Add generic active-ability placeholder VFX (game.visual.ability_placeholder)

Server:
- Add AbilityPlaceholderVisualPush DTO (sourceInstanceId, abilityName,
  sourceAffinity, targets, targetMode: Self|Unit|Tile|PlayerZone|None)
- Promote ComputeVisualTargets to GameHandlerBase (protected static)
- Add ComputeAbilityVisualTargets — extends Repentance logic with
  Self/ExactSelf + All-count detection, falls back to enemy ArchSpirit
- Add ComputeAbilityTargetMode — derives mode from visual targets +
  sourceInstanceId (PlayerZone when target is a player account ID)
- Add FindSourceUnit helper — searches Field + ArchSpirit across all players
- GameActivateAbilityHandler captures source unit + ability def before
  ActivateAbility, skips push when Animation.AssetUrl is set

Client:
- Add ability_placeholder_visual signal and push router case in Game.gd
- New AbilityPlaceholderFx component: Self/None → radial glow burst + two
  expanding rings on source; Unit/Tile/PlayerZone → orb projectile from
  source unit body to resolved target, impact ring + burst motes on arrival
- Wire component in game_screen.gd (_ready, _exit_tree, handler)

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>
This commit is contained in:
dingo
2026-05-11 22:59:57 -04:00
co-authored by Claude Happy
parent 469e72b0f6
commit 3bbf419836
7 changed files with 527 additions and 41 deletions
+8
View File
@@ -89,6 +89,11 @@ signal reveal_choice_pick_request(request_data: Dictionary)
## cardInstanceId, cardDefinitionId, cardName, affinity, targets
signal repentance_placeholder_visual(payload: Dictionary)
## Emitted when an Active ability fires with no custom animation asset.
## Payload keys: eventId, sessionId, actorAccountId, sourceInstanceId,
## abilityName, sourceAffinity, targets, targetMode
signal ability_placeholder_visual(payload: Dictionary)
# ── State ─────────────────────────────────────────────────────────────────────
var session_id : String = ""
@@ -828,3 +833,6 @@ func _on_server_push(type: String, payload: Variant) -> void:
"game.visual.repentance_placeholder":
repentance_placeholder_visual.emit(payload as Dictionary)
"game.visual.ability_placeholder":
ability_placeholder_visual.emit(payload as Dictionary)
@@ -0,0 +1,328 @@
class_name AbilityPlaceholderFx
extends Node
## Plays a placeholder VFX when an Active ability fires without a custom
## animation asset. Behaviour depends on targetMode from the server:
##
## "Self" — glow ring + radial burst on the source unit, no projectile
## "Unit" — orb projectile from source unit to target unit body
## "Tile" — orb projectile from source unit to tile centre
## "PlayerZone" — orb projectile from source unit to target player's ArchSpirit
## "None" — fallback self glow burst
##
## The source is always the activating unit, not the ArchSpirit.
##
## External refs (set by game_screen._ready):
## pathfinder — for coord_to_world
## unit_bodies — Dictionary instanceId → StaticBody3D
## units_root — Node3D that owns the 3D board unit nodes
# ── External refs ─────────────────────────────────────────────────────────────
var pathfinder : Pathfinder = null
var unit_bodies : Dictionary = {} # instanceId → StaticBody3D
var units_root : Node3D = null
# ── Public API ────────────────────────────────────────────────────────────────
## Called by game_screen when Game.ability_placeholder_visual fires.
func play(payload: Dictionary) -> void:
var actor_id: String = str(payload.get("actorAccountId", ""))
var source_id: String = str(payload.get("sourceInstanceId", ""))
var affinity: String = str(payload.get("sourceAffinity", ""))
var target_mode: String = str(payload.get("targetMode", "None"))
var targets_raw: Variant = payload.get("targets", [])
var targets: Array = targets_raw as Array if targets_raw is Array else []
var affinity_color: Color = GameConstants.AFFINITY_COLORS.get(affinity, Color(0.7, 0.55, 0.9))
var player_color: Color = _resolve_player_color(actor_id)
var src_pos: Vector3 = _resolve_unit_pos(source_id)
match target_mode:
"Self", "None":
_play_self_burst(src_pos, affinity_color, player_color)
"Unit":
var tgt_pos: Vector3 = _resolve_unit_target(targets, src_pos)
_spawn_projectile(src_pos, tgt_pos, affinity_color, player_color)
"Tile":
var tgt_pos: Vector3 = _resolve_tile_target(targets, src_pos)
_spawn_projectile(src_pos, tgt_pos, affinity_color, player_color)
"PlayerZone":
var tgt_pos: Vector3 = _resolve_player_arch_target(targets, src_pos)
_spawn_projectile(src_pos, tgt_pos, affinity_color, player_color)
_:
_play_self_burst(src_pos, affinity_color, player_color)
# ── Position resolution ───────────────────────────────────────────────────────
func _resolve_unit_pos(instance_id: String) -> Vector3:
if not instance_id.is_empty():
var body: StaticBody3D = unit_bodies.get(instance_id) as StaticBody3D
if is_instance_valid(body):
return body.global_position + Vector3(0, 0.5, 0)
return Vector3.ZERO
func _resolve_unit_target(targets: Array, fallback: Vector3) -> Vector3:
for t: Variant in targets:
if not (t is Dictionary):
continue
var td: Dictionary = t as Dictionary
var inst_id: String = str(td.get("instanceId", td.get("instance_id", "")))
if inst_id.is_empty():
continue
var body: StaticBody3D = unit_bodies.get(inst_id) as StaticBody3D
if is_instance_valid(body):
return body.global_position + Vector3(0, 0.5, 0)
return fallback
func _resolve_tile_target(targets: Array, fallback: Vector3) -> Vector3:
for t: Variant in targets:
if not (t is Dictionary):
continue
var td: Dictionary = t as Dictionary
var coord_v: Variant = td.get("coord")
if coord_v is Dictionary and pathfinder != null:
var cd: Dictionary = coord_v as Dictionary
return pathfinder.coord_to_world(int(cd.get("x", 0)), int(cd.get("y", 0))) \
+ Vector3(0, 0.6, 0)
return fallback
func _resolve_player_arch_target(targets: Array, fallback: Vector3) -> Vector3:
for t: Variant in targets:
if not (t is Dictionary):
continue
var td: Dictionary = t as Dictionary
var inst_id: String = str(td.get("instanceId", td.get("instance_id", "")))
if inst_id.is_empty():
continue
# Try as unit body first (server may send ArchSpirit InstanceId directly).
var body: StaticBody3D = unit_bodies.get(inst_id) as StaticBody3D
if is_instance_valid(body):
return body.global_position + Vector3(0, 0.5, 0)
# Try as account id → ArchSpirit board position.
var pd: Dictionary = _player_by_id(inst_id)
var arch: Dictionary = pd.get("archSpirit", {})
var apos: Dictionary = arch.get("position", {})
if not apos.is_empty() and pathfinder != null:
return pathfinder.coord_to_world(
int(apos.get("x", 0)), int(apos.get("y", 0))) + Vector3(0, 0.8, 0)
return fallback
func _resolve_player_color(actor_id: String) -> Color:
var player: Dictionary = _player_by_id(actor_id)
var team_idx: int = int(player.get("teamIndex", -1))
var team_colors: Dictionary = Game.state.get("teamColors", {})
var hex: String = str(team_colors.get(team_idx, team_colors.get(str(team_idx), "")))
if hex.length() >= 6:
return Color.html("#" + hex if not hex.begins_with("#") else hex)
return Color(0.9, 0.7, 0.3)
func _player_by_id(account_id: String) -> Dictionary:
for p: Variant in Game.state.get("players", []):
if p is Dictionary and \
str((p as Dictionary).get("accountId", "")).to_lower() == account_id.to_lower():
return p as Dictionary
return {}
# ── Self burst (no projectile) ────────────────────────────────────────────────
func _play_self_burst(pos: Vector3, affinity_color: Color, player_color: Color) -> void:
if units_root == null:
return
var burst_dur: float = randf_range(0.45, 0.65)
# Expanding glow ring.
var ring: MeshInstance3D = _make_impact_ring(
affinity_color.lerp(player_color, 0.25), pos, 0.12, 0.16)
units_root.add_child(ring)
# Larger outer ring (player color accent).
var ring2: MeshInstance3D = _make_impact_ring(
player_color.lerp(affinity_color, 0.3), pos, 0.22, 0.28)
units_root.add_child(ring2)
# Radial motes.
var rng: RandomNumberGenerator = RandomNumberGenerator.new()
rng.randomize()
var burst_root: Node3D = Node3D.new()
burst_root.name = "SelfBurst"
burst_root.position = pos
units_root.add_child(burst_root)
for i: int in range(10):
var angle: float = TAU * float(i) / 10.0 + rng.randf_range(-0.15, 0.15)
var speed: float = rng.randf_range(0.18, 0.42)
var col: Color = affinity_color if i % 2 == 0 else player_color
var mote: MeshInstance3D = _make_orb(col, rng.randf_range(0.022, 0.05))
mote.position = Vector3.ZERO
burst_root.add_child(mote)
var end_pos: Vector3 = Vector3(cos(angle) * speed, rng.randf_range(0.05, 0.28), sin(angle) * speed)
var mt: Tween = create_tween()
mt.set_parallel(true)
mt.tween_property(mote, "position", end_pos, burst_dur)\
.set_trans(Tween.TRANS_EXPO).set_ease(Tween.EASE_OUT)
mt.tween_property(mote, "scale", Vector3.ZERO, burst_dur)\
.set_trans(Tween.TRANS_QUAD).set_ease(Tween.EASE_IN)
# Animate rings outward and fade.
for ring_node: MeshInstance3D in [ring, ring2]:
var rt: Tween = create_tween()
rt.set_parallel(true)
rt.tween_property(ring_node, "scale", Vector3.ONE * 2.8, burst_dur)\
.set_trans(Tween.TRANS_EXPO).set_ease(Tween.EASE_OUT)
var rmat: StandardMaterial3D = ring_node.material_override as StandardMaterial3D
if rmat != null:
rt.tween_method(func(a: float) -> void: rmat.albedo_color.a = a,
0.75, 0.0, burst_dur)
# Cleanup.
var cleanup: float = burst_dur + 0.3
get_tree().create_timer(cleanup).timeout.connect(func() -> void:
if is_instance_valid(ring): ring.queue_free()
if is_instance_valid(ring2): ring2.queue_free()
if is_instance_valid(burst_root): burst_root.queue_free())
# ── Projectile (non-self targets) ─────────────────────────────────────────────
func _spawn_projectile(
src: Vector3, tgt: Vector3,
affinity_color: Color, player_color: Color) -> void:
if units_root == null:
return
var dist: float = src.distance_to(tgt)
var travel_dur: float = clampf(dist * 0.18, 0.35, 0.8)
var root: Node3D = Node3D.new()
root.name = "AbilityPlaceholderFx"
root.position = src
units_root.add_child(root)
# Core orb (affinity color).
root.add_child(_make_orb(affinity_color, 0.09))
# Inner spark (player color).
root.add_child(_make_orb(player_color, 0.045))
# Four trailing motes orbiting the orb.
for i: int in range(4):
var angle: float = TAU * float(i) / 4.0
var offset: Vector3 = Vector3(cos(angle) * 0.06, 0.0, sin(angle) * 0.06)
var mote: MeshInstance3D = _make_orb(player_color.lerp(affinity_color, 0.4), 0.028)
mote.position = offset
root.add_child(mote)
var tween: Tween = create_tween()
tween.tween_property(root, "position", tgt, travel_dur)\
.set_trans(Tween.TRANS_QUAD).set_ease(Tween.EASE_IN)
tween.tween_callback(func() -> void: _play_impact(root, tgt, affinity_color, player_color))
func _play_impact(
projectile: Node3D, pos: Vector3,
affinity_color: Color, player_color: Color) -> void:
if is_instance_valid(projectile):
projectile.queue_free()
if units_root == null:
return
var impact_dur: float = randf_range(0.5, 0.8)
var ring: MeshInstance3D = _make_impact_ring(
affinity_color.lerp(player_color, 0.35), pos, 0.18, 0.22)
units_root.add_child(ring)
var rng: RandomNumberGenerator = RandomNumberGenerator.new()
rng.randomize()
var burst_root: Node3D = Node3D.new()
burst_root.name = "ImpactBurst"
burst_root.position = pos
units_root.add_child(burst_root)
for i: int in range(8):
var angle: float = TAU * float(i) / 8.0 + rng.randf_range(-0.2, 0.2)
var speed: float = rng.randf_range(0.28, 0.56)
var col: Color = affinity_color if i % 2 == 0 else player_color
var mote: MeshInstance3D = _make_orb(col, rng.randf_range(0.024, 0.055))
mote.position = Vector3.ZERO
burst_root.add_child(mote)
var end_pos: Vector3 = Vector3(
cos(angle) * speed, rng.randf_range(0.0, 0.3), sin(angle) * speed)
var mt: Tween = create_tween()
mt.set_parallel(true)
mt.tween_property(mote, "position", end_pos, impact_dur)\
.set_trans(Tween.TRANS_EXPO).set_ease(Tween.EASE_OUT)
mt.tween_property(mote, "scale", Vector3.ZERO, impact_dur)\
.set_trans(Tween.TRANS_QUAD).set_ease(Tween.EASE_IN)
var rt: Tween = create_tween()
rt.set_parallel(true)
rt.tween_property(ring, "scale", Vector3.ONE * 2.4, impact_dur)\
.set_trans(Tween.TRANS_EXPO).set_ease(Tween.EASE_OUT)
var ring_mat: StandardMaterial3D = ring.material_override as StandardMaterial3D
if ring_mat != null:
rt.tween_method(func(a: float) -> void: ring_mat.albedo_color.a = a,
0.75, 0.0, impact_dur)
var cleanup: float = impact_dur + 0.4
get_tree().create_timer(cleanup).timeout.connect(func() -> void:
if is_instance_valid(ring): ring.queue_free()
if is_instance_valid(burst_root): burst_root.queue_free())
# ── Mesh helpers ──────────────────────────────────────────────────────────────
func _make_orb(color: Color, radius: float) -> MeshInstance3D:
var mi: MeshInstance3D = MeshInstance3D.new()
var mesh: SphereMesh = SphereMesh.new()
mesh.radius = radius
mesh.height = radius * 2.0
mesh.radial_segments = 10
mesh.rings = 5
mi.mesh = mesh
var mat: StandardMaterial3D = StandardMaterial3D.new()
mat.transparency = BaseMaterial3D.TRANSPARENCY_ALPHA
mat.albedo_color = Color(color.r, color.g, color.b, 0.85)
mat.emission_enabled = true
mat.emission = color
mat.emission_energy_multiplier = 2.8
mat.shading_mode = BaseMaterial3D.SHADING_MODE_UNSHADED
mat.cull_mode = BaseMaterial3D.CULL_DISABLED
mi.material_override = mat
return mi
func _make_impact_ring(
color: Color, world_pos: Vector3,
inner: float, outer: float) -> MeshInstance3D:
var mi: MeshInstance3D = MeshInstance3D.new()
var mesh: TorusMesh = TorusMesh.new()
mesh.inner_radius = inner
mesh.outer_radius = outer
mesh.rings = 16
mesh.ring_segments = 8
mi.mesh = mesh
mi.position = world_pos
mi.rotation_degrees.x = 90.0
var mat: StandardMaterial3D = StandardMaterial3D.new()
mat.transparency = BaseMaterial3D.TRANSPARENCY_ALPHA
mat.albedo_color = Color(color.r, color.g, color.b, 0.75)
mat.emission_enabled = true
mat.emission = color
mat.emission_energy_multiplier = 1.8
mat.shading_mode = BaseMaterial3D.SHADING_MODE_UNSHADED
mat.cull_mode = BaseMaterial3D.CULL_DISABLED
mi.material_override = mat
return mi
@@ -48,6 +48,7 @@ var _sel_ctrl : SelectionController = null
var _abt : AbilityTargeting = null
var _prompt_handler: ServerPromptHandler = null
var _repentance_fx : RepentancePlaceholderFx = null
var _ability_fx : AbilityPlaceholderFx = null
# ── @onready node refs ────────────────────────────────────────────────────────
@@ -241,6 +242,13 @@ func _ready() -> void:
_repentance_fx.units_root = _units_root
add_child(_repentance_fx)
# AbilityPlaceholderFx
_ability_fx = AbilityPlaceholderFx.new()
_ability_fx.pathfinder = _pathfinder
_ability_fx.unit_bodies = _mesh_builder.unit_bodies
_ability_fx.units_root = _units_root
add_child(_ability_fx)
# BoardInputHandler
_input_handler = BoardInputHandler.new()
_input_handler.hold_timer = _hold_timer
@@ -310,6 +318,7 @@ func _ready() -> void:
Game.player_pick_request.connect(_prompt_handler.on_player_pick_request)
Game.reveal_choice_pick_request.connect(_prompt_handler.on_reveal_choice_pick_request)
Game.repentance_placeholder_visual.connect(_on_repentance_placeholder_visual)
Game.ability_placeholder_visual.connect(_on_ability_placeholder_visual)
# ── 6. Camera, skybox, hover, chat ───────────────────────────────────────
_cam_ctrl.sync_cam_ctrl_panel()
@@ -384,6 +393,8 @@ func _exit_tree() -> void:
Game.reveal_choice_pick_request.disconnect(_prompt_handler.on_reveal_choice_pick_request)
if Game.repentance_placeholder_visual.is_connected(_on_repentance_placeholder_visual):
Game.repentance_placeholder_visual.disconnect(_on_repentance_placeholder_visual)
if Game.ability_placeholder_visual.is_connected(_on_ability_placeholder_visual):
Game.ability_placeholder_visual.disconnect(_on_ability_placeholder_visual)
_skybox.clear_stars()
_reset_unit_hover_glow()
Chat.set_bubble_host(null)
@@ -1133,6 +1144,11 @@ func _on_repentance_placeholder_visual(payload: Dictionary) -> void:
_repentance_fx.play(payload)
func _on_ability_placeholder_visual(payload: Dictionary) -> void:
if _ability_fx != null:
_ability_fx.play(payload)
func _place_highlight_quad(quad: MeshInstance3D, x: int, y: int,
col: Color, texture: Texture2D = null) -> void:
var tile_top: float = _board_ctrl.tile_visual_tops.get(
+20
View File
@@ -622,6 +622,26 @@ public sealed record RepentancePlaceholderVisualPush(
string Affinity,
IReadOnlyList<AbilityTarget> Targets);
/// <summary>
/// Broadcast to every participant and spectator when an Active ability fires
/// and the ability has no usable custom animation asset.
/// TargetMode tells the client which visual behaviour to use:
/// "Self" — glow burst on the source unit, no projectile
/// "Unit" — projectile from source to target unit
/// "Tile" — projectile from source to tile centre
/// "PlayerZone" — projectile from source to that player's ArchSpirit
/// "None" — fallback self glow burst
/// </summary>
public sealed record AbilityPlaceholderVisualPush(
string EventId,
string SessionId,
string ActorAccountId,
string SourceInstanceId,
string AbilityName,
string SourceAffinity,
IReadOnlyList<AbilityTarget> Targets,
string TargetMode);
// ── DTOs ─────────────────────────────────────────────────────────────────────
/// <summary>
@@ -2,6 +2,7 @@ namespace SOR.Game.Handlers;
using System.Text.Json;
using SOR.Database.Contexts;
using SOR.Game.Abilities;
using SOR.Networking.Abstractions.Messaging;
using SOR.Networking.Abstractions.Push;
using SOR.Networking.Abstractions.Transport;
@@ -42,7 +43,15 @@ internal sealed class GameActivateAbilityHandler : GameHandlerBase, IMessageHand
var session = await LoadActiveSessionAsync(_gameDb, req.SessionId, actorId, ct);
var prevStateJson = session.StateJson!;
var state = GameEngine.Deserialize(prevStateJson);
var newState = GameEngine.ActivateAbility(
// Capture source unit and ability definition before the engine mutates state.
var source = FindSourceUnit(state, req.SourceInstanceId);
var abilities = AbilitySystem.ParseAbilities(source?.AbilitiesJson);
var ability = req.AbilityIndex >= 0 && req.AbilityIndex < abilities.Length
? abilities[req.AbilityIndex]
: null;
var newState = GameEngine.ActivateAbility(
state, actorId, req.SourceInstanceId, req.AbilityIndex, req.Targets);
await SaveStateAsync(_gameDb, session, newState, actorId, "game.activate_ability",
@@ -51,6 +60,34 @@ internal sealed class GameActivateAbilityHandler : GameHandlerBase, IMessageHand
var dto = GameEngine.ToDto(newState, actorId);
await PushStateToPlayersAsync(_clientPush, session, newState, ct, prevStateJson);
// Visual-only push when the ability has no custom animation asset.
if (source is not null && ability is not null)
{
var hasCustomAnim = ability.Animation is { } anim
&& !string.IsNullOrEmpty(anim.AssetUrl);
if (!hasCustomAnim)
{
var visualTargets = ComputeAbilityVisualTargets(
req.Targets, ability, newState, actorId, req.SourceInstanceId);
var targetMode = ComputeAbilityTargetMode(
visualTargets, newState, req.SourceInstanceId);
var visualPush = ServerMessage.Push("game.visual.ability_placeholder",
new AbilityPlaceholderVisualPush(
EventId: Guid.NewGuid().ToString("N")[..8],
SessionId: session.Id.ToString(),
ActorAccountId: actorId,
SourceInstanceId: req.SourceInstanceId,
AbilityName: ability.Name ?? string.Empty,
SourceAffinity: source.Affinity,
Targets: visualTargets,
TargetMode: targetMode));
await BroadcastToAllViewersAsync(_clientPush, session, visualPush, ct);
}
}
return ServerMessage.Reply("game.activate_ability.ack", message.Seq,
new GameActivateAbilityResponse(dto));
}
@@ -113,6 +113,123 @@ internal abstract class GameHandlerBase
await Task.WhenAll(subs.Select(uid => clientPush.PushAsync(uid, push, ct)));
}
// ── Visual push helpers ────────────────────────────────────────────────────
/// <summary>
/// Searches all players' Field lists and ArchSpirit slots for a unit with the
/// given instance ID. Returns null when not found.
/// </summary>
protected static CardInstance? FindSourceUnit(GameState state, string instanceId)
{
foreach (var player in state.Players.Values)
{
if (player.ArchSpirit?.InstanceId == instanceId)
return player.ArchSpirit;
var onField = player.Field.FirstOrDefault(c => c.InstanceId == instanceId);
if (onField is not null)
return onField;
}
return null;
}
/// <summary>
/// Derives the best visual targets for a Repentance card placeholder VFX.
/// Prefers explicit client targets (InstanceId / Coord); falls back to the
/// first live enemy ArchSpirit so the projectile always has a destination.
/// </summary>
protected static IReadOnlyList<AbilityTarget> ComputeVisualTargets(
IReadOnlyList<AbilityTarget>? clientTargets,
GameState state,
string actorId)
{
if (clientTargets is { Count: > 0 })
{
var usable = clientTargets
.Where(t => !string.IsNullOrEmpty(t.InstanceId) || t.Coord is not null)
.ToList();
if (usable.Count > 0) return usable;
}
var enemyArch = state.GetEnemyIds(actorId)
.Select(id => state.Players[id].ArchSpirit)
.FirstOrDefault(a => a is not null);
return enemyArch is not null
? [new AbilityTarget(ActionIndex: 0, InstanceId: enemyArch.InstanceId)]
: [];
}
/// <summary>
/// Derives the best visual targets for an Active ability placeholder VFX.
/// Self/ExactSelf-ownership and All-count abilities resolve to the source unit.
/// Other targetless cases fall back to the first live enemy ArchSpirit.
/// </summary>
protected static IReadOnlyList<AbilityTarget> ComputeAbilityVisualTargets(
IReadOnlyList<AbilityTarget>? clientTargets,
Abilities.Models.AbilityDefinition ability,
GameState state,
string actorId,
string sourceInstanceId)
{
if (clientTargets is { Count: > 0 })
{
var usable = clientTargets
.Where(t => !string.IsNullOrEmpty(t.InstanceId) || t.Coord is not null)
.ToList();
if (usable.Count > 0) return usable;
}
// Self/auto-resolved — point at the source unit.
var firstAction = GetFirstAction(ability);
if (firstAction is not null)
{
var own = firstAction.Target.Ownership;
if (own is Abilities.Models.TargetOwnership.Self
or Abilities.Models.TargetOwnership.ExactSelf
|| firstAction.Target.Count.All)
return [new AbilityTarget(ActionIndex: 0, InstanceId: sourceInstanceId)];
}
// External target absent: aim at first live enemy ArchSpirit.
var enemyArch = state.GetEnemyIds(actorId)
.Select(id => state.Players[id].ArchSpirit)
.FirstOrDefault(a => a is not null);
return enemyArch is not null
? [new AbilityTarget(ActionIndex: 0, InstanceId: enemyArch.InstanceId)]
: [];
}
/// <summary>
/// Derives the TargetMode string the client uses to choose its VFX behaviour.
/// </summary>
protected static string ComputeAbilityTargetMode(
IReadOnlyList<AbilityTarget> visualTargets,
GameState state,
string sourceInstanceId)
{
if (visualTargets.Count == 0) return "None";
var first = visualTargets[0];
if (first.Coord is not null) return "Tile";
var id = first.InstanceId ?? string.Empty;
if (id.Length == 0) return "None";
if (id == sourceInstanceId) return "Self";
if (state.Players.ContainsKey(id)) return "PlayerZone";
return "Unit";
}
// Returns the first concrete Action from an ability definition,
// checking ActionGroup before the legacy Actions array.
private static Abilities.Models.Action? GetFirstAction(
Abilities.Models.AbilityDefinition ability)
{
#pragma warning disable CS0618
if (ability.ActionGroup?.Actions is { Length: > 0 } ag) return ag[0];
if (ability.Actions is { Length: > 0 } lx) return lx[0];
#pragma warning restore CS0618
return null;
}
/// <summary>
/// Broadcast an arbitrary push message to all players and spectators in a session.
/// </summary>
@@ -99,44 +99,4 @@ internal sealed class GamePlayCardHandler : GameHandlerBase, IMessageHandler
return ServerMessage.Reply("game.play_card.ack", message.Seq, new GamePlayCardResponse(dto));
}
/// <summary>
/// Derives the best available visual target list for the placeholder VFX.
///
/// Priority:
/// 1. Client-provided targets that carry a unit InstanceId or tile Coord — already
/// represent a player-chosen target and are valid for all ability types that
/// require explicit targeting.
/// 2. Player-style targets sent as InstanceId (account IDs for player-zone actions).
/// 3. Fallback: the first live enemy ArchSpirit (different team, not eliminated)
/// via GameState.GetEnemyIds, so the projectile always has somewhere to travel
/// for targetless or server-resolved abilities without hitting an ally.
/// </summary>
private static IReadOnlyList<AbilityTarget> ComputeVisualTargets(
IReadOnlyList<AbilityTarget>? clientTargets,
GameState state,
string actorId)
{
// Use whatever the client provided as long as it carries a usable ref or coord.
if (clientTargets is { Count: > 0 })
{
var usable = clientTargets
.Where(t => !string.IsNullOrEmpty(t.InstanceId) || t.Coord is not null)
.ToList();
if (usable.Count > 0)
return usable;
}
// Targetless / server-resolved: aim at the first live enemy ArchSpirit.
// GetEnemyIds filters by different TeamIndex and !IsEliminated, covering both
// FFA and team modes without accidentally targeting an ally or a dead player.
var opponentArch = state.GetEnemyIds(actorId)
.Select(id => state.Players[id].ArchSpirit)
.FirstOrDefault(a => a is not null);
if (opponentArch is not null)
return [new AbilityTarget(ActionIndex: 0, InstanceId: opponentArch.InstanceId)];
return [];
}
}