Files
sor/Client/origin-client/scenes/game/game_screen.gd
T
51f3ee23d4 Feature: tile height variation + stalagmite bottoms + live content refresh
## Tile height variation (fix)
Tile tops now visibly vary (0.8–1.0) from a fixed bottom at world Y=0.
Previously the top was fixed and the variation was only visible underneath.
Heights are seeded by tile coordinate so they're deterministic per board.
Unit y_offsets and highlight positions update to match per-tile height.

## Stalagmite tile bottoms
Server: new TileBottomModel entity + migration (catalog.tile_bottom_models),
content.tile_bottoms handler returns all active CDN URLs.
Admin: "Tile Bottom Models" section in the Tile Model Manager page —
  add/toggle active/delete entries with CDN picker.
Client: ContentCache fetches + disk-caches the URL pool; _try_load_tile_model
  picks a random URL and attaches it flipped below the tile model as a
  stalagmite using the existing _fit_model_to_tile scale logic.

## Live content refresh
ContentCache schedules start_sync() every 5 minutes after sync_complete so
card definitions, tile models, and bottom models are refreshed in the
background without restarting the client.

Generated with [Claude Code](https://claude.ai/code)
via [Happy](https://happy.engineering)

Co-Authored-By: Claude <noreply@anthropic.com>
Co-Authored-By: Happy <yesreply@happy.engineering>
2026-03-16 15:05:48 -04:00

2558 lines
101 KiB
GDScript

extends Node3D
## GameScreen — 3D ranked game board with 2D HUD overlay.
##
## Selection modes:
## NONE — nothing selected
## CARD_FROM_HAND — hand card selected, waiting for tile target
## TERRAMORPHA_SELECT — accumulating tile targets for a Terramorpha card
## UNIT_SELECTED — friendly unit selected, shows move/attack ranges
## PLACEMENT — placing ArchSpirit during Placement phase
## SACRIFICE_SELECT — waiting for the player to pick a spirit to sacrifice
## ABILITY_TARGET — waiting for ability target (blue highlights)
# ── Selection mode ────────────────────────────────────────────────────────────
enum Mode {
NONE,
CARD_FROM_HAND,
TERRAMORPHA_SELECT,
UNIT_SELECTED,
PLACEMENT,
SACRIFICE_SELECT,
ABILITY_TARGET,
}
# ── Node refs ─────────────────────────────────────────────────────────────────
@onready var _camera_rig : Node3D = $CameraRig
@onready var _camera : Camera3D = $CameraRig/Camera3D
@onready var _tiles_root : Node3D = $BoardRoot/TilesRoot
@onready var _units_root : Node3D = $BoardRoot/UnitsRoot
@onready var _hi_root : Node3D = $BoardRoot/HighlightsRoot
@onready var _hold_timer : Timer = $HoldTimer
# HUD
@onready var _phase_lbl : Label = %PhaseLabel
@onready var _turn_lbl : Label = %TurnLabel
@onready var _opp_name_lbl : Label = %OppNameLabel
@onready var _opp_hand_lbl : Label = %OppHandLabel
@onready var _opp_deck_lbl : Label = %OppDeckLabel
@onready var _opp_discard_btn : Button = %OppDiscardBtn
@onready var _hand_cards : HBoxContainer = %HandCards
@onready var _sp_lbl : Label = %SpLabel
@onready var _st_lbl : Label = %StLabel
@onready var _deck_lbl : Label = %DeckLabel
@onready var _discard_btn : Button = %DiscardBtn
@onready var _draw_btn : Button = %DrawBtn
@onready var _end_turn_btn : Button = %EndTurnBtn
@onready var _settings_btn : Button = %SettingsBtn
@onready var _in_game_settings: PanelContainer = %InGameSettings
@onready var _ctx_popup : PanelContainer = %ContextPopup
@onready var _ctx_tile_lbl : Label = %ContextTileLabel
@onready var _ctx_unit_lbl : Label = %ContextUnitLabel
@onready var _ctx_abil_lbl : Label = %ContextAbilitiesLabel
@onready var _ctx_close_btn : Button = %ContextClose
@onready var _dv_overlay : PanelContainer = %DiscardViewer
@onready var _dv_title : Label = %DVTitle
@onready var _dv_list : VBoxContainer = %DVList
@onready var _dv_close_btn : Button = %DVCloseBtn
@onready var _go_overlay : PanelContainer = %GameOverOverlay
@onready var _go_result_lbl : Label = %GOResultLabel
@onready var _go_rank_lbl : Label = %GORankLabel
@onready var _go_menu_btn : Button = %GOMainMenuBtn
@onready var _hud : CanvasLayer = $HUD
@onready var _hand_area : PanelContainer = $HUD/HandArea
var count : int = 0
var _cam_tween : Tween = null
var _last_click_frame : int = -1
var _last_click_iid : String = ""
# ── Affinity colors ───────────────────────────────────────────────────────────
const AFFINITY_COLORS : Dictionary = {
"Void": Color(0.18, 0.18, 0.22),
"Aether": Color(0.60, 0.45, 0.85),
"Lake": Color(0.28, 0.52, 0.88),
"Hill": Color(0.58, 0.44, 0.26),
"Forest": Color(0.22, 0.52, 0.24),
"Field": Color(0.62, 0.72, 0.28),
"Ocean": Color(0.10, 0.20, 0.72),
"Island": Color(0.38, 0.68, 0.84),
"Marsh": Color(0.38, 0.52, 0.34),
"Swamp": Color(0.24, 0.33, 0.20),
"Mountain": Color(0.50, 0.44, 0.38),
"Steppe": Color(0.72, 0.63, 0.38),
"Fort": Color(0.40, 0.34, 0.30),
"Plains": Color(0.78, 0.74, 0.50),
"Grove": Color(0.33, 0.58, 0.28),
"Jungle": Color(0.15, 0.42, 0.20),
"PerfectAether": Color(0.88, 0.72, 1.00),
"PureVoid": Color(0.05, 0.05, 0.10),
"UnstableAether":Color(0.70, 0.55, 0.90),
"GatewayLake": Color(0.22, 0.42, 0.70),
"GatewayHill": Color(0.46, 0.34, 0.18),
"GatewayForest": Color(0.18, 0.42, 0.18),
"GatewayField": Color(0.52, 0.60, 0.22),
}
const _CARD_WIDGET_SCENE := preload("res://scenes/collection/components/CardWidget.tscn")
const _CHAT_OVERLAY_SCENE := preload("res://scenes/chat/ChatOverlay.tscn")
const HI_GREEN := Color(0.20, 0.90, 0.20, 0.40)
const HI_RED := Color(1.00, 0.25, 0.25, 0.50)
const HI_BLUE := Color(0.20, 0.50, 1.00, 0.40)
const HI_YELLOW := Color(1.00, 0.85, 0.10, 0.50)
const HI_ORANGE := Color(1.00, 0.60, 0.10, 0.45)
# ── Camera state ──────────────────────────────────────────────────────────────
var _cam_yaw : float = 0.0
var _cam_pitch : float = 40.0
var _cam_distance : float = 14.0
var _cam_pivot : Vector3 = Vector3.ZERO
var _drag_active : bool = false
var _press_was_on_board: bool = false # true only when the PRESS came from unhandled_input (board, not a UI card)
var _camera_oriented : bool = false
var _pan_active : bool = false
var _last_mouse : Vector2 = Vector2.ZERO
var _touch_points : Dictionary = {}
var _pinch_dist : float = 0.0
# ── Selection state ───────────────────────────────────────────────────────────
var _mode : Mode = Mode.NONE
var _sel_card_id : String = ""
var _sel_unit_id : String = ""
var _held_coord : Vector2i = Vector2i(-1, -1)
# Terramorpha
var _terra_targets : Array = [] # Array[Vector2i]
var _terra_count : int = 0 # total tiles needed (1/2/3)
# Sacrifice
var _sac_arch_coord : Vector2i = Vector2i(-1, -1)
# Ability
var _ability_unit_id : String = ""
var _ability_idx : int = -1
var _ability_panel : Control = null
var _ability_def : Array = [] # Actions array from parsed ability JSON
var _ability_range : Dictionary = {} # Top-level range {min, max} from ability definition
var _ability_targets : Array = [] # collected AbilityTarget dicts to send
var _ability_cur_action_idx : int = 0 # which Action we are currently collecting for
var _player_panel : Control = null
# ── Unit ownership lookup ─────────────────────────────────────────────────────
# Rebuilt on each state update for O(1) ownership checks.
var _enemy_unit_ids : Dictionary = {} # instanceId → true
var _friendly_unit_ids: Dictionary = {} # instanceId → true
# ── Scene refs ────────────────────────────────────────────────────────────────
var _tile_bodies : Dictionary = {} # "x,y" → StaticBody3D
var _unit_meshes : Dictionary = {} # instanceId → Node3D (placeholder or real model)
var _unit_bodies : Dictionary = {} # instanceId → StaticBody3D
var _anim_players : Dictionary = {} # instanceId → AnimationPlayer (null if none)
var _unit_def_ids : Dictionary = {} # instanceId → card definition ID string
# ── Animation / facing state ───────────────────────────────────────────────────
var _local_is_p1 : bool = false # true when Auth.user_id == playerOneAccountId
var _prev_unit_hp : Dictionary = {} # instanceId → int, HP snapshot for damage detection
var _prev_unit_pos: Dictionary = {} # instanceId → Vector2i, position snapshot for move detection
var _move_anims : Dictionary = {} # instanceId → Tween (active movement tweens)
var _last_attack_target_iid : String = "" # target of the most recent send_attack() call
var _tile_heights : Dictionary = {} # "x,y" → float, world Y of tile top surface
# Delayed rebuild: when animations need time to play we don't destroy unit nodes immediately.
var _pending_rebuild : Dictionary = {} # latest state waiting for the delayed rebuild
var _rebuild_tween : Tween = null
## Seconds per grid step when animating unit movement along the BFS path.
const MOVE_STEP_SECS : float = 0.28
## How long to hold after one-shot animations (attack / damaged / dying) before rebuilding.
const POST_ANIM_SECS : float = 1.2
## Seconds to skip at the start of looping animations on subsequent loop iterations.
## GLB animations use the first N frames as a transition-in from idle; on repeat loops
## we jump past them to avoid the bind-pose flash.
const ANIM_TRANSITION_SECS : float = 5.0 / 30.0 # 5 frames at 30 fps
# Per-unit animation loop tracking.
var _idle_entry_done : Dictionary = {} # iid → true once the first idle entry has played
var _idle_callbacks : Dictionary = {} # iid → Callable (active loop reconnect, to cancel on interrupt)
var _oneshot_callbacks : Dictionary = {} # iid → Callable (animation_finished → next action, replaceable)
# Per-unit model config.
var _model_base_angles : Dictionary = {} # iid → float (base facing angle, radians)
var _needs_face_rot : Dictionary = {} # iid → bool (team-based 180° flip flag)
## Animation name aliases: maps the canonical lower-case action to fallback track names.
## The AnimationPlayer track list is matched case-insensitively against each entry.
const ANIM_ALIASES : Dictionary = {
"idle": ["idle", "idle_a", "idle1", "idle_loop"],
"attack": ["attack", "attack_a", "attack1", "attack_b", "strike"],
"damaged": ["damaged", "attacked", "hit", "hurt", "flinch"],
"dying": ["dying", "death", "die", "dead"],
"moving": ["moving", "move", "walk", "run", "walk_cycle"],
}
# ── Lifecycle ─────────────────────────────────────────────────────────────────
func _ready() -> void:
_setup_environment()
_apply_camera()
_draw_btn.pressed.connect(_on_draw_pressed)
_end_turn_btn.pressed.connect(_on_end_turn_pressed)
_settings_btn.pressed.connect(func() -> void: _in_game_settings.open())
_discard_btn.pressed.connect(func() -> void: _show_own_discard())
_opp_discard_btn.pressed.connect(func() -> void: _show_opp_discard())
_ctx_close_btn.pressed.connect(func() -> void: _ctx_popup.visible = false)
_dv_close_btn.pressed.connect(func() -> void: _dv_overlay.visible = false)
_go_menu_btn.pressed.connect(func() -> void:
get_tree().change_scene_to_file("res://scenes/main/MainScreen.tscn"))
_hold_timer.timeout.connect(_on_hold_timer_fired)
# Chat overlay — add to viewport root so it renders above everything.
var _chat_overlay := _CHAT_OVERLAY_SCENE.instantiate()
get_tree().get_root().add_child(_chat_overlay)
Game.state_updated.connect(_on_state_updated)
Game.game_over.connect(_on_game_over)
Game.session_abandoned.connect(_on_session_abandoned)
if not Game.state.is_empty():
_on_state_updated(Game.state)
else:
Game.send_ready()
func _exit_tree() -> void:
if Game.state_updated.is_connected(_on_state_updated):
Game.state_updated.disconnect(_on_state_updated)
if Game.game_over.is_connected(_on_game_over):
Game.game_over.disconnect(_on_game_over)
if Game.session_abandoned.is_connected(_on_session_abandoned):
Game.session_abandoned.disconnect(_on_session_abandoned)
# Remove chat overlay added to the viewport root.
var root := get_tree().get_root()
for child in root.get_children():
if child.name == "ChatOverlay":
child.queue_free()
# ── Environment ───────────────────────────────────────────────────────────────
func _setup_environment() -> void:
var env := Environment.new()
var sky := Sky.new()
var proc := ProceduralSkyMaterial.new()
proc.sky_top_color = Color(0.08, 0.10, 0.20)
proc.sky_horizon_color = Color(0.28, 0.38, 0.55)
proc.ground_bottom_color = Color(0.373, 0.374, 0.484, 1.0)
proc.ground_horizon_color = Color(0.20, 0.28, 0.38)
sky.sky_material = proc
env.background_mode = Environment.BG_SKY
env.sky = sky
env.ambient_light_source = Environment.AMBIENT_SOURCE_SKY
env.ambient_light_energy = 0.6
$WorldEnvironment.environment = env
# ── Camera ────────────────────────────────────────────────────────────────────
func _apply_camera() -> void:
var pitch_rad := deg_to_rad(_cam_pitch)
_camera_rig.position = _cam_pivot
_camera_rig.rotation_degrees = Vector3(0.0, _cam_yaw, 0.0)
_camera.position = Vector3(0.0,
_cam_distance * sin(pitch_rad),
_cam_distance * cos(pitch_rad))
_camera.rotation_degrees = Vector3(-_cam_pitch, 0.0, 0.0)
func _zoom(delta: float) -> void:
_cam_distance = clampf(_cam_distance - delta, 4.0, 22.0)
_apply_camera()
# ── Input ─────────────────────────────────────────────────────────────────────
func _unhandled_input(event: InputEvent) -> void:
if event is InputEventMouseButton:
var mb := event as InputEventMouseButton
if mb.button_index == MOUSE_BUTTON_WHEEL_UP:
if _hand_area.get_global_rect().has_point(mb.position): return
_zoom(1.5); return
elif mb.button_index == MOUSE_BUTTON_WHEEL_DOWN:
if _hand_area.get_global_rect().has_point(mb.position): return
_zoom(-1.5); return
elif mb.button_index == MOUSE_BUTTON_MIDDLE:
_pan_active = mb.pressed
_last_mouse = mb.position
elif mb.button_index == MOUSE_BUTTON_LEFT:
if mb.pressed:
# Double-click on a battlefield unit → show full card detail popup.
if mb.double_click:
var dbl_unit_id := _mouse_to_unit_id(mb.position)
if not dbl_unit_id.is_empty():
_show_unit_detail_popup(dbl_unit_id)
return
_last_mouse = mb.position
_drag_active = false
_press_was_on_board = true # unhandled press = board area, not a UI card
var coord := _mouse_to_tile_coord(mb.position)
if coord.x >= 0:
_held_coord = coord
_hold_timer.start()
else:
_held_coord = Vector2i(-1, -1)
else:
_hold_timer.stop()
if not _drag_active and _press_was_on_board:
_handle_board_click(mb.position)
_drag_active = false
_press_was_on_board = false
elif event is InputEventMouseMotion:
var mm := event as InputEventMouseMotion
var delta := mm.position - _last_mouse
_last_mouse = mm.position
if mm.button_mask & MOUSE_BUTTON_MASK_LEFT:
if delta.length() > 2.0:
_drag_active = true
_hold_timer.stop()
if _drag_active:
_cam_yaw -= delta.x * 0.4
_cam_pitch = clampf(_cam_pitch + delta.y * 0.3, 15.0, 75.0)
_apply_camera()
if _pan_active:
var ps := _cam_distance * 0.0015
var right := _camera_rig.global_basis.x * -delta.x * ps
var fwd := Vector3(_camera_rig.global_basis.z.x, 0,
_camera_rig.global_basis.z.z).normalized()
_cam_pivot += right + fwd * delta.y * ps
_cam_pivot.x = clampf(_cam_pivot.x, -6.0, 6.0)
_cam_pivot.z = clampf(_cam_pivot.z, -6.0, 6.0)
_apply_camera()
elif event is InputEventScreenTouch:
var st := event as InputEventScreenTouch
if st.pressed:
_touch_points[st.index] = st.position
if _touch_points.size() == 2:
_pinch_dist = _touch_pair_dist()
_hold_timer.stop()
else:
_touch_points.erase(st.index)
elif event is InputEventScreenDrag:
var sd := event as InputEventScreenDrag
_touch_points[sd.index] = sd.position
if _touch_points.size() == 1:
_cam_yaw -= sd.relative.x * 0.4
_cam_pitch = clampf(_cam_pitch + sd.relative.y * 0.3, 15.0, 75.0)
_apply_camera()
if sd.relative.length() > 2.0:
_hold_timer.stop()
elif _touch_points.size() == 2:
var keys := _touch_points.keys()
var pos_a : Vector2 = _touch_points[keys[0]]
var pos_b : Vector2 = _touch_points[keys[1]]
var mid := (pos_a + pos_b) * 0.5
var nd := pos_a.distance_to(pos_b)
_zoom((nd - _pinch_dist) * 0.03)
_pinch_dist = nd
var ps := _cam_distance * 0.002
var cdelta := mid - _last_mouse
_last_mouse = mid
var right := _camera_rig.global_basis.x * -cdelta.x * ps
var fwd := Vector3(_camera_rig.global_basis.z.x, 0,
_camera_rig.global_basis.z.z).normalized()
_cam_pivot += right + fwd * cdelta.y * ps
_cam_pivot.x = clampf(_cam_pivot.x, -6.0, 6.0)
_cam_pivot.z = clampf(_cam_pivot.z, -6.0, 6.0)
_apply_camera()
func _touch_pair_dist() -> float:
var keys := _touch_points.keys()
if keys.size() < 2: return 0.0
return (_touch_points[keys[0]] as Vector2).distance_to(_touch_points[keys[1]])
# ── Coord helpers ─────────────────────────────────────────────────────────────
func _coord_to_world(x: int, y: int) -> Vector3:
return Vector3(x - (Game.board_width() - 1) * 0.5, 0.0,
y - (Game.board_height() - 1) * 0.5)
func _mouse_to_tile_coord(mouse_pos: Vector2) -> Vector2i:
var body := _raycast_body(mouse_pos)
if body == null: return Vector2i(-1, -1)
if body.has_meta("tile_coord"):
return body.get_meta("tile_coord") as Vector2i
return Vector2i(-1, -1)
func _mouse_to_unit_id(mouse_pos: Vector2) -> String:
var body := _raycast_body(mouse_pos)
if body == null: return ""
if body.has_meta("unit_id"):
return str(body.get_meta("unit_id"))
return ""
func _raycast_body(mouse_pos: Vector2) -> PhysicsBody3D:
var space := get_world_3d().direct_space_state
var from := _camera.project_ray_origin(mouse_pos)
var to := from + _camera.project_ray_normal(mouse_pos) * 100.0
var query := PhysicsRayQueryParameters3D.create(from, to)
var result := space.intersect_ray(query)
if result.is_empty(): return null
return result.get("collider") as PhysicsBody3D
# ── Ownership helpers ─────────────────────────────────────────────────────────
func _is_enemy_unit(instance_id: String) -> bool:
return _enemy_unit_ids.has(instance_id)
func _is_friendly_unit(instance_id: String) -> bool:
return _friendly_unit_ids.has(instance_id)
func _rebuild_ownership(state: Dictionary) -> void:
_enemy_unit_ids.clear()
_friendly_unit_ids.clear()
var my_id := Auth.user_id
for p: Dictionary in state.get("players", []):
var is_mine : bool = str(p.get("accountId", "")).to_lower() == my_id.to_lower()
var target : Dictionary = _enemy_unit_ids if not is_mine else _friendly_unit_ids
for u: Dictionary in p.get("field", []):
var iid : String = u.get("instanceId", "")
if not iid.is_empty(): target[iid] = true
var arch : Dictionary = p.get("archSpirit", {})
var aid : String = arch.get("instanceId", "")
if not aid.is_empty(): target[aid] = true
# ── Board building ────────────────────────────────────────────────────────────
func _build_board(board: Dictionary) -> void:
for c in _tiles_root.get_children(): c.queue_free()
for c in _units_root.get_children(): c.queue_free()
for c in _hi_root.get_children(): c.queue_free()
_tile_bodies.clear()
_unit_meshes.clear()
_unit_bodies.clear()
_tile_heights.clear()
for tile: Dictionary in board.get("tiles", []):
var coord : Dictionary = tile.get("coord", {})
_add_tile(coord.get("x", 0), coord.get("y", 0),
tile.get("resolvedAffinity", "Void"))
func _add_tile(x: int, y: int, affinity: String) -> void:
var wp := _coord_to_world(x, y)
# Deterministic random height per tile (seeded by coord) so the same board
# always produces the same heights. Bottom is fixed at world Y=0; the TOP
# varies between 0.8 and 1.0, giving each tile a distinct elevation visible
# from the camera angle.
var rng := RandomNumberGenerator.new()
rng.seed = hash("%d_%d" % [x, y])
var h : float = rng.randf_range(0.8, 1.0)
_tile_heights["%d,%d" % [x, y]] = h
var body := StaticBody3D.new()
body.position = wp + Vector3(0, h * 0.5, 0) # centre at half-height so bottom = Y 0
body.set_meta("tile_coord", Vector2i(x, y))
body.set_meta("tile_height", h) # used by bottom-model loader
var shape := CollisionShape3D.new()
var box := BoxShape3D.new()
box.size = Vector3(0.98, h, 0.98)
shape.shape = box
body.add_child(shape)
# Placeholder: affinity-coloured flat box, swapped out if a 3D model loads.
var mi := MeshInstance3D.new()
var bm := BoxMesh.new()
bm.size = Vector3(0.98, h, 0.98)
mi.mesh = bm
var mat := StandardMaterial3D.new()
mat.albedo_color = AFFINITY_COLORS.get(affinity, Color(0.2, 0.2, 0.2))
mat.roughness = 0.85
mi.material_override = mat
body.add_child(mi)
_tiles_root.add_child(body)
_tile_bodies["%d,%d" % [x, y]] = body
# ── Try to load a 3D tile model for this affinity ──────────────────────
_try_load_tile_model(body, affinity)
## Load (or replace) the 3D model on a tile body for the given affinity.
## Also attaches a random stalagmite bottom model below the tile when available.
## Safe to call any time affinity changes — replaces existing mesh if present.
func _try_load_tile_model(body: StaticBody3D, affinity: String) -> void:
var model_url := ContentCache.get_tile_model_url(affinity, "Square")
if model_url.is_empty():
return
var body_ref : Variant = weakref(body)
ModelCache.load_model(model_url, func(model_node: Node3D) -> void:
var b := body_ref.get_ref() as StaticBody3D
if not is_instance_valid(b):
if model_node != null:
model_node.queue_free()
return
if model_node == null:
return
# Remove any existing mesh (placeholder or previously loaded model),
# but leave the CollisionShape3D so click detection still works.
for child in b.get_children():
if not (child is CollisionShape3D):
child.queue_free()
b.add_child(model_node)
# Scale so the XZ footprint fits the 0.98-unit tile square.
_fit_model_to_tile(model_node, 0.98)
# Attach a random stalagmite bottom model below the tile (if any are configured).
var bottom_url := ContentCache.get_random_tile_bottom_url()
if not bottom_url.is_empty():
_try_load_tile_bottom(body_ref, bottom_url)
)
## Loads a stalagmite bottom model and attaches it below the tile body.
func _try_load_tile_bottom(body_ref: Variant, url: String) -> void:
ModelCache.load_model(url, func(bottom_node: Node3D) -> void:
var b := body_ref.get_ref() as StaticBody3D
if not is_instance_valid(b):
if bottom_node != null:
bottom_node.queue_free()
return
if bottom_node == null:
return
# The body centre is at world Y = h/2. The bottom of the tile is at
# body-local Y = -h/2. Scale the stalagmite to fit the tile footprint,
# then flip it upside-down (scale Y = -1) so it hangs downward, and
# seat its origin at the tile-bottom local position.
var tile_h : float = float(b.get_meta("tile_height", 1.0))
_fit_model_to_tile(bottom_node, 0.98)
bottom_node.scale.y = -absf(bottom_node.scale.y) # flip to hang down
bottom_node.position.y = -tile_h * 0.5 # move to tile bottom
b.add_child(bottom_node)
)
## Scales model so its largest XZ dimension equals `tile_size`, then centres
## it on XZ and seats the bottom at y = 0 in the parent body's local space.
func _fit_model_to_tile(model: Node3D, tile_size: float) -> void:
var aabb := _model_local_aabb(model)
if aabb.size == Vector3.ZERO:
return
var footprint :float = max(aabb.size.x, aabb.size.z)
if footprint <= 0.0:
return
var s := tile_size / footprint
model.scale = Vector3.ONE * s
var c := aabb.get_center()
model.position = Vector3(-c.x * s, -aabb.position.y * s, -c.z * s)
## Returns the combined AABB of all VisualInstance3D descendants expressed
## in the root node's own local coordinate space (before root.scale/position).
func _model_local_aabb(root: Node3D) -> AABB:
var result := AABB()
var first := true
# Each entry: { n: Node3D, x: Transform3D } where x transforms from
# that node's local space to root's local space.
var stack : Array = [{ "n": root, "x": Transform3D.IDENTITY }]
while not stack.is_empty():
var e : Dictionary = stack.pop_back()
var node : Node3D = e["n"]
var xform : Transform3D = e["x"]
if node is VisualInstance3D:
var local_aabb := xform * (node as VisualInstance3D).get_aabb()
result = local_aabb if first else result.merge(local_aabb)
first = false
for child in node.get_children():
if child is Node3D:
stack.push_back({ "n": child, "x": xform * (child as Node3D).transform })
return result
func _update_tile_affinity(x: int, y: int, affinity: String) -> void:
var body := _tile_bodies.get("%d,%d" % [x, y]) as StaticBody3D
if body == null: return
# Update the placeholder colour in case there is no model for this affinity.
for child in body.get_children():
if child is MeshInstance3D:
var mat := child.material_override as StandardMaterial3D
if mat: mat.albedo_color = AFFINITY_COLORS.get(affinity, Color(0.2, 0.2, 0.2))
# Attempt to swap in a real 3D model.
_try_load_tile_model(body, affinity)
# ── Unit meshes ───────────────────────────────────────────────────────────────
func _rebuild_units(state: Dictionary) -> void:
# Kill any in-flight movement tweens.
for iid : String in _move_anims:
var t := _move_anims[iid] as Tween
if t != null: t.kill()
_move_anims.clear()
# ── Incremental rebuild: only remove/add; never recreate unchanged units ──
# Recreating a unit body interrupts its running animation (idle/move/attack),
# causing a one-frame bind-pose flash on every state echo.
# 1. Collect the desired unit set from the new state.
var my_id := Auth.user_id
var desired : Dictionary = {} # iid → {unit, color, is_enemy}
for player: Dictionary in state.get("players", []):
var is_mine : bool = str(player.get("accountId", "")).to_lower() == my_id.to_lower()
var color : Color = Color(0.3, 0.5, 1.0) if is_mine else Color(1.0, 0.35, 0.35)
var arch : Dictionary = player.get("archSpirit", {})
for unit: Dictionary in ([arch] + player.get("field", [])):
if unit.is_empty() or unit.get("position") == null: continue
var iid : String = str(unit.get("instanceId", ""))
if iid.is_empty(): continue
desired[iid] = {"unit": unit, "color": color, "is_enemy": not is_mine}
# 2. Remove units that are no longer on the board.
var to_remove : Array[String] = []
for iid : String in _unit_bodies:
if not desired.has(iid):
to_remove.append(iid)
for iid : String in to_remove:
var body := _unit_bodies[iid] as StaticBody3D
if is_instance_valid(body):
body.queue_free()
_unit_bodies.erase(iid)
_unit_meshes.erase(iid)
_anim_players.erase(iid)
_unit_def_ids.erase(iid)
_idle_entry_done.erase(iid)
_idle_callbacks.erase(iid)
_oneshot_callbacks.erase(iid)
_model_base_angles.erase(iid)
_needs_face_rot.erase(iid)
# 3. Add units not yet present (newly played, or first render after connect).
for iid : String in desired:
if not _unit_bodies.has(iid):
var d := desired[iid] as Dictionary
_add_unit_mesh(d["unit"] as Dictionary, d["color"] as Color, d["is_enemy"] as bool)
func _add_unit_mesh(unit: Dictionary, team_color: Color, is_enemy: bool = false) -> void:
var pd : Dictionary = unit.get("position", {})
if pd.is_empty(): return
var px : int = pd.get("x", 0)
var py : int = pd.get("y", 0)
var wp := _coord_to_world(px, py)
var tile_h : float = _tile_heights.get("%d,%d" % [px, py], 1.0)
var card_type : String = unit.get("cardType", "Spirit")
var iid : String = unit.get("instanceId", "")
var exhausted : bool = unit.get("isExhausted", false)
var body := StaticBody3D.new()
body.set_meta("unit_id", iid)
var shape := CollisionShape3D.new()
var mi := MeshInstance3D.new()
var mat := StandardMaterial3D.new()
mat.roughness = 0.65
var y_offset : float
match card_type:
"ArchSpirit":
var cyl := CylinderMesh.new()
cyl.top_radius = 0.22; cyl.bottom_radius = 0.22; cyl.height = 0.8
mi.mesh = cyl
mat.albedo_color = team_color.lightened(0.25)
mat.emission_enabled = true
mat.emission = team_color * 0.4
var cs := CylinderShape3D.new()
cs.radius = 0.22; cs.height = 0.8
shape.shape = cs
y_offset = tile_h + 0.4
"Ruin":
var bm := BoxMesh.new()
bm.size = Vector3(0.25, 1.0, 0.25)
mi.mesh = bm
mat.albedo_color = Color(0.35, 0.32, 0.30)
var bs := BoxShape3D.new()
bs.size = Vector3(0.25, 1.0, 0.25)
shape.shape = bs
y_offset = tile_h + 0.5
_:
var sm := SphereMesh.new()
sm.radius = 0.28; sm.height = 0.28
mi.mesh = sm
mat.albedo_color = team_color
var ss := SphereShape3D.new()
ss.radius = 0.28
shape.shape = ss
y_offset = tile_h + 0.28
mi.material_override = mat
if exhausted:
mat.albedo_color = mat.albedo_color.darkened(0.45)
body.add_child(shape)
body.add_child(mi)
body.position = wp + Vector3(0, y_offset, 0)
_units_root.add_child(body)
_unit_meshes[iid] = mi
_unit_bodies[iid] = body
# ── Try to load the real 3D model from the card definition ──────────────
var def_id : String = str(unit.get("cardDefinitionId", ""))
if not def_id.is_empty():
_unit_def_ids[iid] = def_id
if def_id.is_empty():
return
var def := ContentCache.get_definition(def_id)
var model_asset := _find_model3d_asset(def)
var model_url := str(model_asset.get("cdnUrl", ""))
if model_url.is_empty():
return
# Asset-level config (model-file specific).
var facing_dir : String = str(model_asset.get("modelFacingDirection", "north"))
# Card-level config (visual identity of this card, not the shared mesh file).
var model_scale : float = float(def.get("modelScale", 1.0))
var tint_str : String = str(def.get("modelTintColor", ""))
var model_tint : Color = Color.WHITE
if not tint_str.is_empty() and tint_str != "null":
model_tint = Color(tint_str)
# Team-based facing: P1 units face +Z (toward P2), P2 units face -Z (toward P1).
# Rotate if: (local is P1 AND friendly) OR (local is P2 AND enemy).
var needs_face_rotation : bool = _local_is_p1 != is_enemy
var base_angle : float = _facing_to_base_angle(facing_dir)
var body_ref : Variant = weakref(body)
ModelCache.load_model(model_url, func(model_node: Node3D) -> void:
# Guard: body may have been freed by a state rebuild before load finished.
var b := body_ref.get_ref() as StaticBody3D
if not is_instance_valid(b):
if model_node != null:
model_node.queue_free()
return
if model_node == null:
return
# Remove the placeholder MeshInstance3D.
for child in b.get_children():
if child is MeshInstance3D:
child.queue_free()
# Apply uniform scale if configured.
if not is_equal_approx(model_scale, 1.0):
model_node.scale = Vector3.ONE * model_scale
# Store per-unit model config for movement facing and idle rotation.
_model_base_angles[iid] = base_angle
_needs_face_rot[iid] = needs_face_rotation
# Apply idle/team rotation (facing toward opponent).
model_node.rotation.y = _idle_rotation(iid)
# Apply multiplicative tint to all StandardMaterial3D surfaces.
_apply_model_tint(model_node, model_tint)
# Position model so its local origin sits at the body's position.
# Skip reset if a move tween is driving this body — it controls position.
if not _move_anims.has(iid):
b.position = wp + Vector3(0, 0.5, 0)
b.add_child(model_node)
_unit_meshes[iid] = model_node
# Find and store the AnimationPlayer, then start the Idle loop.
var ap := _find_animation_player(model_node)
_anim_players[iid] = ap
if ap != null:
_play_unit_anim(iid, "idle", true)
)
## Returns the first Model3D asset dict for a card definition, or {} if none.
func _find_model3d_asset(def: Dictionary) -> Dictionary:
for asset: Variant in def.get("assets", []):
var d := asset as Dictionary
if d == null: continue
if str(d.get("assetType", "")) == "Model3D":
return d
return {}
## Apply a multiplicative colour tint to all StandardMaterial3D surfaces in a
## model subtree. Materials are duplicated per-instance to avoid cross-unit
## bleed. White (default) is a no-op.
func _apply_model_tint(model: Node3D, tint: Color) -> void:
if tint.is_equal_approx(Color.WHITE):
return
var stack : Array = [model]
while not stack.is_empty():
var n = stack.pop_back()
if n is MeshInstance3D:
var mi := n as MeshInstance3D
if mi.mesh != null:
for i in mi.mesh.get_surface_count():
var mat := mi.get_active_material(i)
if mat is StandardMaterial3D:
var dup := mat.duplicate() as StandardMaterial3D
dup.albedo_color = dup.albedo_color * tint
mi.set_surface_override_material(i, dup)
for child in n.get_children():
stack.append(child)
## Recursively find the first AnimationPlayer in a model subtree.
func _find_animation_player(node: Node) -> AnimationPlayer:
if node is AnimationPlayer:
return node as AnimationPlayer
for child in node.get_children():
var found := _find_animation_player(child)
if found != null:
return found
return null
## Case-insensitive track name resolver with fallback aliases.
## Returns the exact track name in the AnimationPlayer, or "" if not found.
## Handles multiple naming conventions exported from DCC tools:
## "Idle" — bare name
## "lib/Idle" — library-prefixed (GLTF named library)
## "Merlock.Attack" — dot-prefixed model name (e.g. Blender action sets)
## "Merlock_IDLE" — underscore-prefixed model name
func _resolve_anim_track(ap: AnimationPlayer, action_lower: String) -> String:
# Try: canonical action name first, then aliases.
var to_try : Array[String] = [action_lower]
for alias: String in ANIM_ALIASES.get(action_lower, []):
if alias != action_lower:
to_try.append(alias)
for candidate: String in to_try:
for full_name: String in ap.get_animation_list():
# Strip library prefix (e.g. "lib/Idle" → "Idle").
var s := full_name.get_slice("/", full_name.get_slice_count("/") - 1)
# 1. Direct match after library strip.
if s.to_lower() == candidate:
return full_name
# 2. Dot-prefix stripped (e.g. "Merlock.Attack" → "Attack" → "attack").
if "." in s:
if s.get_slice(".", s.get_slice_count(".") - 1).to_lower() == candidate:
return full_name
# 3. First-underscore-prefix stripped (e.g. "Merlock_IDLE" → "IDLE" → "idle").
if "_" in s:
if s.substr(s.find("_") + 1).to_lower() == candidate:
return full_name
return ""
## Convert a model's exported facing direction string to a base angle in radians.
## The angle represents atan2(dir.x, -dir.z) for the direction the model faces
## when rotation.y == 0. All animations and movement share this offset.
## GLB models exported from Blender arrive in Godot facing +Z (south) by default,
## so "south" / unset / null all map to PI. Explicitly pass "north" for -Z models.
func _facing_to_base_angle(facing: String) -> float:
match facing.to_lower():
"north": return 0.0 # model faces -Z (Godot's natural forward)
"east": return PI / 2.0
"west": return -PI / 2.0
_: return PI # "south" / default / null — model faces +Z (Blender GLB)
## Returns the rotation.y (radians) that makes a unit's model face its opponent
## across the board, given its stored base angle and team-flip flag.
func _idle_rotation(iid: String) -> float:
var base : float = float(_model_base_angles.get(iid, 0.0))
var flip : bool = bool(_needs_face_rot.get(iid, false))
# flip=true → unit should face +Z (south, toward P2) atan2(0,-1)=π
# flip=false → unit should face -Z (north, toward P1) atan2(0, 1)=0
var dir := Vector3(0, 0, 1) if flip else Vector3(0, 0, -1)
return atan2(dir.x, -dir.z) - base
## Play an animation on a unit by action name. Uses card's AnimationTrackName
## override when set, then falls back to case-insensitive convention matching.
## Pass loop=true for looping animations (e.g. idle, moving).
## GLB convention: the first ANIM_TRANSITION_SECS of any animation are
## "entry frames" that blend from idle into the action. For looping animations
## those frames are played once on entry, then skipped on every subsequent loop.
func _play_unit_anim(iid: String, action: String, loop: bool = false) -> void:
var ap : AnimationPlayer = _anim_players.get(iid, null)
if ap == null or not is_instance_valid(ap):
return
# Resolve via CardAnimationBinding override first.
var def_id : String = _unit_def_ids.get(iid, "")
var desired := action
if not def_id.is_empty():
var override := ContentCache.get_anim_track(def_id, action)
if not override.is_empty():
desired = override
var track := _resolve_anim_track(ap, desired.to_lower())
if track.is_empty():
return
var anim := ap.get_animation(track)
if anim == null:
return
# All animations are managed with LOOP_NONE; looping is handled manually
# so we can seek past the transition frames on subsequent iterations.
anim.loop_mode = Animation.LOOP_NONE
# Disconnect any stale idle loop callback that would restart idle unexpectedly.
if _idle_callbacks.has(iid):
var old_cb := _idle_callbacks[iid] as Callable
if ap.animation_finished.is_connected(old_cb):
ap.animation_finished.disconnect(old_cb)
_idle_callbacks.erase(iid)
# Don't restart the same animation while it's already playing correctly.
if ap.current_animation == track and ap.is_playing():
return
# Starting a non-loop animation: reset entry-done so the NEXT idle play
# uses the transition frames to blend back from the action pose.
if not loop:
_idle_entry_done.erase(iid)
ap.play(track)
if loop:
# On subsequent loop iterations skip the GLB entry frames.
if _idle_entry_done.get(iid, false):
ap.seek(ANIM_TRANSITION_SECS, true)
else:
_idle_entry_done[iid] = true
# Schedule the next loop iteration via animation_finished.
var cb := func(_n: String) -> void: _play_unit_anim(iid, action, true)
ap.animation_finished.connect(cb, CONNECT_ONE_SHOT)
_idle_callbacks[iid] = cb
else:
# For one-shot non-death animations: return to idle via animation_finished.
var action_l := action.to_lower()
var is_death := action_l == "dying" or action_l == "death" or action_l == "die"
if not is_death:
# Disconnect any prior oneshot callback — allows _play_damage_animations to
# replace "return-to-idle" with "play-damaged-then-idle" on an attacking unit.
if _oneshot_callbacks.has(iid):
var old_os := _oneshot_callbacks[iid] as Callable
if ap.animation_finished.is_connected(old_os):
ap.animation_finished.disconnect(old_os)
_oneshot_callbacks.erase(iid)
var os_cb := func(_n: String) -> void: _play_unit_anim(iid, "idle", true)
ap.animation_finished.connect(os_cb, CONNECT_ONE_SHOT)
_oneshot_callbacks[iid] = os_cb
## Returns true if the AnimationPlayer's current track is an "attack" animation.
func _is_attack_track(full_name: String) -> bool:
var s := full_name.get_slice("/", full_name.get_slice_count("/") - 1)
for alias: String in ANIM_ALIASES.get("attack", []):
if s.to_lower() == alias: return true
if "." in s and s.get_slice(".", s.get_slice_count(".") - 1).to_lower() == alias: return true
if "_" in s and s.substr(s.find("_") + 1).to_lower() == alias: return true
return false
## Replaces the pending animation_finished one-shot callback for [param iid].
## Disconnects the previous callback (stored in _oneshot_callbacks) and
## connects [param cb] as a new CONNECT_ONE_SHOT handler.
func _override_oneshot(iid: String, cb: Callable) -> void:
var ap : AnimationPlayer = _anim_players.get(iid, null)
if ap == null or not is_instance_valid(ap):
return
if _oneshot_callbacks.has(iid):
var old_cb := _oneshot_callbacks[iid] as Callable
if ap.animation_finished.is_connected(old_cb):
ap.animation_finished.disconnect(old_cb)
_oneshot_callbacks.erase(iid)
ap.animation_finished.connect(cb, CONNECT_ONE_SHOT)
_oneshot_callbacks[iid] = cb
## Counterattack phase 2: defender plays "attack", then triggers attacker "damaged".
func _play_counter_attack(defender_iid: String, attacker_iid: String) -> void:
if not _unit_bodies.has(defender_iid): return
if not is_instance_valid(_unit_bodies.get(defender_iid) as Node): return
_play_unit_anim(defender_iid, "attack", false)
# After the counter-attack finishes: defender → idle, attacker → damaged.
_override_oneshot(defender_iid, func(_n: String) -> void:
_play_unit_anim(defender_iid, "idle", true)
if _unit_bodies.has(attacker_iid) and \
is_instance_valid(_unit_bodies.get(attacker_iid) as Node):
_play_unit_anim(attacker_iid, "damaged", false)
)
## Full counterattack chain (starts after [param delay] seconds):
## delay → defender "damaged" → defender "attack" → attacker "damaged" + defender "idle"
func _play_counter_chain(defender_iid: String, attacker_iid: String, delay: float) -> void:
var t := create_tween()
t.tween_callback(func() -> void:
if not _unit_bodies.has(defender_iid) or \
not is_instance_valid(_unit_bodies.get(defender_iid) as Node):
return
_play_unit_anim(defender_iid, "damaged", false)
_override_oneshot(defender_iid, func(_n: String) -> void:
_play_counter_attack(defender_iid, attacker_iid)
)
).set_delay(delay)
## Detect HP decreases and unit deaths vs previous state, and fire animations.
##
## Counterattack scenario (attacker AND a second unit both took damage this update):
## delay(attack_remaining) → defender "damaged" → defender "attack" → attacker "damaged"
##
## Simple damage scenario:
## attacker mid-attack + took damage → queue "damaged" behind its attack
## other unit, attack in progress → delay "damaged" by attack_remaining
## no attack in progress → play "damaged" immediately
##
## Returns true if any animation was triggered (used to decide rebuild delay).
func _play_damage_animations(state: Dictionary) -> bool:
if _prev_unit_hp.is_empty():
return false
# ── Find any currently-playing attack animation ──────────────────────────
var attacker_iid : String = ""
var attack_remaining : float = 0.0
for iid: String in _anim_players:
var ap2 : AnimationPlayer = _anim_players[iid] as AnimationPlayer
if ap2 == null or not is_instance_valid(ap2) or not ap2.is_playing(): continue
if _is_attack_track(ap2.current_animation):
attacker_iid = iid
attack_remaining = maxf(0.0,
ap2.current_animation_length - ap2.current_animation_position)
break
# ── Collect who took damage / died ───────────────────────────────────────
var damaged_iids : Dictionary = {}
var seen_iids : Dictionary = {}
for player: Dictionary in state.get("players", []):
for unit: Dictionary in ([player.get("archSpirit", {})] + player.get("field", [])):
if unit.is_empty(): continue
var iid := str(unit.get("instanceId", ""))
var new_hp := int(unit.get("currentHealth", 0))
var old_hp : int = _prev_unit_hp.get(iid, new_hp)
seen_iids[iid] = true
if new_hp < old_hp:
damaged_iids[iid] = true
var dying_iids : Dictionary = {}
for iid: String in _prev_unit_hp:
if not seen_iids.has(iid):
dying_iids[iid] = true
if damaged_iids.is_empty() and dying_iids.is_empty():
return false
# ── Detect counterattack: attacker took damage while mid-attack ─────────
# The defender may have blocked all HP damage (defense stat), so we can't
# rely on them being in damaged_iids. Use the tracked target from the last
# send_attack() call as the primary source, and fall back to any other
# damaged unit if the tracked target isn't available.
var tracked_target : String = _last_attack_target_iid
_last_attack_target_iid = "" # consume; don't bleed into the next update
var is_counterattack : bool = false
var defender_iid : String = ""
if attacker_iid != "" and damaged_iids.has(attacker_iid):
# Prefer the unit we explicitly attacked (works even when they took 0 damage).
if tracked_target != "" and tracked_target != attacker_iid:
defender_iid = tracked_target
else:
# Fallback: any other damaged unit (original behaviour).
for iid: String in damaged_iids:
if iid != attacker_iid:
defender_iid = iid
break
is_counterattack = defender_iid != ""
# ── Schedule animations ───────────────────────────────────────────────────
if is_counterattack:
# Full chain handles the attacker and primary defender.
_play_counter_chain(defender_iid, attacker_iid, attack_remaining)
# Any other simultaneously-damaged units get a simple delay (uncommon).
for iid: String in damaged_iids:
if iid == attacker_iid or iid == defender_iid:
continue
var hit_iid := iid
var t2 := create_tween()
t2.tween_callback(func() -> void:
if _unit_bodies.has(hit_iid) and \
is_instance_valid(_unit_bodies.get(hit_iid) as Node):
_play_unit_anim(hit_iid, "damaged")
).set_delay(attack_remaining)
else:
for iid: String in damaged_iids:
var ap : AnimationPlayer = _anim_players.get(iid, null)
if ap != null and is_instance_valid(ap) and ap.is_playing() \
and _is_attack_track(ap.current_animation):
# This unit is mid-attack and took damage (self-damage or similar).
# Queue "damaged" to play right after the attack finishes.
if _oneshot_callbacks.has(iid):
var old_cb := _oneshot_callbacks[iid] as Callable
if ap.animation_finished.is_connected(old_cb):
ap.animation_finished.disconnect(old_cb)
_oneshot_callbacks.erase(iid)
var cap_iid := iid
var dmg_cb := func(_n: String) -> void: _play_unit_anim(cap_iid, "damaged", false)
ap.animation_finished.connect(dmg_cb, CONNECT_ONE_SHOT)
_oneshot_callbacks[iid] = dmg_cb
elif attack_remaining > 0.0:
# Bystander — delay "damaged" until after the attack lands.
var hit_iid := iid
var t := create_tween()
t.tween_callback(func() -> void:
if _unit_bodies.has(hit_iid) and \
is_instance_valid(_unit_bodies.get(hit_iid) as Node):
_play_unit_anim(hit_iid, "damaged")
).set_delay(attack_remaining)
else:
_play_unit_anim(iid, "damaged")
for iid: String in dying_iids:
_play_unit_anim(iid, "dying")
return true
## Update _prev_unit_hp and _prev_unit_pos from the given state snapshot.
## Call immediately when a new state arrives so the next state update has
## correct baselines, independent of when the delayed rebuild fires.
func _update_prev_state(state: Dictionary) -> void:
_prev_unit_hp.clear()
_prev_unit_pos.clear()
for player: Dictionary in state.get("players", []):
var arch : Dictionary = player.get("archSpirit", {})
for unit: Dictionary in ([arch] + player.get("field", [])):
if unit.is_empty(): continue
var iid := str(unit.get("instanceId", ""))
if iid.is_empty(): continue
_prev_unit_hp[iid] = int(unit.get("currentHealth", 0))
var pd = unit.get("position")
if pd is Dictionary and not (pd as Dictionary).is_empty():
_prev_unit_pos[iid] = Vector2i((pd as Dictionary).get("x", 0),
(pd as Dictionary).get("y", 0))
## 4-directional BFS on the game grid.
## blocked: Dictionary[Vector2i → true] of impassable tiles;
## the destination 'to' is always reachable regardless.
## Returns the path steps NOT including 'from', including 'to'.
## Falls back to [to] if no path found (shouldn't happen on a connected grid).
func _bfs_path(from: Vector2i, to: Vector2i, blocked: Dictionary) -> Array[Vector2i]:
if from == to:
return []
var bw := Game.board_width()
var bh := Game.board_height()
var DIRS : Array[Vector2i] = [Vector2i(1,0), Vector2i(-1,0), Vector2i(0,1), Vector2i(0,-1)]
var visited : Dictionary = {from: true}
# Queue entries: [pos: Vector2i, path: Array[Vector2i]]
var queue : Array = [[from, []]]
while not queue.is_empty():
var front = queue.pop_front()
var cur : Vector2i = front[0]
var path : Array = front[1] # untyped — stored in a plain Array queue
for d : Vector2i in DIRS:
var nxt := cur + d
if nxt.x < 0 or nxt.x >= bw or nxt.y < 0 or nxt.y >= bh:
continue
if visited.has(nxt):
continue
if blocked.has(nxt) and nxt != to:
continue
visited[nxt] = true
var new_path : Array = path.duplicate()
new_path.append(nxt)
if nxt == to:
var typed : Array[Vector2i] = []
typed.assign(new_path)
return typed
queue.append([nxt, new_path])
return [to] # fallback: direct jump
## Animate a single unit moving from from_coord to to_coord along a BFS path.
## blocked: tiles occupied by other units (their old positions).
## Returns the total tween duration in seconds.
func _animate_unit_move(iid: String, from_coord: Vector2i, to_coord: Vector2i,
blocked: Dictionary) -> float:
var body := _unit_bodies.get(iid) as StaticBody3D
if not is_instance_valid(body):
return 0.0
var path := _bfs_path(from_coord, to_coord, blocked)
if path.is_empty():
return 0.0
var duration := path.size() * MOVE_STEP_SECS
# Cancel any existing move tween for this unit.
if _move_anims.has(iid) and _move_anims[iid] != null:
(_move_anims[iid] as Tween).kill()
# Play the looping move animation.
_play_unit_anim(iid, "moving", true)
# Pre-compute per-step facing angles so the closures capture the correct values.
var base_angle := float(_model_base_angles.get(iid, 0.0))
var prev_coord := from_coord
var step_angles : Array[float] = []
for step : Vector2i in path:
var step_wp := _coord_to_world(step.x, step.y)
var prev_wp := _coord_to_world(prev_coord.x, prev_coord.y)
var dir := step_wp - prev_wp # XZ direction in world space
step_angles.append(atan2(dir.x, -dir.z) - base_angle)
prev_coord = step
# Tween the body through each grid step, rotating the model to face each direction.
var body_y := body.position.y
var tween := create_tween()
tween.set_ease(Tween.EASE_IN_OUT)
tween.set_trans(Tween.TRANS_SINE)
for i in path.size():
var step : Vector2i = path[i]
var wp := _coord_to_world(step.x, step.y)
var facing_angle : float = step_angles[i] # captured per-iteration
# Snap model rotation to face the movement direction before each step.
tween.tween_callback(func() -> void:
var m := _unit_meshes.get(iid) as Node3D
if is_instance_valid(m):
m.rotation.y = facing_angle)
tween.tween_property(body, "position", Vector3(wp.x, body_y, wp.z), MOVE_STEP_SECS)
# Return to idle rotation and idle animation once movement finishes.
tween.tween_callback(func() -> void:
_move_anims.erase(iid)
var m := _unit_meshes.get(iid) as Node3D
if is_instance_valid(m):
m.rotation.y = _idle_rotation(iid)
_play_unit_anim(iid, "idle", true))
_move_anims[iid] = tween
return duration
## Detect position changes vs _prev_unit_pos and start move animations.
## Returns the maximum movement duration across all movers (seconds).
func _play_move_animations(state: Dictionary) -> float:
if _prev_unit_pos.is_empty():
return 0.0
# Build the set of blocked tiles from old unit positions.
var blocked : Dictionary = {}
for prev_iid : String in _prev_unit_pos:
blocked[_prev_unit_pos[prev_iid]] = true
var max_dur := 0.0
for player: Dictionary in state.get("players", []):
var arch : Dictionary = player.get("archSpirit", {})
for unit: Dictionary in ([arch] + player.get("field", [])):
if unit.is_empty(): continue
var iid := str(unit.get("instanceId", ""))
var pd = unit.get("position")
if not (pd is Dictionary) or (pd as Dictionary).is_empty(): continue
var new_coord := Vector2i((pd as Dictionary).get("x", 0),
(pd as Dictionary).get("y", 0))
if not _prev_unit_pos.has(iid):
continue
var old_coord : Vector2i = _prev_unit_pos[iid]
if old_coord == new_coord: continue
# Mover has left its old tile — unblock it for BFS.
blocked.erase(old_coord)
var dur := _animate_unit_move(iid, old_coord, new_coord, blocked)
max_dur = maxf(max_dur, dur)
return max_dur
## Schedule a delayed call to _rebuild_units.
## If delay <= 0 and a tween is already pending, just update the target state
## but DO NOT cancel the running tween — this prevents rapid echo state-updates
## (phase changes, turn ticks) from killing an in-progress movement animation.
func _schedule_rebuild(state: Dictionary, delay: float) -> void:
_pending_rebuild = state # always target the latest state
if delay <= 0.0:
if _rebuild_tween != null:
return # let the existing animation tween finish; it will use _pending_rebuild
_rebuild_units(state)
return
# A new positive delay: cancel any old tween and start a fresh one.
if _rebuild_tween != null:
_rebuild_tween.kill()
_rebuild_tween = null
_rebuild_tween = create_tween()
_rebuild_tween.tween_callback(func() -> void:
_rebuild_tween = null
_rebuild_units(_pending_rebuild)).set_delay(delay)
# ── Highlights ────────────────────────────────────────────────────────────────
func _clear_highlights() -> void:
print("Clearing")
for c in _hi_root.get_children(): c.queue_free()
func _add_highlight(x: int, y: int, color: Color) -> void:
var mi := MeshInstance3D.new()
var bm := BoxMesh.new()
bm.size = Vector3(0.96, 0.06, 0.96)
mi.mesh = bm
var mat := StandardMaterial3D.new()
# Use a solid opaque base + emission so the highlight is always visible
# regardless of depth-sort or transparency ordering.
mat.albedo_color = Color(color.r, color.g, color.b, 1.0)
mat.emission_enabled = true
mat.emission = Color(color.r, color.g, color.b)
mat.emission_energy_multiplier = 2.0
# Keep a mild transparency so the tile below is still readable.
mat.transparency = BaseMaterial3D.TRANSPARENCY_ALPHA
mat.albedo_color.a = 0.75
mi.material_override = mat
# Position just above the tile top (varies per-tile).
var _hi_tile_h : float = _tile_heights.get("%d,%d" % [x, y], 1.0)
mi.position = _coord_to_world(x, y) + Vector3(0, _hi_tile_h + 0.08, 0)
_hi_root.add_child(mi)
print("[Highlight] added (%d,%d) hi_root children=%d" % [x, y, _hi_root.get_child_count()])
func _highlight_tiles(coords: Array, color: Color) -> void:
for coord in coords:
if coord is Vector2i:
_add_highlight(coord.x, coord.y, color)
elif coord is Dictionary:
_add_highlight(coord.get("x", 0), coord.get("y", 0), color)
# ── Valid target computation ──────────────────────────────────────────────────
func _valid_play_tiles(card: Dictionary) -> Array:
var results : Array = []
var card_type : String = card.get("cardType", "")
var board : Dictionary = Game.get_board()
var bw : int = board.get("width", 8)
var bh : int = board.get("height", 8)
var arch : Dictionary = Game.get_my_player().get("archSpirit", {})
var arch_pos : Dictionary = arch.get("position", {})
match card_type:
"Spirit":
if arch_pos.is_empty(): return results
var ax : int = arch_pos.get("x", 0)
var ay : int = arch_pos.get("y", 0)
# Channel range is a property of the ArchSpirit.
# dict.get(key, default) only uses the default when the key is ABSENT.
# The server sends nullable ints (e.g. "minChannelRange": null), so the
# key EXISTS but its value is null — GDScript returns null, which silently
# coerces to 0 on a typed int variable, collapsing the range to nothing.
# Read as Variant first, then substitute the default explicitly.
var raw_min = arch.get("minChannelRange")
var raw_max = arch.get("maxChannelRange")
var min_r : int = 1 if raw_min == null else int(raw_min)
var max_r : int = 1 if raw_max == null else int(raw_max)
for tx in range(bw):
for ty in range(bh):
var dist : int = abs(tx - ax) + abs(ty - ay)
if dist < min_r or dist > max_r: continue
if Game.get_tile(tx, ty).get("occupantId"): continue
print("Adding tiles")
results.append(Vector2i(tx, ty))
print("results: ", results)
"Terramorpha":
for tx in range(bw):
for ty in range(bh):
results.append(Vector2i(tx, ty))
"Repentance", "Instinct", "Ruin":
pass # No tile target — played directly (server handles placement).
return results
func _terra_count_for_card(card: Dictionary) -> int:
match card.get("terramorphaMode", ""):
"Mono": return 1
"Di": return 2
"Tri": return 3
return 1
func _valid_move_tiles(unit: Dictionary) -> Array:
var results : Array = []
var pos : Dictionary = unit.get("position", {})
if pos.is_empty(): return results
var ux : int = pos.get("x", 0)
var uy : int = pos.get("y", 0)
var mp : int = unit.get("currentMp", 0)
var bw : int = Game.board_width()
var bh : int = Game.board_height()
if mp <= 0: return results
for tx in range(bw):
for ty in range(bh):
var dist : int = abs(tx - ux) + abs(ty - uy)
if dist == 0 or dist > mp: continue
if Game.get_tile(tx, ty).get("occupantId"): continue
results.append(Vector2i(tx, ty))
return results
func _valid_attack_target_coords(unit: Dictionary) -> Array:
var results : Array = []
var pos : Dictionary = unit.get("position", {})
if pos.is_empty(): return results
var ux : int = pos.get("x", 0)
var uy : int = pos.get("y", 0)
var min_r : int = unit.get("minAttackRange", 1)
var max_r : int = unit.get("maxAttackRange", 1)
if unit.get("isExhausted", false) and unit.get("extraAttacksRemaining", 0) == 0:
return results
var opp := Game.get_opponent()
var to_check : Array = []
to_check.append_array(opp.get("field", []))
var opp_arch : Dictionary = opp.get("archSpirit", {})
if not opp_arch.is_empty(): to_check.append(opp_arch)
for t: Dictionary in to_check:
if not t.get("canBeAttacked", true): continue
var tp : Dictionary = t.get("position", {})
if tp.is_empty(): continue
var dist : int = abs(tp.get("x", 0) - ux) + abs(tp.get("y", 0) - uy)
if dist >= min_r and dist <= max_r:
results.append(tp)
return results
func _valid_attack_target_ids(unit: Dictionary) -> Array:
var results : Array = []
var pos : Dictionary = unit.get("position", {})
if pos.is_empty(): return results
var ux : int = pos.get("x", 0)
var uy : int = pos.get("y", 0)
var min_r : int = unit.get("minAttackRange", 1)
var max_r : int = unit.get("maxAttackRange", 1)
if unit.get("isExhausted", false) and unit.get("extraAttacksRemaining", 0) == 0:
return results
var opp := Game.get_opponent()
var to_check : Array = []
to_check.append_array(opp.get("field", []))
var opp_arch : Dictionary = opp.get("archSpirit", {})
if not opp_arch.is_empty(): to_check.append(opp_arch)
for t: Dictionary in to_check:
if not t.get("canBeAttacked", true): continue
var tp : Dictionary = t.get("position", {})
if tp.is_empty(): continue
var dist : int = abs(tp.get("x", 0) - ux) + abs(tp.get("y", 0) - uy)
if dist >= min_r and dist <= max_r:
results.append(t.get("instanceId", ""))
return results
## All tiles within a unit's attack range (regardless of occupancy).
## Used to show the orange reach area for ranged units.
func _attack_range_tiles(unit: Dictionary) -> Array:
var results : Array = []
var pos : Dictionary = unit.get("position", {})
if pos.is_empty(): return results
var ux : int = pos.get("x", 0)
var uy : int = pos.get("y", 0)
var min_r : int = unit.get("minAttackRange", 1)
var max_r : int = unit.get("maxAttackRange", 1)
if max_r <= 1: return results # skip melee — no separate range indicator needed
var bw : int = Game.board_width()
var bh : int = Game.board_height()
for tx in range(bw):
for ty in range(bh):
var dist : int = abs(tx - ux) + abs(ty - uy)
if dist >= min_r and dist <= max_r:
results.append(Vector2i(tx, ty))
return results
func _valid_placement_tiles() -> Array:
var results : Array = []
var my_id := Auth.user_id
var p1_id : String = str(Game.state.get("playerOneAccountId", ""))
var bw : int = Game.board_width()
var bh : int = Game.board_height()
var row : int = 0 if my_id == p1_id else bh - 1
for tx in range(bw):
if not Game.get_tile(tx, row).get("occupantId"):
results.append(Vector2i(tx, row))
return results
## Friendly spirits adjacent to own ArchSpirit (sacrifice candidates).
func _valid_sacrifice_spirits() -> Array:
var results : Array = []
var arch : Dictionary = Game.get_my_player().get("archSpirit", {})
var arch_pos : Dictionary = arch.get("position", {})
if arch_pos.is_empty(): return results
var ax : int = arch_pos.get("x", 0)
var ay : int = arch_pos.get("y", 0)
for unit: Dictionary in Game.get_field():
var up : Dictionary = unit.get("position", {})
if up.is_empty(): continue
var ux : int = up.get("x", 0)
var uy : int = up.get("y", 0)
if abs(ux - ax) + abs(uy - ay) == 1:
results.append(unit)
return results
# ── Click handling ────────────────────────────────────────────────────────────
func _handle_board_click(mouse_pos: Vector2) -> void:
var coord := _mouse_to_tile_coord(mouse_pos)
var unit_id := _mouse_to_unit_id(mouse_pos)
match _mode:
Mode.NONE:
if not unit_id.is_empty() and _is_friendly_unit(unit_id) \
and Game.is_my_turn() and Game.get_phase() != "Placement":
_select_unit(unit_id)
Mode.CARD_FROM_HAND:
var card := _find_hand_card(_sel_card_id)
if card.is_empty():
print("Card empty, mode none")
_set_mode(Mode.NONE); return
var card_type : String = card.get("cardType", "")
if card_type in ["Repentance", "Instinct", "Ruin"]:
Game.send_play_card(_sel_card_id, 0, 0)
_set_mode(Mode.NONE); return
if coord.x < 0:
print("x coor < 0")
_set_mode(Mode.NONE); return
Game.send_play_card(_sel_card_id, coord.x, coord.y)
print("Send play card")
_set_mode(Mode.NONE)
Mode.TERRAMORPHA_SELECT:
if coord.x < 0:
_set_mode(Mode.NONE); return
# Validate adjacency to previous target for Di/Tri.
if _terra_targets.size() > 0:
print("_terra_targets: ", _terra_targets.size())
var last : Vector2i = _terra_targets.back()
if abs(coord.x - last.x) + abs(coord.y - last.y) != 1:
return # must be adjacent
# Avoid duplicates.
print("Handle Board Click: terra targets: ", _terra_targets)
if _terra_targets.has(coord): return
_terra_targets.append(coord)
print("Added Target")
if _terra_targets.size() >= _terra_count:
print("Entering here")
print("_terra_count: ", _terra_count)
# All tiles selected — send play.
var targets := _terra_targets.map(func(v: Vector2i) -> Dictionary:
return { "x": v.x, "y": v.y })
Game.send_play_card_multi(_sel_card_id, targets)
_set_mode(Mode.NONE)
else:
# More tiles needed — re-highlight: orange for picked, green for valid next.
_clear_highlights()
for t: Vector2i in _terra_targets:
_add_highlight(t.x, t.y, HI_ORANGE)
var last2 : Vector2i = _terra_targets.back()
var bw2 := Game.board_width()
var bh2 := Game.board_height()
for d: Vector2i in [Vector2i(1,0), Vector2i(-1,0), Vector2i(0,1), Vector2i(0,-1)]:
var nx := last2.x + d.x
var ny := last2.y + d.y
if nx < 0 or ny < 0 or nx >= bw2 or ny >= bh2: continue
if _terra_targets.has(Vector2i(nx, ny)): continue
_add_highlight(nx, ny, HI_GREEN)
Mode.UNIT_SELECTED:
if not unit_id.is_empty():
if _is_enemy_unit(unit_id):
_last_attack_target_iid = unit_id
_play_unit_anim(_sel_unit_id, "attack")
Game.send_attack(_sel_unit_id, unit_id)
_set_mode(Mode.NONE)
elif unit_id == _sel_unit_id:
# Re-click same unit → toggle ability panel.
if is_instance_valid(_ability_panel):
_hide_ability_panel()
else:
var resel_unit := Game.get_unit_by_id(unit_id)
if not resel_unit.is_empty():
_show_ability_panel(unit_id, resel_unit)
elif _is_friendly_unit(unit_id):
_select_unit(unit_id) # switch to new unit
elif coord.x >= 0:
Game.send_move_unit(_sel_unit_id, coord.x, coord.y)
_set_mode(Mode.NONE)
Mode.PLACEMENT:
if coord.x >= 0:
Game.send_place_arch_spirit(coord.x, coord.y)
_set_mode(Mode.NONE)
Mode.SACRIFICE_SELECT:
# Player clicks a highlighted friendly spirit adjacent to ArchSpirit.
if unit_id.is_empty() or not _is_friendly_unit(unit_id):
_set_mode(Mode.NONE); return
var unit := Game.get_unit_by_id(unit_id)
if unit.is_empty() or unit.get("cardType", "") == "ArchSpirit":
_set_mode(Mode.NONE); return
_confirm_sacrifice(unit_id, unit.get("name", "this spirit"))
Mode.ABILITY_TARGET:
# Collect the clicked board target then advance the targeting flow.
if not unit_id.is_empty():
_ability_targets.append({
"actionIndex": _ability_cur_action_idx,
"instanceId": unit_id
})
_ability_cur_action_idx += 1
_advance_ability_targeting()
elif coord.x >= 0:
_ability_targets.append({
"actionIndex": _ability_cur_action_idx,
"coord": { "x": coord.x, "y": coord.y }
})
_ability_cur_action_idx += 1
_advance_ability_targeting()
else:
_set_mode(Mode.NONE)
func _select_unit(unit_id: String) -> void:
var unit := Game.get_unit_by_id(unit_id)
if unit.is_empty(): return
_hide_ability_panel()
_sel_unit_id = unit_id
_set_mode(Mode.UNIT_SELECTED)
_clear_highlights()
# Highlight own tile.
var upos : Dictionary = unit.get("position", {})
if not upos.is_empty():
_add_highlight(upos.get("x", 0), upos.get("y", 0), HI_YELLOW)
# Smoothly pan camera to center on this unit if setting is enabled.
if Settings.camera_follow_unit:
var target := _coord_to_world(upos.get("x", 0), upos.get("y", 0))
var from := _cam_pivot
if _cam_tween: _cam_tween.kill()
_cam_tween = create_tween().set_ease(Tween.EASE_OUT).set_trans(Tween.TRANS_CUBIC)
_cam_tween.tween_method(
func(v: Vector3) -> void: _cam_pivot = v; _apply_camera(),
from, target, 0.4)
# Movement range (green).
_highlight_tiles(_valid_move_tiles(unit), HI_GREEN)
# Attack range area (orange) — visible reach even when no enemies are in range.
_highlight_tiles(_attack_range_tiles(unit), HI_ORANGE)
# Attackable enemies (red — drawn on top of orange).
_highlight_tiles(_valid_attack_target_coords(unit), HI_RED)
# Show ability panel if unit has active abilities.
_show_ability_panel(unit_id, unit)
# Own ArchSpirit — offer Sacrifice option via menu.
if unit.get("cardType", "") == "ArchSpirit" and _is_friendly_unit(unit_id):
_show_arch_spirit_menu(unit_id, unit)
func _set_mode(new_mode: Mode) -> void:
print("Setting mode: ", new_mode)
_mode = new_mode
_terra_targets = []
_terra_count = 0
if new_mode == Mode.NONE:
_sel_card_id = ""
_sel_unit_id = ""
_ability_unit_id = ""
_ability_idx = -1
_ability_def = []
_ability_range = {}
_ability_targets = []
_ability_cur_action_idx = 0
_clear_highlights()
_hide_ability_panel()
_hide_player_panel()
_refresh_hand_selection()
# ── ArchSpirit popup menu (Sacrifice / Ascend / Transition) ───────────────────
func _show_arch_spirit_menu(unit_id: String, _unit: Dictionary) -> void:
var menu := PopupMenu.new()
add_child(menu)
var sac_spirits := _valid_sacrifice_spirits()
if not sac_spirits.is_empty():
menu.add_item("Sacrifice a Spirit", 0)
# Ascend / Transition from hand.
var can_ascend := false
var can_transition := false
var cur_tier : int = _unit.get("tier", 1)
for card: Dictionary in Game.get_hand():
if card.get("cardType", "") != "ArchSpirit": continue
var t : int = int(card.get("tier", 0))
if t == cur_tier + 1: can_ascend = true
if t == 1: can_transition = true
if can_ascend:
menu.add_item("Ascend ArchSpirit", 1)
if can_transition:
menu.add_item("Transition ArchSpirit", 2)
if menu.item_count == 0:
menu.queue_free(); return
menu.id_pressed.connect(func(id: int) -> void:
match id:
0: _start_sacrifice_mode()
1: _pick_ascend_card()
2: _pick_transition_card()
menu.queue_free())
menu.popup_hide.connect(func() -> void: menu.queue_free())
menu.position = DisplayServer.mouse_get_position()
menu.reset_size()
menu.popup()
func _start_sacrifice_mode() -> void:
_set_mode(Mode.SACRIFICE_SELECT)
_clear_highlights()
for spirit: Dictionary in _valid_sacrifice_spirits():
var sp : Dictionary = spirit.get("position", {})
if not sp.is_empty():
_add_highlight(sp.get("x", 0), sp.get("y", 0), HI_GREEN)
func _confirm_sacrifice(unit_id: String, unit_name: String) -> void:
var dlg := ConfirmationDialog.new()
dlg.title = "Sacrifice"
dlg.dialog_text = "Sacrifice %s?" % unit_name
dlg.ok_button_text = "Sacrifice"
dlg.cancel_button_text = "Cancel"
dlg.min_size = Vector2(260, 90)
add_child(dlg)
dlg.popup_centered()
dlg.confirmed.connect(func() -> void:
Game.send_sacrifice(unit_id)
dlg.queue_free()
_set_mode(Mode.NONE))
dlg.canceled.connect(func() -> void:
dlg.queue_free()
_set_mode(Mode.NONE))
# ── Ascend / Transition ───────────────────────────────────────────────────────
func _pick_ascend_card() -> void:
var cur_tier : int = _get_my_arch_tier()
var candidates : Array = Game.get_hand().filter(func(c: Dictionary) -> bool:
return c.get("cardType", "") == "ArchSpirit" and int(c.get("tier", 0)) == cur_tier + 1)
if candidates.is_empty(): return
if candidates.size() == 1:
_confirm_ascend(candidates[0])
else:
_show_card_picker("Choose Ascend Card", candidates,
func(card: Dictionary) -> void: _confirm_ascend(card))
func _pick_transition_card() -> void:
var candidates : Array = Game.get_hand().filter(func(c: Dictionary) -> bool:
return c.get("cardType", "") == "ArchSpirit" and int(c.get("tier", 0)) == 1)
if candidates.is_empty(): return
if candidates.size() == 1:
_confirm_transition(candidates[0])
else:
_show_card_picker("Choose Transition Card", candidates,
func(card: Dictionary) -> void: _confirm_transition(card))
func _confirm_ascend(card: Dictionary) -> void:
var dlg := ConfirmationDialog.new()
dlg.title = "Ascend"
dlg.dialog_text = "Ascend to %s (Tier %d)?" % [
card.get("name", "?"), int(card.get("tier", 0))]
dlg.ok_button_text = "Ascend"
dlg.min_size = Vector2(280, 90)
add_child(dlg)
dlg.popup_centered()
dlg.confirmed.connect(func() -> void:
Game.send_ascend(card.get("instanceId", ""))
dlg.queue_free())
dlg.canceled.connect(func() -> void: dlg.queue_free())
func _confirm_transition(card: Dictionary) -> void:
var dlg := ConfirmationDialog.new()
dlg.title = "Transition"
dlg.dialog_text = "Swap to %s?" % card.get("name", "?")
dlg.ok_button_text = "Transition"
dlg.min_size = Vector2(280, 90)
add_child(dlg)
dlg.popup_centered()
dlg.confirmed.connect(func() -> void:
Game.send_transition(card.get("instanceId", ""))
dlg.queue_free())
dlg.canceled.connect(func() -> void: dlg.queue_free())
func _get_my_arch_tier() -> int:
var arch : Dictionary = Game.get_my_player().get("archSpirit", {})
return int(arch.get("tier", 1))
## Generic card picker popup for when there are multiple candidates.
func _show_card_picker(title: String, cards: Array, on_pick: Callable) -> void:
var dlg := AcceptDialog.new()
dlg.title = title
dlg.min_size = Vector2(320, 200)
var vbox := VBoxContainer.new()
vbox.add_theme_constant_override("separation", 6)
for card: Dictionary in cards:
var btn := Button.new()
btn.text = "%s (Tier %d)" % [card.get("name", "?"), int(card.get("tier", 0))]
btn.pressed.connect(func() -> void:
on_pick.call(card)
dlg.queue_free())
vbox.add_child(btn)
dlg.add_child(vbox)
add_child(dlg)
dlg.popup_centered()
dlg.canceled.connect(func() -> void: dlg.queue_free())
# ── Ability panel ─────────────────────────────────────────────────────────────
## Recursively normalise all Dictionary keys to lowercase so ability JSON can
## be read with consistent lowercase lookups regardless of server casing.
func _normalize_keys(value: Variant) -> Variant:
if value is Dictionary:
var result := {}
for k in (value as Dictionary):
result[str(k).to_lower()] = _normalize_keys((value as Dictionary)[k])
return result
elif value is Array:
var result : Array = []
for item in (value as Array):
result.append(_normalize_keys(item))
return result
return value
## Clamp a panel's desired top-left position so it stays within the viewport.
## Called after the panel has been added to the tree so size is valid.
func _clamp_panel_pos(desired: Vector2, panel: Control) -> Vector2:
var vp := get_viewport().get_visible_rect().size
var sz := panel.size # may still be zero the first frame; safe fallback
if sz == Vector2.ZERO:
sz = panel.custom_minimum_size
return Vector2(
clampf(desired.x, 4.0, vp.x - sz.x - 4.0),
clampf(desired.y, 4.0, vp.y - sz.y - 4.0))
func _show_ability_panel(unit_id: String, unit: Dictionary) -> void:
_hide_ability_panel()
# Null trap: server sends "abilitiesJson": null for units with no abilities.
# dict.get(key, default) returns null when key exists with null value.
var _raw_abil_ap = unit.get("abilitiesJson")
var abil_json : String = "" if _raw_abil_ap == null else str(_raw_abil_ap)
if abil_json.is_empty(): return
var parsed = JSON.parse_string(abil_json)
if not parsed is Array: return
# Server may serialise with PascalCase keys — normalise to lowercase.
var abilities : Array = _normalize_keys(parsed) as Array
# Collect Active abilities.
var actives : Array = []
for i in abilities.size():
var ab : Dictionary = abilities[i] as Dictionary
if ab.get("type", "") == "Active":
actives.append({ "index": i,
"name": ab.get("name", "Ability %d" % i),
"desc": ab.get("description", ""),
"def": ab })
if actives.is_empty(): return
# Build a floating panel positioned to the right of the unit in screen space.
var panel := PanelContainer.new()
var vbox := VBoxContainer.new()
vbox.add_theme_constant_override("separation", 4)
vbox.custom_minimum_size = Vector2(160, 0)
var title := Label.new()
title.text = "Abilities"
title.add_theme_font_size_override("font_size", 12)
title.add_theme_color_override("font_color", Color(0.7, 0.8, 1.0))
vbox.add_child(title)
vbox.add_child(HSeparator.new())
for ab: Dictionary in actives:
var btn := Button.new()
btn.text = ab.get("name", "")
btn.tooltip_text = ab.get("desc", "")
btn.add_theme_font_size_override("font_size", 12)
var idx : int = ab.get("index", 0)
var ab_def : Dictionary = ab.get("def", {})
btn.pressed.connect(func() -> void:
_ability_unit_id = unit_id
_ability_idx = idx
_ability_def = ab_def.get("actions", [])
_ability_range = ab_def.get("range", {})
_ability_targets = []
_ability_cur_action_idx = 0
_start_ability_targeting())
vbox.add_child(btn)
panel.add_child(vbox)
_hud.add_child(panel)
_ability_panel = panel
# Position panel to the right of the unit after one layout frame so size is known.
var body := _unit_bodies.get(unit_id) as StaticBody3D
if is_instance_valid(body):
var screen_pos := _camera.unproject_position(body.global_position)
panel.set_deferred("position", _clamp_panel_pos(screen_pos + Vector2(36, -40), panel))
else:
panel.position = Vector2(12, 420)
func _hide_ability_panel() -> void:
if is_instance_valid(_ability_panel):
_ability_panel.queue_free()
_ability_panel = null
## Determine what input is needed for the current action and either enter
## ABILITY_TARGET mode (board highlights) or show the player panel.
func _start_ability_targeting() -> void:
if _ability_cur_action_idx >= _ability_def.size():
_send_ability()
return
var action : Dictionary = {}
if _ability_def[_ability_cur_action_idx] is Dictionary:
action = _ability_def[_ability_cur_action_idx] as Dictionary
var target_sel : Dictionary = action.get("target", {})
var scope : String = target_sel.get("scope", "Battlefield")
var ownership : String = target_sel.get("ownership", "Any")
var count_dict : Dictionary = target_sel.get("count", {})
var count_all : bool = count_dict.get("all", false)
# Actions auto-resolved by the server need no player input.
var auto_ownerships := ["Self", "ExactSelf", "Random"]
if count_all or ownership in auto_ownerships:
_ability_cur_action_idx += 1
_start_ability_targeting()
return
# Player / zone selection — show the left-side player panel.
var zone_scopes := ["Player", "Hand", "Deck", "Discard", "AnyZone"]
if scope in zone_scopes:
_set_mode(Mode.ABILITY_TARGET)
_clear_highlights()
_show_player_panel(scope, ownership)
return
# Board selection — enter ABILITY_TARGET mode with blue tile highlights.
_set_mode(Mode.ABILITY_TARGET)
_clear_highlights()
_highlight_ability_targets(action)
## Called after each target is collected; advances to the next action or sends.
func _advance_ability_targeting() -> void:
_hide_player_panel()
_clear_highlights()
_start_ability_targeting()
## Highlight valid ability targets in blue.
func _highlight_ability_targets(action: Dictionary) -> void:
var target_sel : Dictionary = action.get("target", {})
var type_ : String = target_sel.get("type", "Unit")
var ownership : String = target_sel.get("ownership", "Any")
var filters : Array = target_sel.get("filters", [])
# Tile target — paint tiles that pass spatial filters blue.
if type_ == "Tile":
var bw := Game.board_width()
var bh := Game.board_height()
for tx in range(bw):
for ty in range(bh):
if _tile_passes_filters(tx, ty, filters):
_add_highlight(tx, ty, HI_BLUE)
return
# Unit-type target — highlight the board position of each matching unit.
var include_enemy : bool = ownership in ["Enemy", "Any"]
var include_friendly : bool = ownership in ["Owner", "Ally", "Any"]
# Fallback: if nothing matched, treat as enemy.
if not include_enemy and not include_friendly:
include_enemy = true
var targets : Array = []
if include_enemy:
targets.append_array(Game.get_opponent().get("field", []))
var opp_arch : Dictionary = Game.get_opponent().get("archSpirit", {})
if not opp_arch.is_empty():
targets.append(opp_arch)
if include_friendly:
targets.append_array(Game.get_field())
var my_arch : Dictionary = Game.get_my_player().get("archSpirit", {})
if not my_arch.is_empty():
targets.append(my_arch)
var src_pos_ab : Dictionary = {}
if not _ability_range.is_empty():
src_pos_ab = Game.get_unit_by_id(_ability_unit_id).get("position", {})
for u: Dictionary in targets:
var pos : Dictionary = u.get("position", {})
if pos.is_empty(): continue
if not _unit_passes_filters(u, filters): continue
if not _ability_range.is_empty():
if src_pos_ab.is_empty(): continue
var dist := (absi(int(pos.get("x", 0)) - int(src_pos_ab.get("x", 0))) +
absi(int(pos.get("y", 0)) - int(src_pos_ab.get("y", 0))))
if dist < int(_ability_range.get("min", 0)) or dist > int(_ability_range.get("max", 999)):
continue
_add_highlight(pos.get("x", 0), pos.get("y", 0), HI_BLUE)
## Returns true if the unit passes all client-evaluable filters.
## Spatial filters (withinrange, isadjacenttosource) are checked here so the
## highlight matches what the server will accept.
func _unit_passes_filters(unit: Dictionary, filters: Array) -> bool:
if filters.is_empty(): return true
var src := Game.get_unit_by_id(_ability_unit_id)
var src_pos : Dictionary = src.get("position", {})
for f: Dictionary in filters:
match f.get("$type", ""):
"withinrange":
if src_pos.is_empty(): return false
var tgt_pos : Dictionary = unit.get("position", {})
if tgt_pos.is_empty(): return false
var dist := (absi(int(tgt_pos.get("x", 0)) - int(src_pos.get("x", 0))) +
absi(int(tgt_pos.get("y", 0)) - int(src_pos.get("y", 0))))
if dist < int(f.get("min", 0)) or dist > int(f.get("max", 999)):
return false
"isadjacenttosource":
if src_pos.is_empty(): return false
var tgt_pos : Dictionary = unit.get("position", {})
if tgt_pos.is_empty(): return false
var dist := (absi(int(tgt_pos.get("x", 0)) - int(src_pos.get("x", 0))) +
absi(int(tgt_pos.get("y", 0)) - int(src_pos.get("y", 0))))
if dist != 1: return false
return true
## Returns true if the tile at (tx, ty) passes all client-evaluable tile filters.
func _tile_passes_filters(tx: int, ty: int, filters: Array) -> bool:
if filters.is_empty(): return true
var src := Game.get_unit_by_id(_ability_unit_id)
var src_pos : Dictionary = src.get("position", {})
for f: Dictionary in filters:
match f.get("$type", ""):
"tilewithinrange":
if src_pos.is_empty(): return false
var dist := (absi(tx - int(src_pos.get("x", 0))) +
absi(ty - int(src_pos.get("y", 0))))
if dist < int(f.get("min", 0)) or dist > int(f.get("max", 999)):
return false
return true
## Fire the ability request with all collected targets.
func _send_ability() -> void:
Game.send_activate_ability(_ability_unit_id, _ability_idx, _ability_targets)
_set_mode(Mode.NONE)
## Show a left-side panel to let the player select a player (and optionally a
## zone) as the ability target.
func _show_player_panel(scope: String, ownership: String) -> void:
_hide_player_panel()
var panel := PanelContainer.new()
panel.position = Vector2(8, 180)
var vbox := VBoxContainer.new()
vbox.add_theme_constant_override("separation", 8)
vbox.custom_minimum_size = Vector2(160, 0)
var title := Label.new()
title.text = "Choose Player"
title.add_theme_font_size_override("font_size", 13)
title.add_theme_color_override("font_color", Color(0.7, 0.8, 1.0))
vbox.add_child(title)
vbox.add_child(HSeparator.new())
var my_id : String = Auth.user_id
var my_name : String = Auth.display_name if not Auth.display_name.is_empty() else "You"
var opp_id : String = str(Game.get_opponent().get("accountId", ""))
var opp_name : String = Game.opponent_name if not Game.opponent_name.is_empty() else "Opponent"
var show_self : bool = ownership in ["Owner", "Ally", "Any"]
var show_enemy : bool = ownership in ["Enemy", "Any"]
if not show_self and not show_enemy:
show_self = true
show_enemy = true
if show_self:
_add_player_option(vbox, my_name, my_id, scope)
if show_enemy:
_add_player_option(vbox, opp_name, opp_id, scope)
panel.add_child(vbox)
_hud.add_child(panel)
_player_panel = panel
## Add a player row (name + optional zone buttons) to the player panel vbox.
func _add_player_option(vbox: VBoxContainer, name_: String,
account_id: String, scope: String) -> void:
var zone_scopes := ["Hand", "Deck", "Discard", "AnyZone"]
if scope in zone_scopes:
# Player name label + zone buttons on the same row.
var lbl := Label.new()
lbl.text = name_
lbl.add_theme_font_size_override("font_size", 12)
vbox.add_child(lbl)
var zone_hbox := HBoxContainer.new()
zone_hbox.add_theme_constant_override("separation", 4)
var zones : Array = ["Hand", "Deck", "Discard"] if scope == "AnyZone" else [scope]
for zone_name : String in zones:
var zbtn := Button.new()
zbtn.text = zone_name
zbtn.add_theme_font_size_override("font_size", 11)
var cap_id : String = account_id
zbtn.pressed.connect(func() -> void:
_ability_targets.append({
"actionIndex": _ability_cur_action_idx,
"instanceId": cap_id
})
_ability_cur_action_idx += 1
_advance_ability_targeting())
zone_hbox.add_child(zbtn)
vbox.add_child(zone_hbox)
else:
# Pure player target — single button with the player's name.
var btn := Button.new()
btn.text = name_
btn.add_theme_font_size_override("font_size", 12)
var cap_id : String = account_id
btn.pressed.connect(func() -> void:
_ability_targets.append({
"actionIndex": _ability_cur_action_idx,
"instanceId": cap_id
})
_ability_cur_action_idx += 1
_advance_ability_targeting())
vbox.add_child(btn)
func _hide_player_panel() -> void:
if is_instance_valid(_player_panel):
_player_panel.queue_free()
_player_panel = null
func _show_unit_detail_popup(unit_id: String) -> void:
var unit := Game.get_unit_by_id(unit_id)
if unit.is_empty(): return
var name_ : String = unit.get("name", "?")
var type_ : String = unit.get("cardType", "")
var aff : String = unit.get("affinity", "")
_ctx_tile_lbl.text = "%s — %s [%s]" % [name_, type_, aff]
_ctx_unit_lbl.text = "HP %d/%d DEF %d/%d ATK %d MP %d/%d" % [
int(unit.get("currentHealth", 0)), int(unit.get("maxHealth", 0)),
int(unit.get("currentDefense", 0)), int(unit.get("maxDefense", 0)),
int(unit.get("damage", 0)),
int(unit.get("currentMp", 0)), int(unit.get("maxMp", 0))]
var abil_str := ""
var _raw = unit.get("abilitiesJson")
var parsed = JSON.parse_string("[]" if _raw == null else str(_raw))
if parsed is Array:
for ab: Dictionary in parsed:
var ab_name := str(ab.get("name", ab.get("Name", "")))
var ab_desc := str(ab.get("description", ab.get("Description", "")))
abil_str += "• %s" % ab_name
if not ab_desc.is_empty():
abil_str += ": %s" % ab_desc
abil_str += "\n"
_ctx_abil_lbl.text = abil_str.strip_edges()
_ctx_popup.visible = true
# ── Hand card ArchSpirit routing ──────────────────────────────────────────────
func _on_hand_card_clicked(iid: String, _panel: PanelContainer) -> void:
# Dedup: the same physical click can arrive twice if a stale queue_freed widget
# still overlaps the live one (see _rebuild_hand). Ignore the second call in
# the same engine frame for the same card instance.
var cf := Engine.get_process_frames()
if cf == _last_click_frame and _last_click_iid == iid:
print("[HandClick] dedup suppressed iid=", iid.substr(0,8))
return
_last_click_frame = cf
_last_click_iid = iid
print("Clicked x times: ", count)
count += 1
if not Game.is_my_turn(): return
var card := _find_hand_card(iid)
#print(card.get("name", "name failed"))
if card.is_empty(): return
# ArchSpirit in hand → Ascend or Transition.
if card.get("cardType", "") == "ArchSpirit":
var tier : int = int(card.get("tier", 0))
var cur_tier : int = _get_my_arch_tier()
if tier == cur_tier + 1:
_confirm_ascend(card)
elif tier == 1 and cur_tier >= 1:
_confirm_transition(card)
return
# Terramorpha → multi-tile flow (only if player can afford it).
if card.get("cardType", "") == "Terramorpha":
if Game.get_my_player().get("currentSp", 0) < card.get("spCost", 0):
return
_sel_card_id = iid
_terra_targets = []
print("_terra Array clean. _terra_count: ", _terra_count)
_set_mode(Mode.TERRAMORPHA_SELECT)
_terra_count = _terra_count_for_card(card)
_clear_highlights()
_highlight_tiles(_valid_play_tiles(card), HI_GREEN)
return
# Ruin — server auto-places it; channel immediately on click.
if card.get("cardType", "") == "Ruin":
Game.send_play_card(iid, 0, 0)
return
# Deselect if same card clicked again.
if _mode == Mode.CARD_FROM_HAND and _sel_card_id == iid:
print("Deselect")
_set_mode(Mode.NONE); return
# If switching cards (or coming from TERRAMORPHA_SELECT), explicitly reset
# so the previous card's scale-up tween is released before entering the new mode.
if _mode in [Mode.CARD_FROM_HAND, Mode.TERRAMORPHA_SELECT]:
print("switching cards catch")
_set_mode(Mode.NONE)
# Normal Spirit / Repentance / Instinct.
_sel_card_id = iid
_set_mode(Mode.CARD_FROM_HAND)
_clear_highlights()
_highlight_tiles(_valid_play_tiles(card), HI_GREEN)
# ── Hand display ──────────────────────────────────────────────────────────────
func _rebuild_hand(hand: Array) -> void:
# Use remove_child + queue_free (not queue_free alone) so stale widgets are
# immediately pulled from the GUI tree. queue_free() alone keeps the node in
# get_children() and receiving input events until end-of-frame; if two state
# updates arrive in the same frame we'd have two overlapping CardWidgets at the
# same position → two card_pressed emissions → double _on_hand_card_clicked.
for c in _hand_cards.get_children():
_hand_cards.remove_child(c)
c.queue_free()
for card: Dictionary in hand:
_hand_cards.add_child(_make_hand_card(card))
func _make_hand_card(card: Dictionary) -> Control:
var iid : String = card.get("instanceId", "")
# Instantiate the shared CardWidget scene used by the collection UI.
# Build a def dict from the live card data. CardWidget reads "movementPoints"
# but the CardInstanceDto field is "maxMp", so alias it here.
var widget : PanelContainer = _CARD_WIDGET_SCENE.instantiate()
widget.set_meta("card_instance_id", iid)
var def := card.duplicate()
def["movementPoints"] = card.get("maxMp", null)
widget.setup(card, def)
# Compact the card for the hand area: shrink art and hide the detailed
# stats grid (HP/ATK/DEF/MP/range). Name, SP/ST cost, genus, and type
# remain visible; long-press context popup shows full unit stats.
var art_area := widget.get_node_or_null("Margin/VBox/ArtArea")
if art_area is Control:
(art_area as Control).custom_minimum_size = Vector2(0, 80)
var stats_grid := widget.get_node_or_null("Margin/VBox/StatsGrid")
if stats_grid is CanvasItem:
(stats_grid as CanvasItem).visible = false
# CardWidget emits card_pressed(definition_id); forward as hand-card click.
widget.card_pressed.connect(func(_def_id: String) -> void:
_on_hand_card_clicked(iid, widget))
return widget
func _refresh_hand_selection() -> void:
for widget in _hand_cards.get_children():
if not widget.has_meta("card_instance_id"): continue
var iid : String = str(widget.get_meta("card_instance_id"))
var sel : bool = ((_mode == Mode.CARD_FROM_HAND
or _mode == Mode.TERRAMORPHA_SELECT)
and _sel_card_id == iid)
var prev_sel : bool = widget.get_meta("_sel", false)
if widget.has_method("set_selected"):
widget.set_selected(sel)
# Tween scale on selection change.
# IMPORTANT: defer the tween + z_index update so they run AFTER the
# current input event is fully processed. Setting z_index synchronously
# while a mouse button is held causes Godot 4 to re-evaluate GUI focus
# and deliver a synthetic second pressed=true event → immediate deselect.
if sel != prev_sel:
widget.set_meta("_sel", sel)
_tween_hand_card.call_deferred(widget, sel)
func _tween_hand_card(widget: Control, sel: bool) -> void:
if not is_instance_valid(widget): return
widget.pivot_offset = widget.size * 0.5
var tw := create_tween()
if sel:
tw.tween_property(widget, "scale", Vector2(1.12, 1.12), 0.14)
widget.z_index = 20
else:
tw.tween_property(widget, "scale", Vector2(1.0, 1.0), 0.10)
widget.z_index = 0
func _find_hand_card(iid: String) -> Dictionary:
for card: Dictionary in Game.get_hand():
if card.get("instanceId", "") == iid:
return card
return {}
# ── HUD update ────────────────────────────────────────────────────────────────
func _update_hud(state: Dictionary) -> void:
var phase : String = state.get("phase", "")
var turn : int = state.get("turnNumber", 1)
var is_mine : bool = Game.is_my_turn()
var my : Dictionary = Game.get_my_player()
var opp : Dictionary = Game.get_opponent()
_phase_lbl.text = "Phase: %s" % phase
_turn_lbl.text = "Turn %d — %s" % [turn, "Your turn" if is_mine else "Opponent's turn"]
_turn_lbl.modulate = Color(0.4, 1.0, 0.5) if is_mine else Color(1.0, 0.6, 0.6)
_sp_lbl.text = "SP: %d" % int(my.get("currentSp", 0))
_st_lbl.text = "ST: %d" % int(my.get("currentSt", 0))
_deck_lbl.text = "Deck: %d" % int(my.get("deckCount", 0))
_opp_name_lbl.text = Game.opponent_name if not Game.opponent_name.is_empty() \
else str(opp.get("accountId", "Opponent")).substr(0, 8)
_opp_hand_lbl.text = "Hand: %d" % int(opp.get("handCount", 0))
_opp_deck_lbl.text = "Deck: %d" % int(opp.get("deckCount", 0))
_draw_btn.visible = (phase == "Draw" and is_mine)
_end_turn_btn.visible = (phase == "Main" and is_mine)
_end_turn_btn.disabled = not is_mine
if phase == "Placement":
var my_arch : Dictionary = my.get("archSpirit", {})
var i_have_placed : bool = not my_arch.is_empty() and my_arch.get("position") != null
if not i_have_placed:
_phase_lbl.text = "Phase: Placement — click a tile to place your ArchSpirit"
if _mode != Mode.PLACEMENT:
_set_mode(Mode.PLACEMENT)
_clear_highlights()
_highlight_tiles(_valid_placement_tiles(), HI_GREEN)
else:
_phase_lbl.text = "Phase: Placement — waiting for opponent…"
if _mode == Mode.PLACEMENT:
_set_mode(Mode.NONE)
# ── Discard viewer ────────────────────────────────────────────────────────────
func _show_own_discard() -> void:
_show_discard_for("Your Discard", Game.get_my_player().get("discard", []))
func _show_opp_discard() -> void:
_show_discard_for("Opponent Discard", Game.get_opponent().get("discard", []))
func _show_discard_for(title: String, cards: Array) -> void:
_dv_title.text = "%s (%d)" % [title, cards.size()]
for c in _dv_list.get_children(): c.queue_free()
if cards.is_empty():
var lbl := Label.new()
lbl.text = "(empty)"
lbl.add_theme_color_override("font_color", Color(0.55, 0.55, 0.6))
_dv_list.add_child(lbl)
else:
for card: Dictionary in cards:
_dv_list.add_child(_make_discard_row(card))
_dv_overlay.visible = true
func _make_discard_row(card: Dictionary) -> Control:
var hbox := HBoxContainer.new()
hbox.add_theme_constant_override("separation", 8)
hbox.custom_minimum_size = Vector2(0, 32)
var type_lbl := Label.new()
type_lbl.text = "[%s]" % card.get("cardType", "?")
type_lbl.add_theme_font_size_override("font_size", 11)
type_lbl.add_theme_color_override("font_color", Color(0.6, 0.6, 0.7))
type_lbl.custom_minimum_size = Vector2(90, 0)
type_lbl.size_flags_vertical = Control.SIZE_SHRINK_CENTER
hbox.add_child(type_lbl)
var name_lbl := Label.new()
name_lbl.text = card.get("name", "Unknown")
name_lbl.add_theme_font_size_override("font_size", 13)
name_lbl.size_flags_horizontal = Control.SIZE_EXPAND_FILL
name_lbl.size_flags_vertical = Control.SIZE_SHRINK_CENTER
hbox.add_child(name_lbl)
var aff_lbl := Label.new()
aff_lbl.text = card.get("affinity", "")
aff_lbl.add_theme_font_size_override("font_size", 11)
aff_lbl.add_theme_color_override("font_color", Color(0.6, 0.7, 0.85))
aff_lbl.size_flags_vertical = Control.SIZE_SHRINK_CENTER
hbox.add_child(aff_lbl)
return hbox
# ── Hold timer → context popup ────────────────────────────────────────────────
func _on_hold_timer_fired() -> void:
if _held_coord.x < 0: return
var tile := Game.get_tile(_held_coord.x, _held_coord.y)
if tile.is_empty(): return
var aff : String = tile.get("resolvedAffinity", "Void")
_ctx_tile_lbl.text = "Tile (%d,%d) — %s" % [_held_coord.x, _held_coord.y, aff]
var _raw_occ = tile.get("occupantId")
var occupant_id : String = _raw_occ if _raw_occ is String else ""
if occupant_id.is_empty():
_ctx_unit_lbl.text = ""
_ctx_abil_lbl.text = ""
else:
var unit := Game.get_unit_by_id(occupant_id)
_ctx_unit_lbl.text = "%s HP %d/%d DEF %d/%d ATK %d" % [
unit.get("name", "?"),
int(unit.get("currentHealth", 0)), int(unit.get("maxHealth", 0)),
int(unit.get("currentDefense", 0)), int(unit.get("maxDefense", 0)),
int(unit.get("damage", 0))]
var abil_str := ""
var _raw_abil_hud = unit.get("abilitiesJson")
var parsed = JSON.parse_string("[]" if _raw_abil_hud == null else str(_raw_abil_hud))
if parsed is Array:
for ab: Dictionary in parsed:
abil_str += "• %s\n" % str(ab.get("name", ""))
_ctx_abil_lbl.text = abil_str.strip_edges()
_ctx_popup.visible = true
# ── Game over ─────────────────────────────────────────────────────────────────
func _on_game_over(winner_id: String, win_condition: String,
winner_delta: int, loser_delta: int) -> void:
var i_won : bool = (winner_id == Auth.user_id)
_go_result_lbl.text = "Victory!" if i_won else "Defeat"
_go_result_lbl.modulate = Color(0.4, 1.0, 0.5) if i_won else Color(1.0, 0.4, 0.4)
var my_delta : int = winner_delta if i_won else loser_delta
_go_rank_lbl.text = "Win by %s | Rank %s%d" % [
win_condition, "+" if my_delta >= 0 else "", my_delta]
_go_overlay.visible = true
func _on_session_abandoned(_reason: String) -> void:
get_tree().change_scene_to_file("res://scenes/main/MainScreen.tscn")
# ── State → scene ─────────────────────────────────────────────────────────────
func _on_state_updated(state: Dictionary) -> void:
print("[StateUpdate] phase=", state.get("phase","?"),
" mode=", _mode, " sel_card=",
_sel_card_id.substr(0, 8) if not _sel_card_id.is_empty() else "none")
_rebuild_ownership(state)
# Orient camera behind the local player's row on the first state with playerOneAccountId.
var p1_id : String = str(state.get("playerOneAccountId", ""))
if not p1_id.is_empty():
# Update P1/P2 flag every time — used for model facing on full rebuild.
_local_is_p1 = Auth.user_id.to_lower() == p1_id.to_lower()
if not _camera_oriented and not p1_id.is_empty():
_camera_oriented = true
var bh := float(Game.board_height())
# Shift cam_pivot toward the opponent's side (30 % of board half-length)
# so the player's own row appears in the lower-middle of the screen,
# above the hand panel — not hidden behind it.
var pivot_offset := (bh - 1.0) * 0.3
if _local_is_p1:
# P1 row is at world -Z. Camera looks from -Z toward +Z → yaw=180°.
# Shift pivot toward world -Z so P1's row is NOT at the very bottom.
_cam_yaw = 180.0
_cam_pivot = Vector3(0.0, 0.0, -pivot_offset)
else:
# P2 row is at world +Z (default yaw=0°).
_cam_pivot = Vector3(0.0, 0.0, pivot_offset)
_apply_camera()
var board : Dictionary = state.get("board", {})
if _tile_bodies.is_empty() and not board.is_empty():
_build_board(board)
elif not board.is_empty():
for tile: Dictionary in board.get("tiles", []):
var c : Dictionary = tile.get("coord", {})
_update_tile_affinity(c.get("x", 0), c.get("y", 0),
tile.get("resolvedAffinity", "Void"))
# ── Fire animations on existing nodes before rebuild destroys them ────────
var move_dur : float = _play_move_animations(state)
var dmg_played : bool = _play_damage_animations(state)
# ── Immediate UI update (hand / HUD don't need to wait for animations) ────
var hand := Game.get_hand()
print("[GameScreen] state phase=", state.get("phase","?"),
" my_player_found=", not Game.get_my_player().is_empty(),
" hand_size=", hand.size(),
" my_id=", Auth.user_id.substr(0,8))
_rebuild_hand(hand)
_update_hud(state)
# ── Update position/HP tracking now so the next state update is correct ───
_update_prev_state(state)
# ── Schedule delayed board rebuild to let animations finish ───────────────
var delay := move_dur
if dmg_played:
delay = maxf(delay, POST_ANIM_SECS)
_schedule_rebuild(state, delay)
# ── Selection preservation (immediate — highlights are tile overlays) ──────
# After a state update, preserve hand-card and unit selections where possible.
# A state push from the server (e.g. opponent action, draw echo) must not
# silently clear tile highlights that the player just set up.
match _mode:
Mode.NONE, Mode.PLACEMENT:
pass # placement highlights are managed in _update_hud above
Mode.CARD_FROM_HAND, Mode.TERRAMORPHA_SELECT:
# Keep selection only if the card is still in our hand.
var sel_card := _find_hand_card(_sel_card_id)
if sel_card.is_empty():
print("[StateUpdate] selected card gone — clearing mode")
_set_mode(Mode.NONE)
else:
# Re-apply highlights: board/units may have changed.
print("[StateUpdate] preserving CARD_FROM_HAND, re-highlighting")
_clear_highlights()
_highlight_tiles(_valid_play_tiles(sel_card), HI_GREEN)
_refresh_hand_selection() # mark the (new) widget as selected
_:
# Unit selected, sacrifice, ability — clear these on any state change
# because unit positions / health / eligibility may have changed.
_set_mode(Mode.NONE)
# Auto-draw.
if state.get("phase", "") == "Draw" and Game.is_my_turn():
await get_tree().create_timer(0.3).timeout
Game.send_draw()
# ── Action buttons ────────────────────────────────────────────────────────────
func _on_draw_pressed() -> void: Game.send_draw()
func _on_end_turn_pressed() -> void: _set_mode(Mode.NONE); Game.send_end_turn()