359 lines
14 KiB
GDScript
359 lines
14 KiB
GDScript
extends Control
|
|
## Leaderboard panel — reads from Nakama native leaderboard (global_high_score).
|
|
## Left: sortable leaderboard list.
|
|
## Right: 3D SubViewport character preview of the selected/top-ranked player.
|
|
|
|
signal closed
|
|
|
|
# -------------------------------------------------------------------------
|
|
# UI References
|
|
# -------------------------------------------------------------------------
|
|
@onready var back_btn := %BackBtn as Button
|
|
@onready var refresh_btn := %RefreshBtn as Button
|
|
@onready var sort_score_btn := %SortScoreBtn as Button
|
|
@onready var sort_win_rate_btn := %SortWinRateBtn as Button
|
|
@onready var sort_games_btn := %SortGamesBtn as Button
|
|
@onready var leaderboard_list := %LeaderboardList as VBoxContainer
|
|
@onready var status_label := %StatusLabel as Label
|
|
@onready var item_template := %ItemTemplate as PanelContainer
|
|
|
|
# 3D Preview
|
|
@onready var character_root := %CharacterRoot as Node3D
|
|
@onready var selected_name_label := %SelectedNameLabel as Label
|
|
@onready var selected_rank_label := %SelectedRankLabel as Label
|
|
@onready var selected_score_label := %SelectedScoreLabel as Label
|
|
@onready var selected_avatar_rect := %SelectedAvatarRect as TextureRect
|
|
|
|
# -------------------------------------------------------------------------
|
|
# State
|
|
# -------------------------------------------------------------------------
|
|
var leaderboard_data: Array = []
|
|
var current_sort_key: String = "high_score"
|
|
var current_selected_index: int = 0
|
|
var _anim_player: AnimationPlayer
|
|
|
|
# Maps game character name -> GLB node name in the SubViewport
|
|
const CHAR_NODE_MAP: Dictionary = {
|
|
"Copper": "Oldpop",
|
|
"Dabro": "Masbro",
|
|
"Gatot": "Gatot",
|
|
"Pip": "Bob"
|
|
}
|
|
# Avatar index -> character name (same order as UserProfileManager.AVATARS)
|
|
const AVATAR_TO_CHAR: Array[String] = ["Pip", "Gatot", "Dabro", "Copper"]
|
|
|
|
func _ready() -> void:
|
|
back_btn.pressed.connect(_on_close_pressed)
|
|
refresh_btn.pressed.connect(_fetch_leaderboard_data)
|
|
|
|
sort_score_btn.pressed.connect(func(): _sort_by("high_score"))
|
|
sort_win_rate_btn.pressed.connect(func(): _sort_by("win_rate"))
|
|
sort_games_btn.pressed.connect(func(): _sort_by("games_played"))
|
|
_update_tab_visuals()
|
|
_setup_3d_preview()
|
|
|
|
if item_template:
|
|
item_template.hide()
|
|
|
|
# Listen to profile and stats changes to keep the panel updated
|
|
UserProfileManager.profile_updated.connect(_on_profile_or_stats_changed)
|
|
UserProfileManager.stats_updated.connect(_on_profile_or_stats_changed)
|
|
UserProfileManager.avatar_changed.connect(func(_url): _on_profile_or_stats_changed())
|
|
|
|
func _on_profile_or_stats_changed() -> void:
|
|
if visible:
|
|
_fetch_leaderboard_data()
|
|
|
|
# -------------------------------------------------------------------------
|
|
# Show / Close
|
|
# -------------------------------------------------------------------------
|
|
func show_panel() -> void:
|
|
show()
|
|
status_label.text = "Syncing scores..."
|
|
# Bulk-sync all users' storage stats to native leaderboard (server-side operation)
|
|
if NakamaManager.session:
|
|
var sync_result = await NakamaManager.client.rpc_async(NakamaManager.session, "sync_leaderboard", "{}")
|
|
if sync_result.is_exception():
|
|
push_error("[Leaderboard] sync_leaderboard RPC failed: ", sync_result.get_exception().message)
|
|
else:
|
|
print("[Leaderboard] Server sync finished: ", sync_result.payload)
|
|
_fetch_leaderboard_data()
|
|
|
|
func _on_close_pressed() -> void:
|
|
hide()
|
|
emit_signal("closed")
|
|
|
|
# -------------------------------------------------------------------------
|
|
# Data
|
|
# -------------------------------------------------------------------------
|
|
func _fetch_leaderboard_data() -> void:
|
|
if not NakamaManager.session:
|
|
status_label.text = "Not connected to Nakama"
|
|
return
|
|
|
|
status_label.text = "Fetching Leaderboard..."
|
|
status_label.show()
|
|
for child in leaderboard_list.get_children():
|
|
if child != item_template:
|
|
child.queue_free()
|
|
|
|
# Try native Nakama leaderboard first (fastest, ranked already)
|
|
var native_data = await _fetch_native_leaderboard()
|
|
|
|
if native_data.size() > 0:
|
|
_apply_local_overrides(native_data)
|
|
leaderboard_data = native_data
|
|
_calculate_win_rates()
|
|
status_label.text = ""
|
|
_sort_by(current_sort_key)
|
|
if leaderboard_data.size() > 0:
|
|
_show_entry_preview(0)
|
|
else:
|
|
# Fallback: try the server RPC (reads same native leaderboard)
|
|
await _fetch_via_rpc()
|
|
|
|
func _fetch_native_leaderboard() -> Array:
|
|
"""Use the Nakama client API to list native leaderboard records directly."""
|
|
var result = await NakamaManager.client.list_leaderboard_records_async(
|
|
NakamaManager.session,
|
|
"global_high_score",
|
|
[], # no specific owner filter
|
|
null, # expiry = null (no filter)
|
|
100 # limit
|
|
)
|
|
|
|
if result.is_exception():
|
|
push_warning("[Leaderboard] Native API failed: ", result.get_exception().message)
|
|
return []
|
|
|
|
var data: Array = []
|
|
for record in result.records:
|
|
var meta: Dictionary = {}
|
|
if record.metadata and not record.metadata.is_empty():
|
|
var parsed = JSON.parse_string(record.metadata)
|
|
if parsed is Dictionary:
|
|
meta = parsed
|
|
if record.owner_id == NakamaManager.session.user_id:
|
|
print("[Leaderboard] Local player meta: ", meta)
|
|
|
|
data.append({
|
|
"user_id": record.owner_id,
|
|
"display_name": record.username if (record.username and not record.username.is_empty()) else "Unknown",
|
|
"avatar_url": meta.get("avatar_url", ""),
|
|
"loadout_character": meta.get("loadout_character", "Copper"),
|
|
"high_score": int(record.score),
|
|
"games_played": int(meta.get("games_played", 0)),
|
|
"games_won": int(meta.get("games_won", 0)),
|
|
"rank": int(record.rank)
|
|
})
|
|
return data
|
|
|
|
func _fetch_via_rpc() -> void:
|
|
"""Fallback: call server RPC which reads the same native leaderboard."""
|
|
var result = await NakamaManager.client.rpc_async(NakamaManager.session, "get_leaderboard_stats", "{}")
|
|
|
|
if result.is_exception():
|
|
status_label.text = "Failed to load leaderboard"
|
|
push_error("[Leaderboard] RPC failed: ", result.get_exception().message)
|
|
return
|
|
|
|
var json := JSON.new()
|
|
if json.parse(result.payload) == OK:
|
|
var data = json.get_data()
|
|
if data.has("leaderboard") and data.leaderboard.size() > 0:
|
|
_apply_local_overrides(data.leaderboard)
|
|
leaderboard_data = data.leaderboard
|
|
_calculate_win_rates()
|
|
status_label.text = ""
|
|
_sort_by(current_sort_key)
|
|
if leaderboard_data.size() > 0:
|
|
_show_entry_preview(0)
|
|
else:
|
|
# No records exist yet — show a helpful hint
|
|
status_label.text = "No scores recorded yet.\nPlay a match to appear here!"
|
|
else:
|
|
status_label.text = "Error parsing server data"
|
|
|
|
func _calculate_win_rates() -> void:
|
|
for entry in leaderboard_data:
|
|
var played = entry.get("games_played", 0)
|
|
var won = entry.get("games_won", 0)
|
|
entry["win_rate"] = float(won) / float(played) * 100.0 if played > 0 else 0.0
|
|
|
|
func _apply_local_overrides(data: Array) -> void:
|
|
if not NakamaManager.session:
|
|
return
|
|
var my_id = NakamaManager.session.user_id
|
|
for entry in data:
|
|
if entry.get("user_id") == my_id:
|
|
entry["display_name"] = UserProfileManager.get_display_name(entry.get("display_name", "Unknown"))
|
|
entry["avatar_url"] = UserProfileManager.get_avatar_url()
|
|
entry["loadout_character"] = UserProfileManager.profile.get("loadout_character", entry.get("loadout_character", "Copper"))
|
|
|
|
var local_score = UserProfileManager.stats.get("high_score", 0)
|
|
if local_score >= entry.get("high_score", 0):
|
|
entry["high_score"] = local_score
|
|
|
|
var local_played = UserProfileManager.stats.get("games_played", 0)
|
|
if local_played >= entry.get("games_played", 0):
|
|
entry["games_played"] = local_played
|
|
|
|
var local_won = UserProfileManager.stats.get("games_won", 0)
|
|
if local_won >= entry.get("games_won", 0):
|
|
entry["games_won"] = local_won
|
|
|
|
# -------------------------------------------------------------------------
|
|
# Sorting / Display
|
|
# -------------------------------------------------------------------------
|
|
func _sort_by(key: String) -> void:
|
|
current_sort_key = key
|
|
current_selected_index = 0
|
|
_update_tab_visuals()
|
|
leaderboard_data.sort_custom(func(a, b): return a.get(key, 0) > b.get(key, 0))
|
|
_populate_list()
|
|
|
|
func _update_tab_visuals() -> void:
|
|
var color_active = Color(0.647, 0.996, 0.224, 1)
|
|
var color_inactive = Color(0.69, 0.529, 0.357, 1)
|
|
sort_score_btn.add_theme_color_override("font_color", color_active if current_sort_key == "high_score" else color_inactive)
|
|
sort_win_rate_btn.add_theme_color_override("font_color", color_active if current_sort_key == "win_rate" else color_inactive)
|
|
sort_games_btn.add_theme_color_override("font_color", color_active if current_sort_key == "games_played" else color_inactive)
|
|
|
|
# Make the background of unselected tabs visibly darker via modulate so they contrast against the active yellow background
|
|
sort_score_btn.self_modulate = Color(1, 1, 1) if current_sort_key == "high_score" else Color(0.5, 0.5, 0.5)
|
|
sort_win_rate_btn.self_modulate = Color(1, 1, 1) if current_sort_key == "win_rate" else Color(0.5, 0.5, 0.5)
|
|
sort_games_btn.self_modulate = Color(1, 1, 1) if current_sort_key == "games_played" else Color(0.5, 0.5, 0.5)
|
|
|
|
func _populate_list() -> void:
|
|
for child in leaderboard_list.get_children():
|
|
if child != item_template:
|
|
child.queue_free()
|
|
|
|
if leaderboard_data.size() == 0:
|
|
status_label.text = "No players found.\nPlay a match to appear here!"
|
|
status_label.show()
|
|
return
|
|
|
|
status_label.hide()
|
|
for i in range(leaderboard_data.size()):
|
|
var entry = leaderboard_data[i]
|
|
_create_leaderboard_item(i + 1, entry, i)
|
|
|
|
func _create_leaderboard_item(rank: int, entry: Dictionary, index: int) -> void:
|
|
var item = item_template.duplicate()
|
|
item.show()
|
|
|
|
var style: StyleBoxFlat
|
|
if item.has_theme_stylebox_override("panel"):
|
|
style = item.get_theme_stylebox("panel").duplicate()
|
|
else:
|
|
style = StyleBoxFlat.new()
|
|
style.bg_color = Color(0.25, 0.3, 0.35, 1.0)
|
|
style.set_corner_radius_all(8)
|
|
|
|
if index == current_selected_index:
|
|
style.bg_color = Color(0.35, 0.45, 0.30, 1.0)
|
|
else:
|
|
style.bg_color = Color(0.25, 0.3, 0.35, 1.0)
|
|
|
|
item.add_theme_stylebox_override("panel", style)
|
|
|
|
var rank_label = item.get_node("HBoxContainer/RankLabel") as Label
|
|
if rank_label:
|
|
var rank_suffix = "th"
|
|
if rank % 10 == 1 and rank % 100 != 11: rank_suffix = "st"
|
|
elif rank % 10 == 2 and rank % 100 != 12: rank_suffix = "nd"
|
|
elif rank % 10 == 3 and rank % 100 != 13: rank_suffix = "rd"
|
|
rank_label.text = str(rank) + rank_suffix
|
|
|
|
match rank:
|
|
1: rank_label.add_theme_color_override("font_color", Color.GOLD)
|
|
2: rank_label.add_theme_color_override("font_color", Color.SILVER)
|
|
3: rank_label.add_theme_color_override("font_color", Color.DARK_ORANGE)
|
|
_: rank_label.add_theme_color_override("font_color", Color.WHITE)
|
|
|
|
var avatar_rect = item.get_node("HBoxContainer/Margin/InnerHBox/AvatarRect") as TextureRect
|
|
if avatar_rect:
|
|
var avatar_url = entry.get("avatar_url", "")
|
|
if avatar_url.is_empty() or not ResourceLoader.exists(avatar_url):
|
|
avatar_url = UserProfileManager.AVATARS[0]
|
|
avatar_rect.texture = load(avatar_url)
|
|
|
|
var name_label = item.get_node("HBoxContainer/Margin/InnerHBox/NameLabel") as Label
|
|
if name_label:
|
|
name_label.text = entry.get("display_name", "Unknown")
|
|
|
|
var value_label = item.get_node("HBoxContainer/ValueLabel") as Label
|
|
if value_label:
|
|
match current_sort_key:
|
|
"high_score": value_label.text = str(entry.get("high_score", 0))
|
|
"win_rate": value_label.text = "%.1f%%" % entry.get("win_rate", 0.0)
|
|
"games_played": value_label.text = str(entry.get("games_played", 0))
|
|
|
|
leaderboard_list.add_child(item)
|
|
|
|
item.gui_input.connect(func(event: InputEvent):
|
|
if event is InputEventMouseButton and event.pressed and event.button_index == MOUSE_BUTTON_LEFT:
|
|
current_selected_index = index
|
|
_populate_list()
|
|
_show_entry_preview(index)
|
|
)
|
|
item.mouse_filter = Control.MOUSE_FILTER_STOP
|
|
|
|
# -------------------------------------------------------------------------
|
|
# 3D Preview
|
|
# -------------------------------------------------------------------------
|
|
func _setup_3d_preview() -> void:
|
|
if not character_root:
|
|
return
|
|
_anim_player = character_root.get_node_or_null("AnimationPlayer")
|
|
|
|
func _show_entry_preview(index: int) -> void:
|
|
if index >= leaderboard_data.size():
|
|
return
|
|
var entry = leaderboard_data[index]
|
|
|
|
# Determine character from metadata or avatar_url index
|
|
var char_name: String = entry.get("loadout_character", "")
|
|
|
|
if char_name.is_empty():
|
|
var avatar_url: String = entry.get("avatar_url", "")
|
|
char_name = "Copper"
|
|
for i in range(UserProfileManager.AVATARS.size()):
|
|
if UserProfileManager.AVATARS[i] == avatar_url:
|
|
char_name = AVATAR_TO_CHAR[i] if i < AVATAR_TO_CHAR.size() else "Copper"
|
|
break
|
|
|
|
_update_3d_preview(char_name)
|
|
|
|
var display_name: String = entry.get("display_name", "Unknown")
|
|
var rank := index + 1
|
|
if selected_name_label: selected_name_label.text = display_name
|
|
if selected_rank_label: selected_rank_label.text = "Rank #%d" % rank
|
|
if selected_score_label:
|
|
match current_sort_key:
|
|
"high_score": selected_score_label.text = str(entry.get("high_score", 0))
|
|
"win_rate": selected_score_label.text = "%.1f%%" % entry.get("win_rate", 0.0)
|
|
"games_played": selected_score_label.text = str(entry.get("games_played", 0))
|
|
if selected_avatar_rect:
|
|
var avatar_url2 = entry.get("avatar_url", "")
|
|
if avatar_url2.is_empty() or not ResourceLoader.exists(avatar_url2):
|
|
avatar_url2 = UserProfileManager.AVATARS[0]
|
|
selected_avatar_rect.texture = load(avatar_url2)
|
|
|
|
func _update_3d_preview(character_name: String) -> void:
|
|
if not character_root:
|
|
return
|
|
var node_name: String = CHAR_NODE_MAP.get(character_name, "Masbro")
|
|
for child in character_root.get_children():
|
|
if child is Node3D:
|
|
child.visible = (child.name == node_name)
|
|
if _anim_player:
|
|
var new_root := character_root.get_node_or_null(node_name)
|
|
if new_root:
|
|
_anim_player.root_node = new_root.get_path()
|
|
if _anim_player.has_animation("animation-pack/idle"):
|
|
_anim_player.play("animation-pack/idle")
|
|
elif _anim_player.get_animation_list().size() > 0:
|
|
_anim_player.play(_anim_player.get_animation_list()[0])
|