diff --git a/Client/origin-client/autoloads/Game.gd b/Client/origin-client/autoloads/Game.gd index bbfb29d..a0a570f 100644 --- a/Client/origin-client/autoloads/Game.gd +++ b/Client/origin-client/autoloads/Game.gd @@ -260,6 +260,24 @@ func get_all_enemy_units() -> Array: return units +## Returns all units (field + archSpirit) belonging to allied players +## (same team, not the local player). Empty in FFA games. +func get_ally_units() -> Array: + var my_team : int = int(get_my_player().get("teamIndex", -1)) + var units : Array = [] + if my_team < 0: + return units + for p: Dictionary in state.get("players", []): + var pid : String = str(p.get("accountId", "")) + if pid == Auth.user_id: continue + if int(p.get("teamIndex", -2)) != my_team: continue + units.append_array(_as_array(p.get("field", []))) + var arch = p.get("archSpirit") + if arch is Dictionary and not (arch as Dictionary).is_empty(): + units.append(arch) + return units + + ## Returns a TileDto dict by coord, or {}. func get_tile(x: int, y: int) -> Dictionary: for t: Dictionary in get_tiles(): @@ -468,6 +486,16 @@ func send_reveal_choice_pick_response(request_id: String, ordered_indices: Array # ── Private ─────────────────────────────────────────────────────────────────── +## Pick/response messages where the client optimistically tears down its prompt UI +## before the server confirms. If the server rejects the pick, the pending prompt +## still exists server-side — re-fetching state makes GameGetStateHandler re-push +## it so the player is never stuck without a prompt. +const _PROMPT_RESPONSE_TYPES: Array[String] = [ + "game.triggered_target", "game.cost_pick", "game.cost_group_pick", + "game.action_group_pick", "game.branch_pick", "game.target_pick", + "game.tile_pick", "game.player_pick", "game.reveal_choice_pick", +] + func _game_request(msg_type: String, extra: Dictionary) -> void: var payload := { "sessionId": session_id } payload.merge(extra) @@ -480,7 +508,9 @@ func _game_request(msg_type: String, extra: Dictionary) -> void: _apply_state_from_payload(p), func(code: String, msg: String) -> void: if debug_output: - print("[Game] ERR ", msg_type, " code=", code, " msg=", msg)) + print("[Game] ERR ", msg_type, " code=", code, " msg=", msg) + if msg_type in _PROMPT_RESPONSE_TYPES: + _fetch_state()) func _apply_state_from_payload(p: Variant) -> void: diff --git a/Client/origin-client/scenes/game/components/selection/ability_targeting.gd b/Client/origin-client/scenes/game/components/selection/ability_targeting.gd index 32ca752..1edd3d5 100644 --- a/Client/origin-client/scenes/game/components/selection/ability_targeting.gd +++ b/Client/origin-client/scenes/game/components/selection/ability_targeting.gd @@ -360,20 +360,21 @@ func highlight_ability_targets(action: Dictionary) -> void: emit_signal("highlight_add_requested", tx, ty, "ability") return - # Unit-type target. - var include_enemy: bool = ownership in ["Enemy", "Any"] - var include_friendly: bool = ownership in ["Owner", "Ally", "Any"] - if not include_enemy and not include_friendly: - include_enemy = true - + # Unit-type target. Pools mirror the server's team-aware BuildCandidates: + # Owner = own units only, Ally = teammates only, Enemy = non-allies, Any = everyone. var targets: Array = [] - if include_enemy: + if ownership in ["Enemy", "Any"]: targets.append_array(Game.get_all_enemy_units()) - if include_friendly: + if ownership in ["Owner", "Any"]: 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) + if ownership in ["Ally", "Any"]: + targets.append_array(Game.get_ally_units()) + if targets.is_empty() and not ownership in ["Owner", "Ally", "Enemy", "Any"]: + # Unknown ownership string — fall back to enemies (legacy behaviour). + targets.append_array(Game.get_all_enemy_units()) for u: Dictionary in targets: if type_ in ["Spirit", "ArchSpirit", "SpiritToken", "Ruin"]: @@ -511,6 +512,50 @@ func unit_passes_filters(unit: Dictionary, filters: Array) -> bool: int(src_pos.get("x", 0)), int(src_pos.get("y", 0))) if dist != 1: return false + "genuscontains": + var genus_v: Variant = unit.get("genus") + var genus: Array = genus_v as Array if genus_v is Array else [] + if not genus.has(str(f.get("tag", ""))): + return false + "cardtypeis": + if str(unit.get("cardType", "")) != str(f.get("cardtype", f.get("cardType", ""))): + return false + "affinitymatches": + if str(unit.get("affinity", "")) != str(f.get("affinity", "")): + return false + "tieris": + if int(unit.get("tier", 0)) != int(f.get("tier", 0)): + return false + "healthbelow": + if int(unit.get("currentHealth", 0)) >= int(f.get("n", 0)): + return false + "healthabove": + if int(unit.get("currentHealth", 0)) <= int(f.get("n", 0)): + return false + "damagerange": + var dmg: int = int(unit.get("damage", 0)) + if dmg < int(f.get("min", 0)) or dmg > int(f.get("max", 999)): + return false + "defenserange": + var def_: int = int(unit.get("currentDefense", 0)) + if def_ < int(f.get("min", 0)) or def_ > int(f.get("max", 999)): + return false + "ownership": + var uid: String = str(unit.get("instanceId", "")) + match str(f.get("ownership", "Any")).to_lower(): + "self", "owner", "ally": + if unit_registry != null and not unit_registry.friendly_unit_ids.has(uid): + return false + "enemy", "opponent": + if unit_registry != null and not unit_registry.enemy_unit_ids.has(uid): + return false + "isself": + # Same card definition as the ability source. + if str(unit.get("cardDefinitionId", "")) != str(src.get("cardDefinitionId", "")): + return false + "isexactself": + if str(unit.get("instanceId", "")) != ability_unit_id: + return false for cond: Dictionary in ability_target_conditions: match str(cond.get("$type", "")).to_lower(): "isontilewithaffinity": @@ -578,6 +623,33 @@ func tile_passes_filters(tx: int, ty: int, filters: Array) -> bool: var tile: Dictionary = Game.get_tile(tx, ty) if tile.get("occupantId", null) != null: return false + "tileisoccupied": + var tile: Dictionary = Game.get_tile(tx, ty) + var occ_v: Variant = tile.get("occupantId") + if occ_v == null or str(occ_v).is_empty(): + return false + var want_type: String = str(f.get("unittype", f.get("unitType", ""))) + if not want_type.is_empty() and want_type != "Unit": + var occ_unit: Dictionary = Game.get_unit_by_id(str(occ_v)) + if str(occ_unit.get("cardType", "")) != want_type: + return false + "tileoccupancy": + var tile: Dictionary = Game.get_tile(tx, ty) + var occ_v: Variant = tile.get("occupantId") + if occ_v == null or str(occ_v).is_empty(): + return false + var occ_id: String = str(occ_v) + var occ_unit: Dictionary = Game.get_unit_by_id(occ_id) + var want_type: String = str(f.get("unittype", f.get("unitType", "Unit"))) + if want_type != "Unit" and str(occ_unit.get("cardType", "")) != want_type: + return false + match str(f.get("ownership", "Any")).to_lower(): + "self", "owner", "ally": + if unit_registry != null and not unit_registry.friendly_unit_ids.has(occ_id): + return false + "enemy", "opponent": + if unit_registry != null and not unit_registry.enemy_unit_ids.has(occ_id): + return false return true @@ -859,7 +931,14 @@ func get_ability_actions(ab: Dictionary) -> Array: return legacy var ag: Variant = ab.get("actiongroup") if ag is Dictionary: - return flatten_and_group(ag as Dictionary) + var group: Dictionary = ag as Dictionary + # OR/XOR root group: the server either pauses for an action_group_pick BEFORE + # costs (Self/Opponent chooser) or picks one child at index 0 (Random) — either + # way upfront targets collected against the flattened list would misalign and be + # discarded. The server re-prompts for whatever targets the chosen branch needs. + if str(group.get("logicop", "and")).to_lower() != "and": + return [] + return flatten_and_group(group) return [] diff --git a/Client/origin-client/scenes/game/components/selection/server_prompt_handler.gd b/Client/origin-client/scenes/game/components/selection/server_prompt_handler.gd index 272d9cb..a622039 100644 --- a/Client/origin-client/scenes/game/components/selection/server_prompt_handler.gd +++ b/Client/origin-client/scenes/game/components/selection/server_prompt_handler.gd @@ -319,11 +319,25 @@ func on_branch_pick_request(req: Dictionary) -> void: # ── PendingTargetPick ───────────────────────────────────────────────────────── +# Zone-scope card pick accumulation +var target_pick_selected: Array = [] # [{actionIndex, instanceId}] +var target_pick_required: int = 1 +var target_pick_up_to: bool = false + func on_target_pick_request(req: Dictionary) -> void: _cancel_current_mode() if ability_targeting == null: return + # Zone-scope pick: the server sends an explicit candidates list (hidden zones) — + # show a card list panel instead of board targeting. + var candidates_json: String = str(req.get("candidatesJson", "")) + if not candidates_json.is_empty() and candidates_json != "null" and candidates_json != "": + var cand_raw: Variant = JSON.parse_string(candidates_json) + if cand_raw is Array and not (cand_raw as Array).is_empty(): + _show_zone_target_panel(req, cand_raw as Array) + return + ability_targeting.is_target_pick = true ability_targeting.pending_req_id = str(req.get("requestId", "")) pending_req_id = ability_targeting.pending_req_id @@ -356,6 +370,79 @@ func on_target_pick_request(req: Dictionary) -> void: ability_targeting.ability_targets_this_action = 0 ability_targeting.start_ability_targeting() +## Card-list picker for zone-scope target picks (hand/deck/discard candidates +## enumerated by the server). Resumed action is replayed at index 0 server-side, +## so picks are submitted with actionIndex 0. +func _show_zone_target_panel(req: Dictionary, candidates: Array) -> void: + pending_req_id = str(req.get("requestId", "")) + pending_source_id = str(req.get("sourceInstanceId", "")) + target_pick_selected.clear() + target_pick_required = 1 + target_pick_up_to = false + + # Count requirements come from the action's target selector. + var action_raw: Variant = JSON.parse_string(str(req.get("actionJson", "{}"))) + if action_raw is Dictionary: + var action_n: Dictionary = _normalize_keys(action_raw) as Dictionary + var count_d: Dictionary = (action_n.get("target", {}) as Dictionary).get("count", {}) as Dictionary + target_pick_required = maxi(1, int(count_d.get("n", 1))) + target_pick_up_to = bool(count_d.get("upto", false)) + + hide_pending_prompt_panel() + var panel: PanelContainer = PanelContainer.new() + panel.position = Vector2(8, 140) + var vbox: VBoxContainer = VBoxContainer.new() + vbox.add_theme_constant_override("separation", 6) + vbox.custom_minimum_size = Vector2(210, 0) + + var title: Label = Label.new() + title.text = "Choose %s%d card(s):" % ["up to " if target_pick_up_to else "", target_pick_required] + title.add_theme_font_size_override("font_size", 13) + title.add_theme_color_override("font_color", Color(0.5, 0.9, 1.0)) + vbox.add_child(title) + vbox.add_child(HSeparator.new()) + + for cand: Variant in candidates: + var card_d: Dictionary = cand as Dictionary + var iid: String = str(card_d.get("instanceId", "")) + var name_: String = str(card_d.get("name", iid)) + var ctype: String = str(card_d.get("cardType", "")) + var btn: Button = Button.new() + btn.text = "%s%s" % [name_, "" if ctype.is_empty() else " (%s)" % ctype] + btn.add_theme_font_size_override("font_size", 11) + var cap_iid: String = iid + var cap_btn: Button = btn + btn.pressed.connect(func() -> void: + for sel_v: Variant in target_pick_selected: + if str((sel_v as Dictionary).get("instanceId", "")) == cap_iid: + return + target_pick_selected.append({ "actionIndex": 0, "instanceId": cap_iid }) + cap_btn.modulate = Color(0.4, 1.0, 0.5) + if target_pick_selected.size() >= target_pick_required: + _finish_zone_target_pick()) + vbox.add_child(btn) + + if target_pick_up_to: + var done: Button = Button.new() + done.text = "Done Selecting" + done.add_theme_font_size_override("font_size", 12) + done.pressed.connect(_finish_zone_target_pick) + vbox.add_child(HSeparator.new()) + vbox.add_child(done) + + panel.add_child(vbox) + if hud != null: + hud.add_child(panel) + pending_prompt_panel = panel + + +func _finish_zone_target_pick() -> void: + hide_pending_prompt_panel() + var rid: String = pending_req_id + pending_req_id = "" + Game.send_target_pick_response(rid, target_pick_selected.duplicate()) + target_pick_selected.clear() + # ── PendingTilePick ─────────────────────────────────────────────────────────── func on_tile_pick_request(req: Dictionary) -> void: diff --git a/SOR.Abilities-Review-and-solutions.md b/SOR.Abilities-Review-and-solutions.md index a746f41..205ef26 100644 --- a/SOR.Abilities-Review-and-solutions.md +++ b/SOR.Abilities-Review-and-solutions.md @@ -33,11 +33,95 @@ > - **Builder** — UpTo checkbox added (parsed/compiled); dead triggers/effects delisted. > - **Client** — cost-group / action-group prompt labels fixed (normalized keys + amounts). > -> **Deferred** (see §7): validation-on-save endpoint (Phase 2.9), remaining H5 effects -> (SearchAndPlace→Battlefield, RevealCards N/ToOwnership, ChannelCardFromZone Filters/range flags, -> TakeControl duration reversal), H8 duration edge cases, H9 builder round-trip preservation, -> Phase 3 builder fields, Phase 4 client parity items (zone-scope card picking, prompt resilience, -> filter parity, OR-group UX), Phase 5 hygiene. +> **Also implemented (second pass):** +> - **Test suite** — new `Server/tests/SOR.Game.Tests` (added to SOR.slnx): 17 passing tests +> covering §8 tests 1–5 (passives-via-ActionGroup, ArchSpirit triggers, triggered pick at +> index 1, PreventDeath options, team-aware targeting, DOT tick gating, parse hardening, +> state-backed trigger limits/shields) plus 7 validator tests. +> - **Validation-on-save (Phase 2.9)** — new `SOR.Game.Abilities.AbilityValidator` (engine +> round-trip + structural lint: dead triggers, no-op effects, Repentance/Instinct shape, +> Range on effect cards, OR-group Passives, TokenDefJson incl. nested abilities); wired +> into `CardEditor.SaveAsync`, which blocks the save and lists the errors. +> - **SearchAndPlace Destination=Battlefield** — now places on a random affinity-valid empty +> tile (with enter-triggers/auras/passives), falling back to hand. +> +> **Also implemented (third pass):** +> - **H9 builder round-trip preservation** — every draft (ability/action/effect/condition/cost) +> stashes its original `JsonObject`; `Compile()` clones it and rewrites only UI-owned keys, +> guarded by `$type` so switching types drops stale fields. Preserved now: `SourceZoneGate`, +> `TriggerLimitPerGame`, `OnEnter/OnLeaveAuraActions`, `ChooseOne`, filter parameters + +> extra filters, cost `PickMode`/`Filters`, nested cost/action groups, trigger `Filter` +> params/`CardDefinitionId`/`AmountComparator`, unmodeled effect fields. +> - **ChannelCardFromZone.Filters** now enforced at all three resolution sites. +> - **Client prompt resilience (M11)** — a rejected pick response triggers `_fetch_state()`, +> which re-pushes the still-pending prompt (Game.gd `_PROMPT_RESPONSE_TYPES`). +> +> **Also implemented (fourth pass):** +> - **H8 duration edge cases** — `UntilStartOfSourceOwnerTurn` now anchors to the source +> unit's owner (`TrackedDuration.SourceOwnerAccountId`, old records fall back to the actor); +> `ReapplyAurasAtTurnStart` strips only aura-applied effects (`TrackedDuration.IsAura`, +> stamped via `AbilityContext.IsAuraApplication`) instead of every effect from that source. +> - **TakeControl duration reversal** — internal `__ReturnControl` effect tracked with the +> take-control duration; control (and the board occupant-owner) returns to the original +> owner on expiry. PermanentInMatch keeps control permanently. +> - **ChannelCardFromZone range flags** — `InOwnChannelRange` / `InTargetChannelRange` +> enforced via a shared `IsWithinChannelConstraints` helper at all three resolution sites, +> including validation of player-picked tiles (throws `OUT_OF_CHANNEL_RANGE`, client re-prompts). +> - **RevealCards N** — a player-targeted RevealCards now reveals the top N deck cards +> (ToOwnership still needs a per-player visibility model — deferred). +> - **Builder fields** — cost `PickMode` dropdown (pickable cost types only), +> `TriggerLimitPerGame` and `SourceZoneGate` inputs on Triggered abilities; all three +> added to the UI-owned key handling. +> - **Client filter parity (subset)** — `GenusContains`, `CardTypeIs`, `AffinityMatches`, +> `TierIs`, `HealthBelow/Above`, `DamageRange`, `DefenseRange`, `Ownership`, +> `IsSelf`/`IsExactSelf` unit filters and `TileIsOccupied`/`TileOccupancy` tile filters +> now enforced in targeting highlights/click validation. +> - Tests: 19 passing (added TakeControl reversal + source-owner expiry). +> +> **Also implemented (fifth pass):** +> - **H2 zone-scope card picking** — for Hand/Deck/Discard/AnyZone card targets on +> player-driven paths, the engine now pauses with a server-enumerated candidates list +> (`PendingTargetPick.CandidatesJson`, pushed in `TargetPickRequestPush`); the client's +> player/zone panel flow feeds into a new card-list picker (`_show_zone_target_panel` +> in server_prompt_handler.gd). AccountId placeholders are auto-substituted when +> there is no real choice. +> - **Prompt-instead-of-throw** — a mandatory explicit pick with no submitted targets on a +> player-driven path now emits `PendingTargetPick` (guarded by a non-empty-pool check) +> instead of `INSUFFICIENT_TARGETS`; all post-pick resume flows +> (cost/cost-group/action-group/branch/tile/player/reveal) now run with +> `requireClientTargets: true`, so "choose an enemy" actions after an OR-pick **prompt** +> rather than silently auto-hitting the first candidate. +> - **M13 OR-group UX** — the client no longer collects speculative targets for OR/XOR-root +> abilities (indices would misalign and be discarded); the server drives the flow. +> - **Hygiene** — `IsAllyTurn` now means "a teammate's turn" (was identical to IsOwnTurn); +> content-keyed `ParseAbilities` cache (bounded, safe: parsed defs are engine-immutable) +> removes the per-event JSON parse of every card in every zone. +> - Tests: 21 passing (added zone-pick pause/resume + prompt-instead-of-throw). +> +> **Also implemented (sixth pass, 2026-07-03):** +> - **Multi-filter editor** — the single param-less "Target Filter" dropdown is replaced by +> a full filter list per action (form view + canvas inspector): 28 filter types grouped +> Unit/Card vs Tile, each with its parameter fields (`FilterDraft`, `ParseFilter`, +> `CompileFilter`, `RenderFilterFields`). Nested-parameter filters +> (IsAdjacentToUnitMatching etc.) are selectable with their inner params preserved via +> the round-trip overlay. +> - **ChooseOne editor (advanced)** — per-action raw-JSON textarea (same pattern as +> AddAbility/ApplyOnEvent); parsed/compiled with fallback to the loaded value on +> invalid JSON. Branch abilities are now authorable. +> - **M14 allied pools** — new `Game.get_ally_units()`; highlight pools now mirror the +> server's team-aware semantics (Owner = own only, Ally = teammates only, +> Enemy = non-allies, Any = everyone). +> +> **Also implemented (seventh pass, 2026-07-04):** +> - PolyType duplicate attributes removed from sealed condition/filter classes (the +> converter only reads the base-type registry — verified inert before removal). +> - `IgnoreTurnConstraint` decided: documented as **reserved/no-effect** — ability-driven +> channels are never subject to the own-turn constraint (model doc comment updated). +> +> **Remaining backlog (feature work, not defects):** RevealCards `ToOwnership` — blocked on +> a per-player card-visibility model; structured (non-JSON) ChooseOne branch editor — the +> raw-JSON editor covers authoring today. Everything else from this review is resolved and +> covered by the 21-test regression suite in `Server/tests/SOR.Game.Tests`. **Date:** 2026-07-02 **Scope reviewed:** diff --git a/Server/SOR.slnx b/Server/SOR.slnx index a3f907c..babea70 100644 --- a/Server/SOR.slnx +++ b/Server/SOR.slnx @@ -24,4 +24,7 @@ + + + diff --git a/Server/src/SOR.Admin/Components/Pages/Cards/AbilityBuilder.razor b/Server/src/SOR.Admin/Components/Pages/Cards/AbilityBuilder.razor index 5b0424c..0a400c9 100644 --- a/Server/src/SOR.Admin/Components/Pages/Cards/AbilityBuilder.razor +++ b/Server/src/SOR.Admin/Components/Pages/Cards/AbilityBuilder.razor @@ -136,6 +136,15 @@ + @if (PickableCostTypes.Contains(cost.TypeStr)) + { + + } + @for (int flI = 0; flI < action.Filters.Count; flI++) + { + var flIdx = flI; + var flt = action.Filters[flIdx]; +
+ + @RenderFilterFields(flt) + +
+ } + + + +
+ +
@@ -1543,15 +1598,39 @@ } - - +
+ Target Filters + +
+ @for (int inFlI = 0; inFlI < inAct.Filters.Count; inFlI++) + { + int inFlIdx = inFlI; + var inFlt = inAct.Filters[inFlIdx]; +
+
+ + +
+
+ @RenderFilterFields(inFlt) +
+
+ } @* Action conditions *@
@@ -2209,6 +2288,15 @@ "DealDamageToOwnArchSpirit", "DealDamageToOwnSpirit", ]; + /// Cost types the engine supports interactive PickMode for. + private static readonly string[] PickableCostTypes = [ + "DiscardFromHand", "SendSpiritFromBattlefieldToDiscard", "DealDamageToOwnSpirit", + ]; + + private static readonly string[] CostPickModeValues = [ + "", "Random", "SelfPick", "EnemySeePick", "EnemyRandomPick", "EnemyPick", + ]; + // Only triggers the engine actually fires AND matches are listed here. // NOT yet implemented server-side (do not re-add without engine support — // see SOR.Abilities-Review-and-solutions.md §C3): @@ -2284,6 +2372,27 @@ new("Composite", ["AND", "OR", "XOR", "NOT"]), ]; + // ── Filter groups (target-pool filters) ────────────────────────────────────── + + private static readonly EffectGroup[] FilterGroups = + [ + new("Unit / Card", ["GenusContains", "AffinityMatches", "HealthBelow", "HealthAbove", + "DamageRange", "DefenseRange", "MPRange", "HasFlag", "TierIs", + "IsAdjacentToSource", "CardTypeIs", "CardSPCostRange", "CardSTCostRange", + "WithinRange", "IsSelf", "IsExactSelf", + "IsAdjacentToUnitMatching", "IsAdjacentToTileMatching", + "Ownership", "UnitProperty"]), + new("Tile", ["TileAffinityMatches", "TileIsOccupied", "TileIsUnoccupied", + "TileWithinRange", "TileIsAdjacentToUnit", "TileIsOnPlayerSide", + "TileIsInArchSpiritChannelRange", "TileOccupancy"]), + ]; + + /// Flags the engine's HasFlagFilter actually evaluates. + private static readonly string[] FilterFlagValues = ["CanMove", "CanAttack", "IsLeader", "IsExhausted"]; + + private static readonly string[] CardTypeIsValues = + ["Spirit", "ArchSpirit", "SpiritToken", "Repentance", "Instinct", "Terramorpha", "Ruin"]; + // ── Effect type categories for rendering ───────────────────────────────────── private static readonly HashSet _amountBypassTypes = ["DealDamage", "DealDamageToSelf"]; @@ -2373,11 +2482,16 @@ { var ab = new AbilityDraft { + Original = node, TypeStr = node["Type"]?.GetValue() ?? "Active", Name = node["Name"]?.GetValue() ?? "", Description = node["Description"]?.GetValue() ?? "", UsesPerTurn = node["UsesPerTurn"]?.GetValue() ?? 1, TriggerLimitPerTurn = node["TriggerLimitPerTurn"]?.GetValue(), + TriggerLimitPerGame = node["TriggerLimitPerGame"]?.GetValue(), + SourceZoneGate = node["SourceZoneGate"] is JsonArray szg + ? string.Join(", ", szg.Select(z => z?.GetValue() ?? "").Where(z => !string.IsNullOrEmpty(z))) + : "", RangeMin = node["Range"]?["Min"]?.GetValue(), RangeMax = node["Range"]?["Max"]?.GetValue(), RangeRequiresLos = node["Range"]?["RequiresLos"]?.GetValue() ?? false, @@ -2419,16 +2533,20 @@ foreach (var c in cgEntries.OfType()) ab.Costs.Add(new CostDraft { + Original = c, TypeStr = c["Type"]?.GetValue() ?? "SpiritPoints", Amount = c["Amount"]?.GetValue() ?? 1, + PickModeStr = c["PickMode"]?.GetValue() ?? "", }); } else if (node["Cost"] is JsonArray costs) foreach (var c in costs.OfType()) ab.Costs.Add(new CostDraft { + Original = c, TypeStr = c["Type"]?.GetValue() ?? "SpiritPoints", Amount = c["Amount"]?.GetValue() ?? 1, + PickModeStr = c["PickMode"]?.GetValue() ?? "", }); if (node["ActivationConditions"] is JsonArray aconds) @@ -2461,6 +2579,7 @@ { LogicOp = sgNode["LogicOp"]?.GetValue() ?? "And", ChooserRole = sgNode["ChooserRole"]?.GetValue() ?? "Self", + OriginalNestedGroups = sgNode["Groups"] as JsonArray, }; if (sgNode["Actions"] is JsonArray sgActions) foreach (var sgActionNode in sgActions.OfType()) @@ -2498,6 +2617,7 @@ private static ConditionDraft ParseCondition(JsonObject c) => new() { + Original = c, TypeStr = c["$type"]?.GetValue() ?? "IsOwnTurn", Subject = c["Subject"]?.GetValue() ?? "Self", N = c["N"]?.GetValue() ?? 1, @@ -2524,7 +2644,7 @@ private static EffectDraft ParseEffect(JsonObject eff) { var typeKey = eff["$type"]?.GetValue() ?? "DealDamage"; - var d = new EffectDraft { TypeKey = typeKey }; + var d = new EffectDraft { TypeKey = typeKey, Original = eff }; // ValueExpr helpers — eff[key] may be a raw JsonValue (legacy) or a JsonObject // with a "Fixed" int field or a "Ref" string field. Calling GetValue() on a @@ -2734,10 +2854,10 @@ private static ActionDraft ParseActionNode(JsonObject actionNode) { - var target = actionNode["Target"] as JsonObject; - var firstFilter = (target?["Filters"] as JsonArray)?.OfType().FirstOrDefault(); + var target = actionNode["Target"] as JsonObject; var act = new ActionDraft { + Original = actionNode, Scope = target?["Scope"]?.GetValue() ?? "Battlefield", TargetType = target?["Type"]?.GetValue() ?? "Unit", Ownership = target?["Ownership"]?.GetValue() ?? "Enemy", @@ -2745,8 +2865,12 @@ Count = target?["Count"]?["N"]?.GetValue() ?? 1, All = target?["Count"]?["All"]?.GetValue() ?? false, UpTo = target?["Count"]?["UpTo"]?.GetValue() ?? false, - FilterType = firstFilter?["$type"]?.GetValue() ?? "", }; + if (target?["Filters"] is JsonArray filtersArr) + foreach (var f in filtersArr.OfType()) + act.Filters.Add(ParseFilter(f)); + if (actionNode["ChooseOne"] is JsonObject chooseOne) + act.ChooseOneJson = chooseOne.ToJsonString(); if (actionNode["Duration"] is JsonObject actionDur) { act.DurationStr = actionDur["Type"]?.GetValue() ?? ""; @@ -2763,6 +2887,20 @@ // ── Compile ────────────────────────────────────────────────────────────────── + /// + /// Top-level AbilityDefinition keys the UI owns and rewrites on every compile. + /// Anything NOT in this list (SourceZoneGate, TriggerLimitPerGame, + /// OnEnterAuraActions, OnLeaveAuraActions, future fields…) is preserved from the + /// loaded JSON so an open → save round-trip never strips it. + /// + private static readonly string[] _abilityOwnedKeys = + [ + "Type", "Name", "Description", "Range", "UsesPerTurn", + "CostGroup", "Cost", "AuraRange", "ClearOnLeave", "LingerDuration", + "TriggerEvent", "TriggerLimitPerTurn", "TriggerLimitPerGame", "SourceZoneGate", + "ActivationConditions", "ActionGroup", "Actions", "Duration", "Animation", + ]; + private void Compile() { try @@ -2771,12 +2909,16 @@ foreach (var ab in _abilities) { - var node = new JsonObject - { - ["Type"] = ab.TypeStr, - ["Name"] = ab.Name, - ["Description"] = ab.Description, - }; + // Start from the loaded node (preserve-unknown), then rewrite UI-owned keys. + var node = ab.Original is not null + ? (JsonObject)ab.Original.DeepClone() + : new JsonObject(); + foreach (var owned in _abilityOwnedKeys) + node.Remove(owned); + + node["Type"] = ab.TypeStr; + node["Name"] = ab.Name; + node["Description"] = ab.Description; if (ab.TypeStr == "Active") { @@ -2800,8 +2942,24 @@ costGroup["ChooserRole"] = ab.CostGroupChooserRole; var entriesArr = new JsonArray(); foreach (var cost in ab.Costs) - entriesArr.Add(new JsonObject { ["Type"] = cost.TypeStr, ["Amount"] = cost.Amount }); + { + // Preserve unmodeled entry fields (Filters) when Type unchanged. + var entryNode = cost.Original is not null + && string.Equals(cost.Original["Type"]?.GetValue(), cost.TypeStr, StringComparison.Ordinal) + ? (JsonObject)cost.Original.DeepClone() + : new JsonObject(); + entryNode["Type"] = cost.TypeStr; + entryNode["Amount"] = cost.Amount; + if (!string.IsNullOrEmpty(cost.PickModeStr)) + entryNode["PickMode"] = cost.PickModeStr; + else + entryNode.Remove("PickMode"); + entriesArr.Add(entryNode); + } costGroup["Entries"] = entriesArr; + // Nested cost groups are not modeled by the UI — carry them through. + if (ab.Original?["CostGroup"]?["Groups"] is JsonArray origCostGroups && origCostGroups.Count > 0) + costGroup["Groups"] = origCostGroups.DeepClone(); node["CostGroup"] = costGroup; } } @@ -2824,9 +2982,20 @@ } else if (ab.TypeStr == "Triggered" && !string.IsNullOrEmpty(ab.TriggerType)) { - node["TriggerEvent"] = CompileTrigger(ab); + node["TriggerEvent"] = CompileTrigger(ab, + ab.Original?["TriggerEvent"] as JsonObject); if (ab.TriggerLimitPerTurn is > 0) node["TriggerLimitPerTurn"] = ab.TriggerLimitPerTurn.Value; + if (ab.TriggerLimitPerGame is > 0) + node["TriggerLimitPerGame"] = ab.TriggerLimitPerGame.Value; + var zones = ab.SourceZoneGate + .Split(',', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries); + if (zones.Length > 0) + { + var zoneArr = new JsonArray(); + foreach (var z in zones) zoneArr.Add(z); + node["SourceZoneGate"] = zoneArr; + } } if (ab.Conditions.Count > 0) @@ -2857,7 +3026,10 @@ if (sg.LogicOp != "And" || sg.ChooserRole != "Self") subGroup["ChooserRole"] = sg.ChooserRole; subGroup["Actions"] = sgActionsArr; - subGroup["Groups"] = new JsonArray(); + // Preserve deeper nesting the UI does not model. + subGroup["Groups"] = sg.OriginalNestedGroups is not null + ? (JsonArray)sg.OriginalNestedGroups.DeepClone() + : new JsonArray(); groupsArr.Add(subGroup); } actionGroup["Groups"] = groupsArr; @@ -2901,6 +3073,32 @@ private static JsonObject CompileActionNode(ActionDraft action) { + // Preserve-unknown: unmodeled action keys (ChooseOne, …) carry through from + // the loaded node; UI-owned keys are removed and rewritten below. + var actionNode = action.Original is not null + ? (JsonObject)action.Original.DeepClone() + : new JsonObject(); + actionNode.Remove("Target"); + actionNode.Remove("Conditions"); + actionNode.Remove("Effects"); + actionNode.Remove("Duration"); + actionNode.Remove("ChooseOne"); + + // ChooseOne (advanced, raw JSON). Invalid JSON falls back to the loaded value. + if (!string.IsNullOrWhiteSpace(action.ChooseOneJson)) + { + try + { + if (JsonNode.Parse(action.ChooseOneJson) is JsonObject co) + actionNode["ChooseOne"] = co; + } + catch + { + if (action.Original?["ChooseOne"] is JsonObject origCo) + actionNode["ChooseOne"] = (JsonObject)origCo.DeepClone(); + } + } + var targetNode = new JsonObject { ["Scope"] = action.Scope, @@ -2914,10 +3112,14 @@ ["All"] = action.All, }, }; - if (!string.IsNullOrEmpty(action.FilterType)) - targetNode["Filters"] = new JsonArray( - new JsonObject { ["$type"] = action.FilterType }); - var actionNode = new JsonObject { ["Target"] = targetNode }; + if (action.Filters.Count > 0) + { + var filtersArr = new JsonArray(); + foreach (var flt in action.Filters) + filtersArr.Add(CompileFilter(flt)); + targetNode["Filters"] = filtersArr; + } + actionNode["Target"] = targetNode; if (action.Conditions.Count > 0) { var ca = new JsonArray(); @@ -2937,10 +3139,84 @@ return actionNode; } + private static FilterDraft ParseFilter(JsonObject f) => new() + { + Original = f, + TypeStr = f["$type"]?.GetValue() ?? "GenusContains", + Tag = f["Tag"]?.GetValue() ?? "", + Affinity = f["Affinity"]?.GetValue() ?? "Aether", + N = f["N"]?.GetValue() ?? 1, + Min = f["Min"]?.GetValue() ?? 1, + Max = f["Max"]?.GetValue() ?? 2, + Flag = f["Flag"]?.GetValue() ?? "CanAttack", + Tier = f["Tier"]?.GetValue() ?? 1, + CardType = f["CardType"]?.GetValue() ?? "Spirit", + UnitType = f["UnitType"]?.GetValue() ?? "Unit", + Ownership = f["Ownership"]?.GetValue() ?? "Any", + PropertyName = f["PropertyName"]?.GetValue() ?? "Damage", + Comparator = f["Comparator"]?.GetValue() ?? "GreaterThanOrEqual", + Value = f["Value"]?.GetValue() ?? 1, + }; + + private static JsonObject CompileFilter(FilterDraft f) + { + // Preserve nested/unmodeled parameters when the filter type is unchanged. + var node = f.Original is not null + && string.Equals(f.Original["$type"]?.GetValue(), f.TypeStr, StringComparison.Ordinal) + ? (JsonObject)f.Original.DeepClone() + : new JsonObject(); + node["$type"] = f.TypeStr; + + switch (f.TypeStr) + { + case "GenusContains": + node["Tag"] = f.Tag; break; + case "AffinityMatches": case "TileAffinityMatches": + node["Affinity"] = f.Affinity; break; + case "HealthBelow": case "HealthAbove": + node["N"] = f.N; break; + case "DamageRange": case "DefenseRange": case "MPRange": + case "CardSPCostRange": case "CardSTCostRange": + case "WithinRange": case "TileWithinRange": + node["Min"] = f.Min; node["Max"] = f.Max; break; + case "HasFlag": + node["Flag"] = f.Flag; break; + case "TierIs": + node["Tier"] = f.Tier; break; + case "CardTypeIs": + node["CardType"] = f.CardType; break; + case "TileIsOccupied": + if (!string.IsNullOrEmpty(f.UnitType) && f.UnitType != "Unit") node["UnitType"] = f.UnitType; + else node.Remove("UnitType"); + break; + case "Ownership": case "TileIsOnPlayerSide": case "TileIsInArchSpiritChannelRange": + node["Ownership"] = f.Ownership; break; + case "UnitProperty": + node["PropertyName"] = f.PropertyName; + node["Comparator"] = f.Comparator; + node["Value"] = f.Value; + break; + case "TileOccupancy": + node["UnitType"] = f.UnitType; + node["Ownership"] = f.Ownership; + break; + // IsSelf / IsExactSelf / IsAdjacentToSource / TileIsUnoccupied — no parameters. + // IsAdjacentToUnitMatching / IsAdjacentToTileMatching / TileIsAdjacentToUnit — + // nested UnitFilters/TileFilters preserved via the overlay; no UI-owned fields. + } + return node; + } + private static JsonObject CompileCondition(ConditionDraft c) { - var node = new JsonObject { ["$type"] = c.TypeStr }; + // Preserve unmodeled parameters when the condition type is unchanged. + var node = c.Original is not null + && string.Equals(c.Original["$type"]?.GetValue(), c.TypeStr, StringComparison.Ordinal) + ? (JsonObject)c.Original.DeepClone() + : new JsonObject(); + node["$type"] = c.TypeStr; if (c.Subject != "Self") node["Subject"] = c.Subject; + else node.Remove("Subject"); switch (c.TypeStr) { @@ -2968,7 +3244,9 @@ case "MovementTypeIs": node["MovementType"] = c.MovementType; break; case "TileIsOccupied": - if (!string.IsNullOrEmpty(c.UnitType)) node["UnitType"] = c.UnitType; break; + if (!string.IsNullOrEmpty(c.UnitType)) node["UnitType"] = c.UnitType; + else node.Remove("UnitType"); + break; case "IsActivePlayerTurn": node["Ownership"] = c.Ownership; break; case "UnitCountOnBattlefield": @@ -3013,7 +3291,9 @@ break; case "HandContainsCount": if (!string.IsNullOrEmpty(c.Tag)) node["CardType"] = c.Tag; + else node.Remove("CardType"); if (c.Affinity != "Aether") node["Affinity"] = c.Affinity; + else node.Remove("Affinity"); node["Comparator"] = c.Comparator; node["N"] = c.N; break; @@ -3036,17 +3316,25 @@ case "CostOfCardsInHand": node["CostType"] = c.CostType; if (!string.IsNullOrEmpty(c.Tag)) node["CardType"] = c.Tag; + else node.Remove("CardType"); if (c.Affinity != "Aether") node["Affinity"] = c.Affinity; + else node.Remove("Affinity"); node["Comparator"] = c.Comparator; node["Value"] = c.Value; break; } return node; } - private static JsonObject CompileTrigger(AbilityDraft ab) + private static JsonObject CompileTrigger(AbilityDraft ab, JsonObject? original = null) { var t = ab.TriggerType; - var n = new JsonObject { ["$type"] = t }; + // Preserve unmodeled trigger fields (Filter parameters, CardDefinitionId, + // AmountComparator, OccupantFilters, …) when the trigger type is unchanged. + var n = original is not null + && string.Equals(original["$type"]?.GetValue(), t, StringComparison.Ordinal) + ? (JsonObject)original.DeepClone() + : new JsonObject(); + n["$type"] = t; // Player-only if (t is "OnTurnStart" or "OnTurnEnd" or "OnCardDrawn" @@ -3060,12 +3348,14 @@ { n["Player"] = ab.TriggerPlayer; if (ab.TriggerAmount.HasValue) n["Amount"] = ab.TriggerAmount.Value; + else n.Remove("Amount"); } // Player + optional Cause else if (t == "OnCardDiscarded") { n["Player"] = ab.TriggerPlayer; if (!string.IsNullOrEmpty(ab.TriggerCause)) n["Cause"] = ab.TriggerCause; + else n.Remove("Cause"); } // Ownership-only else if (t is "OnAscend" or "OnTransition" or "OnUnitMove" or "OnUnitAttack" @@ -3079,12 +3369,14 @@ { n["Ownership"] = ab.TriggerOwnership; if (ab.TriggerAmount.HasValue) n["Amount"] = ab.TriggerAmount.Value; + else n.Remove("Amount"); } // Ownership + optional Stat else if (t == "OnStatModified") { n["Ownership"] = ab.TriggerOwnership; if (!string.IsNullOrEmpty(ab.TriggerStat)) n["Stat"] = ab.TriggerStat; + else n.Remove("Stat"); } // Ownership + CardType else if (t == "OnChanneled") @@ -3104,6 +3396,7 @@ n["Ownership"] = ab.TriggerOwnership; n["UnitType"] = ab.TriggerUnitType; if (!string.IsNullOrEmpty(ab.TriggerCausedBy)) n["CausedBy"] = ab.TriggerCausedBy; + else n.Remove("CausedBy"); } // SourceOwnership + TargetOwnership + optional DamageType + optional Amount else if (t == "OnDamageDealt") @@ -3111,9 +3404,20 @@ n["SourceOwnership"] = ab.TriggerSourceOwnership; n["TargetOwnership"] = ab.TriggerTargetOwnership; if (ab.TriggerDamageType != "Any") n["DamageType"] = ab.TriggerDamageType; + else n.Remove("DamageType"); if (ab.TriggerAmount.HasValue) n["Amount"] = ab.TriggerAmount.Value; + else n.Remove("Amount"); if (!string.IsNullOrWhiteSpace(ab.TriggerSourceFilterType)) - n["SourceFilter"] = new JsonObject { ["$type"] = ab.TriggerSourceFilterType }; + { + // Keep the original SourceFilter (with its parameters) when its type is unchanged. + var origSf = n["SourceFilter"] as JsonObject; + if (origSf?["$type"]?.GetValue() != ab.TriggerSourceFilterType) + n["SourceFilter"] = new JsonObject { ["$type"] = ab.TriggerSourceFilterType }; + } + else + { + n.Remove("SourceFilter"); + } } else if (t == "BeforeDamageApplied") { @@ -3130,6 +3434,7 @@ { n["TargetOwnership"] = ab.TriggerTargetOwnership; if (ab.TriggerAmount.HasValue) n["Amount"] = ab.TriggerAmount.Value; + else n.Remove("Amount"); } // TargetOwnership + SourceOwnership else if (t is "OnTargetedByAbility" or "OnEffectApplied") @@ -3143,6 +3448,8 @@ n["RuinOwnership"] = ab.TriggerRuinOwnership; if (!string.IsNullOrEmpty(ab.TriggerOccupantOwnership)) n["OccupantOwnership"] = ab.TriggerOccupantOwnership; + else + n.Remove("OccupantOwnership"); } // UnitOwnership only else if (t == "OnUnitOccupyRuin") @@ -3162,7 +3469,13 @@ private static JsonObject CompileEffect(EffectDraft d) { - var node = new JsonObject { ["$type"] = d.TypeKey }; + // Preserve unmodeled effect fields (ToOwnership, TileFilter params, ThenGroup, …) + // when the effect type is unchanged; switching types starts from a clean node. + var node = d.Original is not null + && string.Equals(d.Original["$type"]?.GetValue(), d.TypeKey, StringComparison.Ordinal) + ? (JsonObject)d.Original.DeepClone() + : new JsonObject(); + node["$type"] = d.TypeKey; JsonObject ValueExpr() => string.IsNullOrEmpty(d.AmountRef) ? new JsonObject { ["Fixed"] = d.Amount } @@ -3212,6 +3525,7 @@ { node["Tiles"] = d.Tiles; if (d.BlockedDamage > 0) node["BlockedDamage"] = d.BlockedDamage; + else node.Remove("BlockedDamage"); } else if (d.TypeKey == "DisplaceUnit") { @@ -3221,9 +3535,13 @@ { node["Tiles"] = d.Tiles; if (d.AdjacentToSource) node["AdjacentToSource"] = true; + else node.Remove("AdjacentToSource"); if (!string.IsNullOrWhiteSpace(d.RelativeToTargetRef)) node["RelativeToTargetRef"] = d.RelativeToTargetRef; + else node.Remove("RelativeToTargetRef"); if (d.AdjacentToRelativeTarget) node["AdjacentToRelativeTarget"] = true; + else node.Remove("AdjacentToRelativeTarget"); if (d.AllowRelativeTargetTile) node["AllowRelativeTargetTile"] = true; + else node.Remove("AllowRelativeTargetTile"); } else if (d.TypeKey == "SetAttackRange") { @@ -3268,7 +3586,9 @@ else if (d.TypeKey == "ModifyCost") { if (d.Sp.HasValue) node["Sp"] = d.Sp.Value; + else node.Remove("Sp"); if (d.St.HasValue) node["St"] = d.St.Value; + else node.Remove("St"); } else if (d.TypeKey == "SetStatModMultiplier") { @@ -3325,11 +3645,16 @@ node["TileFilter"] = new JsonArray( new JsonObject { ["$type"] = "TileAffinityMatches", ["Affinity"] = d.TokenAffinity }); } + else + { + node.Remove("TileFilter"); + } } else if (d.TypeKey is "AscendFromZone" or "TransitionFromZone") { node["Zone"] = d.Zone; if (d.IgnoreCost) node["IgnoreCost"] = true; + else node.Remove("IgnoreCost"); } else if (d.TypeKey == "ModifyChannelRange") { @@ -3359,6 +3684,10 @@ } else if (_rawJsonTypes.Contains(d.TypeKey)) { + // Raw-JSON effects: the textarea IS the whole definition — replace every + // field so deletions made in the raw editor actually take effect. + foreach (var staleKey in node.Select(kv => kv.Key).Where(k => k != "$type").ToList()) + node.Remove(staleKey); if (!string.IsNullOrWhiteSpace(d.RawJson)) { try @@ -3378,6 +3707,44 @@ // ── Per-type field renderers (RenderFragment) ───────────────────────────────── + private RenderFragment RenderFilterFields(FilterDraft f) => __builder => + { + switch (f.TypeStr) + { + case "GenusContains": + BuildTextInput(__builder, f.Tag, v => { f.Tag = v; Compile(); }, 120, "Tag"); break; + case "AffinityMatches": case "TileAffinityMatches": + BuildSelect(__builder, AffinityValues, f.Affinity, v => { f.Affinity = v; Compile(); }, 120); break; + case "HealthBelow": case "HealthAbove": + BuildIntInput(__builder, f.N, v => { f.N = v; Compile(); }, 70, "N"); break; + case "DamageRange": case "DefenseRange": case "MPRange": + case "CardSPCostRange": case "CardSTCostRange": + case "WithinRange": case "TileWithinRange": + BuildIntInput(__builder, f.Min, v => { f.Min = v; Compile(); }, 60, "Min"); + BuildIntInput(__builder, f.Max, v => { f.Max = v; Compile(); }, 60, "Max"); + break; + case "HasFlag": + BuildSelect(__builder, FilterFlagValues, f.Flag, v => { f.Flag = v; Compile(); }, 120); break; + case "TierIs": + BuildIntInput(__builder, f.Tier, v => { f.Tier = v; Compile(); }, 60, "Tier"); break; + case "CardTypeIs": + BuildSelect(__builder, CardTypeIsValues, f.CardType, v => { f.CardType = v; Compile(); }, 130); break; + case "TileIsOccupied": + BuildSelect(__builder, UnitTypeValues, f.UnitType, v => { f.UnitType = v; Compile(); }, 110); break; + case "Ownership": case "TileIsOnPlayerSide": case "TileIsInArchSpiritChannelRange": + BuildSelect(__builder, OwnershipValues, f.Ownership, v => { f.Ownership = v; Compile(); }, 100); break; + case "UnitProperty": + BuildSelect(__builder, UnitPropertyNames, f.PropertyName, v => { f.PropertyName = v; Compile(); }, 150); + BuildSelect(__builder, ComparatorValues, f.Comparator, v => { f.Comparator = v; Compile(); }, 150); + BuildIntInput(__builder, f.Value, v => { f.Value = v; Compile(); }, 60, "Value"); + break; + case "TileOccupancy": + BuildSelect(__builder, UnitTypeValues, f.UnitType, v => { f.UnitType = v; Compile(); }, 110); + BuildSelect(__builder, OwnershipValues, f.Ownership, v => { f.Ownership = v; Compile(); }, 100); + break; + } + }; + private RenderFragment RenderConditionFields(ConditionDraft c) => __builder => { var t = c.TypeStr; @@ -3970,6 +4337,19 @@ b.CloseElement(); } + private void BuildTextInput(RenderTreeBuilder b, string value, Action onChange, int widthPx, string placeholder) + { + b.OpenElement(0, "input"); + b.AddAttribute(1, "class", "form-control form-control-sm"); + b.AddAttribute(2, "style", $"width:{widthPx}px"); + b.AddAttribute(3, "placeholder", placeholder); + b.AddAttribute(4, "title", placeholder); + b.AddAttribute(5, "value", value); + b.AddAttribute(6, "onchange", EventCallback.Factory.Create( + this, e => onChange(e.Value?.ToString() ?? ""))); + b.CloseElement(); + } + private void BuildIntInput(RenderTreeBuilder b, int value, Action onChange, int widthPx, string placeholder) { b.OpenElement(0, "input"); @@ -4510,6 +4890,14 @@ private sealed class AbilityDraft { + /// + /// The ability's original JSON node as loaded (null for newly added abilities). + /// Compile() starts from a clone of this so properties the UI does not model + /// (SourceZoneGate, TriggerLimitPerGame, OnEnter/OnLeaveAuraActions, …) survive + /// an open → save round-trip instead of being silently stripped. + /// + public JsonObject? Original { get; set; } + public string TypeStr { get; set; } = "Active"; public string Name { get; set; } = ""; public string Description { get; set; } = ""; @@ -4547,6 +4935,9 @@ public string TriggerUnitOwnership { get; set; } = "Any"; public string TriggerAuraOwnership { get; set; } = "Owner"; public int? TriggerLimitPerTurn { get; set; } + public int? TriggerLimitPerGame { get; set; } + /// Comma-separated zone list ("Hand, Battlefield"); "" = battlefield-only default. + public string SourceZoneGate { get; set; } = ""; // Ability-level duration (overrides per-action Duration when set; "" = per-action) public string DurationStr { get; set; } = ""; public int DurationN { get; set; } = 1; @@ -4573,10 +4964,15 @@ public string LogicOp { get; set; } = "And"; public string ChooserRole { get; set; } = "Self"; public List Actions { get; set; } = new(); + /// Nested Groups[] of this sub-group as loaded — preserved verbatim (UI edits one level only). + public JsonArray? OriginalNestedGroups { get; set; } } private sealed class ActionDraft { + /// Original action JSON node (null for new actions). Preserves ChooseOne, filter parameters, etc. + public JsonObject? Original { get; set; } + public string Scope { get; set; } = "Battlefield"; public string TargetType { get; set; } = "Unit"; public string Ownership { get; set; } = "Enemy"; @@ -4586,11 +4982,15 @@ public bool All { get; set; } /// Player may select fewer than Count valid targets. public bool UpTo { get; set; } + /// Target-pool filters (all must match). Maps to Target.Filters in the compiled JSON. + public List Filters { get; set; } = new(); + /// - /// Optional filter type applied to the target pool (single filter, no-param variant). - /// "" = no filter. Maps to Target.Filters[0] in the compiled JSON. + /// Raw ChooseOne JSON ({"Branches":[…],"ChooserRole":"Self"}); "" = none. + /// When set, the engine ignores this action's Effects and the chooser picks a branch. + /// Advanced editor — edited as raw JSON like AddAbility/ApplyOnEvent effects. /// - public string FilterType { get; set; } = ""; + public string ChooseOneJson { get; set; } = ""; /// /// Action-level duration override. "" = no override (each effect uses its own duration or the ability-level duration). /// Written to "Duration": {"Type": ...} in the compiled action JSON. @@ -4603,6 +5003,9 @@ private sealed class EffectDraft { + /// Original effect JSON node (null for new effects). Used when $type still matches TypeKey. + public JsonObject? Original { get; set; } + public string TypeKey { get; set; } = "DealDamage"; public int Amount { get; set; } = 1; public string AmountRef { get; set; } = ""; // "" = use Fixed; non-empty = ValueExpr Ref path @@ -4676,6 +5079,9 @@ private sealed class ConditionDraft { + /// Original condition JSON node (null for new conditions). Used when $type still matches TypeStr. + public JsonObject? Original { get; set; } + public string TypeStr { get; set; } = "IsOwnTurn"; public string Subject { get; set; } = "Self"; public int N { get; set; } = 1; @@ -4701,9 +5107,37 @@ public string CostType { get; set; } = "SP"; } + private sealed class FilterDraft + { + /// Original filter JSON node (null for new filters). Used when $type still matches TypeStr — + /// preserves nested parameters (UnitFilters, TileFilters) the UI does not model. + public JsonObject? Original { get; set; } + + public string TypeStr { get; set; } = "GenusContains"; + public string Tag { get; set; } = ""; + public string Affinity { get; set; } = "Aether"; + public int N { get; set; } = 1; + public int Min { get; set; } = 1; + public int Max { get; set; } = 2; + public string Flag { get; set; } = "CanAttack"; + public int Tier { get; set; } = 1; + public string CardType { get; set; } = "Spirit"; + public string UnitType { get; set; } = "Unit"; + public string Ownership { get; set; } = "Any"; + public string PropertyName { get; set; } = "Damage"; + public string Comparator { get; set; } = "GreaterThanOrEqual"; + public int Value { get; set; } = 1; + } + private sealed class CostDraft { + /// Original cost-entry JSON node (null for new costs). Preserves Filters when Type unchanged. + public JsonObject? Original { get; set; } + public string TypeStr { get; set; } = "SpiritPoints"; public int Amount { get; set; } = 1; + /// Interactive pick mode; "" = server auto-resolves. Only honoured by the engine for + /// DiscardFromHand / SendSpiritFromBattlefieldToDiscard / DealDamageToOwnSpirit. + public string PickModeStr { get; set; } = ""; } } diff --git a/Server/src/SOR.Admin/Components/Pages/Cards/CardEditor.razor b/Server/src/SOR.Admin/Components/Pages/Cards/CardEditor.razor index 66c7ead..d163a8e 100644 --- a/Server/src/SOR.Admin/Components/Pages/Cards/CardEditor.razor +++ b/Server/src/SOR.Admin/Components/Pages/Cards/CardEditor.razor @@ -43,6 +43,18 @@ else {
@_saveError
} + @if (_abilityErrors.Count > 0) + { +
+ Abilities failed validation — not saved: +
    + @foreach (var err in _abilityErrors) + { +
  • @err
  • + } +
+
+ } @if (_saveSuccess) {
Saved successfully.
@@ -782,6 +794,7 @@ else private bool _saving; private string? _saveError; private bool _saveSuccess; + private IReadOnlyList _abilityErrors = []; private List _selectedGenus = new(); private List _availableGenus = new(); private string _newGenusTag = string.Empty; @@ -1036,6 +1049,16 @@ else _saveError = null; _saveSuccess = false; + // Validate abilities with the game engine's own deserializer + structural lint + // so unplayable content never reaches the catalog. + _abilityErrors = SOR.Game.Abilities.AbilityValidator.Validate( + _abilitiesJson, _card.CardType.ToString()); + if (_abilityErrors.Count > 0) + { + _saving = false; + return; + } + try { _card.Genus = _selectedGenus.Count > 0 ? _selectedGenus.ToArray() : null; diff --git a/Server/src/SOR.Game/Abilities/AbilityContext.cs b/Server/src/SOR.Game/Abilities/AbilityContext.cs index 2f00573..a2c7510 100644 --- a/Server/src/SOR.Game/Abilities/AbilityContext.cs +++ b/Server/src/SOR.Game/Abilities/AbilityContext.cs @@ -40,6 +40,13 @@ public sealed class AbilityContext ///
public AbilityRange? ActivationRange { get; set; } + /// + /// True while an Aura ability is applying its effects. Stamped into the tracked + /// duration so ReapplyAurasAtTurnStart only strips aura-applied effects and never + /// unrelated buffs the same unit applied via an Active ability. + /// + public bool IsAuraApplication { get; set; } + // ── Intra-action position tracking (set per-loop-iteration by ExecuteSingleAction) ── /// Index of the currently-executing effect within . diff --git a/Server/src/SOR.Game/Abilities/AbilitySystem.cs b/Server/src/SOR.Game/Abilities/AbilitySystem.cs index 75b2a7d..41e7852 100644 --- a/Server/src/SOR.Game/Abilities/AbilitySystem.cs +++ b/Server/src/SOR.Game/Abilities/AbilitySystem.cs @@ -66,19 +66,33 @@ public static class AbilitySystem // ── Parsing ──────────────────────────────────────────────────────────────── + // Content-keyed parse cache. FireTrigger parses every card's AbilitiesJson on every + // occurrence — the same JSON strings repeat constantly, so caching by content is a + // large win and safe across sessions. Parsed definitions are treated as immutable by + // the engine (ability-list mutations always serialize a NEW string). Bounded to guard + // against unbounded growth from AddAbilityEffect-generated variants. + private static readonly System.Collections.Concurrent.ConcurrentDictionary + _parseCache = new(); + private const int MaxParseCacheEntries = 4096; + public static AbilityDefinition[] ParseAbilities(string? json) { if (string.IsNullOrWhiteSpace(json)) return []; + if (_parseCache.TryGetValue(json, out var cached)) return cached; + AbilityDefinition[] parsed; try { - return JsonSerializer.Deserialize(json, _jsonOpts) ?? []; + parsed = JsonSerializer.Deserialize(json, _jsonOpts) ?? []; } catch (JsonException ex) { // One malformed card must not poison every trigger scan / activation. _log?.LogWarning(ex, "[ABILITY] Unparseable AbilitiesJson ignored: {Json}", json); - return []; + parsed = []; } + if (_parseCache.Count >= MaxParseCacheEntries) _parseCache.Clear(); + _parseCache[json] = parsed; + return parsed; } public static Models.Action[] ParseEffects(string? json) @@ -783,7 +797,9 @@ public static class AbilitySystem if (paused) return state; } - ExecuteActions(actions, ctx, clientTargets: null, requireClientTargets: false, + // Player-driven flow: mandatory explicit picks must prompt (PendingTargetPick), + // never silently auto-take the first N candidates. + ExecuteActions(actions, ctx, clientTargets: null, requireClientTargets: true, activationRange: range, forceDuration: forceDuration); return state; } @@ -986,7 +1002,8 @@ public static class AbilitySystem ? JsonSerializer.Deserialize(pending.RangeJson, _jsonOpts) : null; - ExecuteActions(actions, ctx, clientTargets: null, requireClientTargets: false, + // Player-driven flow: mandatory explicit picks must prompt, not auto-resolve. + ExecuteActions(actions, ctx, clientTargets: null, requireClientTargets: true, activationRange: range, forceDuration: forceDuration); return state; @@ -1027,7 +1044,8 @@ public static class AbilitySystem var ctx = new AbilityContext { State = state, ActorId = pending.ActorId, Source = source }; var allActions = branches[branchIndex].Actions.Concat(continuation).ToArray(); - ExecuteActions(allActions, ctx, clientTargets: null, requireClientTargets: false, + // Player-driven flow: mandatory explicit picks must prompt, not auto-resolve. + ExecuteActions(allActions, ctx, clientTargets: null, requireClientTargets: true, activationRange: range, forceDuration: forceDuration); return state; } @@ -1246,7 +1264,8 @@ public static class AbilitySystem // Correct AND-group order: [preceding] + [chosen/remaining] + [outer continuation]. var allActions = preceding.Concat(chosen).Concat(continuation).ToArray(); - ExecuteActions(allActions, ctx, clientTargets: null, requireClientTargets: false, + // Player-driven flow: mandatory explicit picks must prompt, not auto-resolve. + ExecuteActions(allActions, ctx, clientTargets: null, requireClientTargets: true, activationRange: range, forceDuration: forceDuration); return state; } @@ -1323,8 +1342,8 @@ public static class AbilitySystem { AbilityRange? rrcRange = pending.RangeJson is not null ? JsonSerializer.Deserialize(pending.RangeJson, _jsonOpts) : null; - ExecuteActions(rrcContinuation, rrcCtx, clientTargets: null, activationRange: rrcRange, - forceDuration: rrcActionDuration); + ExecuteActions(rrcContinuation, rrcCtx, clientTargets: null, requireClientTargets: true, + activationRange: rrcRange, forceDuration: rrcActionDuration); } } @@ -1431,6 +1450,15 @@ public static class AbilitySystem ? JsonSerializer.Deserialize(pending.EffectJson, _jsonOpts) as ChannelCardFromZoneEffect : null; + // Card constraint filters. + if (ccze?.Filters is { Length: > 0 } && !FiltersMatch(ccze.Filters, ccCard, ctx)) + break; + + // Channel-range constraints on the picked tile — throw so the client's + // rejected pick re-prompts instead of silently consuming the effect. + if (!IsWithinChannelConstraints(state, pending.ActorId, ccDestPlayer, ccCard, ccze, pickedTile)) + throw new GameException("OUT_OF_CHANNEL_RANGE"); + // Affinity check. if (ccze?.IgnoreAffinity != true && Enum.TryParse(ccCard.Affinity, out var tpAffinity)) { @@ -1485,8 +1513,8 @@ public static class AbilitySystem { AbilityRange? range = pending.RangeJson is not null ? JsonSerializer.Deserialize(pending.RangeJson, _jsonOpts) : null; - ExecuteActions(continuation, ctx, clientTargets: null, activationRange: range, - forceDuration: tpActionDuration); + ExecuteActions(continuation, ctx, clientTargets: null, requireClientTargets: true, + activationRange: range, forceDuration: tpActionDuration); } } return state; @@ -1544,6 +1572,10 @@ public static class AbilitySystem ? JsonSerializer.Deserialize(pending.EffectJson, _jsonOpts) as ChannelCardFromZoneEffect : null; + // Card constraint filters. + if (ppCcze?.Filters is { Length: > 0 } && !FiltersMatch(ppCcze.Filters, ppCard, ppCtx)) + break; + if (ppCcze?.TargetTile == true) { // Chain into a tile pick for the chosen dest player. @@ -1567,36 +1599,14 @@ public static class AbilitySystem return state; } - // Random tile in channel range. - var ppArch = ppDest.ArchSpirit; - Coord? ppCoord; - if (ppCcze?.IgnoreChannelRange != true && ppArch?.Position.HasValue == true) - { - var maxR = ppCard.MaxChannelRange ?? 2; - var minR = ppCard.MinChannelRange ?? 1; - ppCoord = ppBoard.Tiles.Values - .Where(t => t.IsEmpty) - .Where(t => - { - var d = ppBoard.HexSides > 0 - ? HexGrid.Distance(ppArch.Position!.Value, t.Coord, ppBoard.HexSides) - : ppArch.Position!.Value.ManhattanDistance(t.Coord); - return d >= minR && d <= maxR; - }) - .Select(t => t.Coord) - .OrderBy(_ => Random.Shared.Next()) - .Cast() - .FirstOrDefault(); - } - else - { - ppCoord = ppBoard.Tiles.Values - .Where(t => t.IsEmpty) - .Select(t => t.Coord) - .OrderBy(_ => Random.Shared.Next()) - .Cast() - .FirstOrDefault(); - } + // Random empty tile satisfying the channel-range constraints. + Coord? ppCoord = ppBoard.Tiles.Values + .Where(t => t.IsEmpty) + .Where(t => IsWithinChannelConstraints(state, pending.ActorId, ppDest, ppCard, ppCcze, t.Coord)) + .Select(t => t.Coord) + .OrderBy(_ => Random.Shared.Next()) + .Cast() + .FirstOrDefault(); if (ppCoord is null) break; // Affinity check. @@ -1661,8 +1671,8 @@ public static class AbilitySystem { AbilityRange? ppRange = pending.RangeJson is not null ? JsonSerializer.Deserialize(pending.RangeJson, _jsonOpts) : null; - ExecuteActions(ppContinuation, ppCtx, clientTargets: null, activationRange: ppRange, - forceDuration: ppActionDuration); + ExecuteActions(ppContinuation, ppCtx, clientTargets: null, requireClientTargets: true, + activationRange: ppRange, forceDuration: ppActionDuration); } } return state; @@ -1819,20 +1829,126 @@ public static class AbilitySystem if (cond.Subject != "Target" && !EvaluateCondition(cond, ctx, ctx.Source!)) return; - // If Chooser=Opponent/Ally and we have no client-provided targets, pause for the - // non-activating player to pick. (Chooser=Random is server-resolved in ResolveTargets.) var sel = action.Target; - if (sel.Chooser is TargetChooser.Opponent or TargetChooser.Ally - && clientTargets is null - && sel.Type != TargetType.Player - && !sel.Count.All) + + // ── Zone-scope card picks ───────────────────────────────────────────── + // For Hand/Deck/Discard/AnyZone card targets the client cannot enumerate the + // pool itself (hidden zones); it submits player accountIds (or nothing). + // Pause with an explicit candidates list so the chooser picks real cards; + // resumed via game.target_pick with card InstanceIds. Only on player-driven + // paths (requireClientTargets) — automated paths keep auto-resolving. + if (requireClientTargets + && sel.Scope is TargetScope.Hand or TargetScope.Deck or TargetScope.Discard or TargetScope.AnyZone + && sel.Type is not (TargetType.Player or TargetType.Tile) + && !sel.Count.All + && sel.Chooser != TargetChooser.Random + && sel.Ownership is not (TargetOwnership.Self or TargetOwnership.ExactSelf + or TargetOwnership.Target or TargetOwnership.Random)) { - var tpChooser = sel.Chooser == TargetChooser.Opponent - ? ctx.State.GetEnemyIds(ctx.ActorId).FirstOrDefault() ?? ctx.ActorId - : ctx.State.Players.Values + var providedIds = clientTargets? + .Where(t => t.ActionIndex == actionIndex && t.InstanceId is not null) + .Select(t => t.InstanceId!) + .ToList() ?? []; + bool onlyPlayerIds = providedIds.Count == 0 + || providedIds.All(id => ctx.State.Players.ContainsKey(id)); + + if (onlyPlayerIds) + { + var pool = BuildCandidates(sel, ctx.State, ctx.ActorId); + if (providedIds.Count > 0) + { + var allowedOwners = providedIds.ToHashSet(); + pool = pool.Where(c => + FindCardOwner(ctx.State, c.InstanceId)?.AccountId is { } cardOwnerId + && allowedOwners.Contains(cardOwnerId)).ToList(); + } + if (sel.Filters is { Length: > 0 }) + pool = pool.Where(c => FiltersMatch(sel.Filters, c, ctx)).ToList(); + + // Pause only when the chooser has an actual choice to make; otherwise + // fall through and let ResolveTargets auto-take the pool. + if (pool.Count > sel.Count.N || (sel.Count.UpTo && pool.Count > 0)) + { + var zoneChooserId = sel.Chooser switch + { + TargetChooser.Opponent => + ctx.State.GetEnemyIds(ctx.ActorId).FirstOrDefault() ?? ctx.ActorId, + TargetChooser.Ally => ctx.State.Players.Values + .FirstOrDefault(p => p.AccountId != ctx.ActorId + && ctx.State.AreAllies(p.AccountId, ctx.ActorId)) + ?.AccountId ?? ctx.ActorId, + _ => ctx.ActorId, + }; + var zoneCandidates = pool + .Select(c => new { instanceId = c.InstanceId, name = c.Name, cardType = c.CardType }) + .ToArray(); + ctx.State.PendingTargetPick = new PendingTargetPick + { + ActorId = ctx.ActorId, + ChooserActorId = zoneChooserId, + SourceInstanceId = ctx.Source?.InstanceId ?? string.Empty, + ActionJson = JsonSerializer.Serialize(action, _jsonOpts), + CandidatesJson = JsonSerializer.Serialize(zoneCandidates), + ContinuationActionsJson = JsonSerializer.Serialize(continuationActions, _jsonOpts), + RangeJson = activationRange is not null + ? JsonSerializer.Serialize(activationRange, _jsonOpts) : null, + ForceDurationJson = forceDuration is not null + ? JsonSerializer.Serialize(forceDuration, _jsonOpts) : null, + }; + return; + } + + // No real choice: substitute the pool's card ids as the client picks so + // ResolveTargets (which expects card InstanceIds and enforces mandatory + // explicit targets) resolves them directly. + var autoPicks = pool.Take(sel.Count.N) + .Select(c => new AbilityTarget(actionIndex, c.InstanceId)); + clientTargets = (clientTargets ?? []) + .Where(t => t.ActionIndex != actionIndex) + .Concat(autoPicks) + .ToList(); + } + } + + // Pause for a target pick when a human choice is required and missing: + // • Chooser=Opponent/Ally — the non-activating player must pick. + // • Chooser=Self on a player-driven path (requireClientTargets) with no targets + // submitted for this action — happens after OR/XOR Random group resolution + // (indices shifted) or any flow where the client couldn't pre-target. + // Prompting beats throwing INSUFFICIENT_TARGETS at the player. + bool actionServerResolved = + sel.Type == TargetType.Player + || sel.Count.All + || sel.Chooser == TargetChooser.Random + || sel.Ownership is TargetOwnership.Self or TargetOwnership.ExactSelf + or TargetOwnership.Target or TargetOwnership.Random; + bool hasTargetsForAction = clientTargets?.Any(t => t.ActionIndex == actionIndex + && (t.InstanceId is not null || t.Coord is not null)) == true; + bool chooserIsOtherPlayer = sel.Chooser is TargetChooser.Opponent or TargetChooser.Ally; + + // Never pause into an unwinnable pick: for card targets verify at least one valid + // candidate exists (tile pools are filter-dependent and assumed non-empty). + // With an empty pool we fall through and let ResolveTargets fail fast. + bool PickPoolNonEmpty() => + sel.Type == TargetType.Tile + || BuildCandidates(sel, ctx.State, ctx.ActorId) + .Any(c => sel.Filters is not { Length: > 0 } || FiltersMatch(sel.Filters, c, ctx)); + + if (!actionServerResolved + && !hasTargetsForAction + && (chooserIsOtherPlayer || (requireClientTargets && !sel.Count.UpTo)) + && PickPoolNonEmpty()) + { + var tpChooser = sel.Chooser switch + { + TargetChooser.Opponent => + ctx.State.GetEnemyIds(ctx.ActorId).FirstOrDefault() ?? ctx.ActorId, + TargetChooser.Ally => ctx.State.Players.Values .FirstOrDefault(p => p.AccountId != ctx.ActorId && ctx.State.AreAllies(p.AccountId, ctx.ActorId)) - ?.AccountId ?? ctx.ActorId; + ?.AccountId ?? ctx.ActorId, + _ => ctx.ActorId, + }; ctx.State.PendingTargetPick = new PendingTargetPick { @@ -2858,6 +2974,11 @@ public static class AbilitySystem } break; } + // Player target: reveal the top N cards of that player's deck. + case RevealCardsEffect rvc when target is PlayerState revPs: + foreach (var revealed in revPs.Deck.TakeLast(Math.Max(1, rvc.N))) + revealed.IsRevealed = true; + break; case RevealCardsEffect when target is CardInstance ci: ci.IsRevealed = true; break; @@ -3011,10 +3132,11 @@ public static class AbilitySystem } // ── §5.10 Control ───────────────────────────────────────────────── - case TakeControlEffect when target is FieldCard fc4: + case TakeControlEffect tce when target is FieldCard fc4: { var originalOwner = FindCardOwner(ctx.State, fc4.InstanceId); - if (originalOwner is not null) originalOwner.Field.Remove(fc4); + if (originalOwner is null || originalOwner.AccountId == ctx.ActorId) break; + originalOwner.Field.Remove(fc4); ctx.State.Players[ctx.ActorId].Field.Add(fc4); // Keep the board's occupant-owner in sync so ownership filters, // sacrifice checks and tile conditions agree with the new controller. @@ -3023,6 +3145,29 @@ public static class AbilitySystem tcBoard.RemoveUnit(fc4.InstanceId); tcBoard.PlaceUnit(tcPos, fc4.InstanceId, ctx.ActorId); } + // Honour the effect's own Duration when the action carries none + // (mirrors the ObstructMovementType pattern); PermanentInMatch = keep. + var tcDuration = duration is null || duration.Type is DurationType.Instant + ? tce.Duration + : duration; + TrackEffect(new ReturnControlEffect { ToAccountId = originalOwner.AccountId }, + fc4.InstanceId, tcDuration, ctx); + break; + } + case ReturnControlEffect rce when target is FieldCard fcRet: + { + if (string.IsNullOrEmpty(rce.ToAccountId) + || !ctx.State.Players.TryGetValue(rce.ToAccountId, out var backTo)) + break; + var holder = FindCardOwner(ctx.State, fcRet.InstanceId); + if (holder is null || holder.AccountId == rce.ToAccountId) break; + holder.Field.Remove(fcRet); + backTo.Field.Add(fcRet); + if (fcRet.Position is { } rcPos && ctx.State.Board is { } rcBoard) + { + rcBoard.RemoveUnit(fcRet.InstanceId); + rcBoard.PlaceUnit(rcPos, fcRet.InstanceId, rce.ToAccountId); + } break; } case GrantMovementControlEffect gmc when target is FieldCard fc6: @@ -3287,6 +3432,10 @@ public static class AbilitySystem var board = ctx.State.Board; if (board is null) break; + // Card constraint filters (e.g. "channel a Spirit costing 3 or less"). + if (ccze.Filters is { Length: > 0 } && !FiltersMatch(ccze.Filters, ciCcze, ctx)) + break; + // Determine destination player. PlayerState? ccDestPlayer = ccze.UnderControlOf switch { @@ -3348,36 +3497,15 @@ public static class AbilitySystem return; } - // Random tile in channel range (or anywhere if IgnoreChannelRange). - var ccArch = ccDestPlayer.ArchSpirit; - Coord? ccDestCoord; - if (!ccze.IgnoreChannelRange && ccArch?.Position.HasValue == true) - { - var maxR = ciCcze.MaxChannelRange ?? 2; - var minR = ciCcze.MinChannelRange ?? 1; - ccDestCoord = board.Tiles.Values - .Where(t => t.IsEmpty) - .Where(t => - { - var d = board.HexSides > 0 - ? HexGrid.Distance(ccArch.Position!.Value, t.Coord, board.HexSides) - : ccArch.Position!.Value.ManhattanDistance(t.Coord); - return d >= minR && d <= maxR; - }) - .Select(t => t.Coord) - .OrderBy(_ => Random.Shared.Next()) - .Cast() - .FirstOrDefault(); - } - else - { - ccDestCoord = board.Tiles.Values - .Where(t => t.IsEmpty) - .Select(t => t.Coord) - .OrderBy(_ => Random.Shared.Next()) - .Cast() - .FirstOrDefault(); - } + // Random empty tile satisfying the channel-range constraints + // (destination arch range by default; InOwn/InTargetChannelRange extras). + Coord? ccDestCoord = board.Tiles.Values + .Where(t => t.IsEmpty) + .Where(t => IsWithinChannelConstraints(ctx.State, ctx.ActorId, ccDestPlayer, ciCcze, ccze, t.Coord)) + .Select(t => t.Coord) + .OrderBy(_ => Random.Shared.Next()) + .Cast() + .FirstOrDefault(); if (ccDestCoord is null) break; // Affinity check. @@ -3580,9 +3708,38 @@ public static class AbilitySystem case "Hand": sapPs.Hand.Add(card); break; case "Discard": sapPs.Discard.Add(card); break; case "Battlefield": - // Basic: put in discard if no tile available. - sapPs.Discard.Add(card); + { + // Place on a random empty tile with a compatible affinity; + // fall back to hand when no valid tile exists. + var sapBoard = ctx.State.Board; + bool hasAff = Enum.TryParse(card.Affinity, out var sapAff) + && card.Affinity != "Void"; + var sapTile = sapBoard?.Tiles.Values + .Where(t => t.IsEmpty) + .Where(t => !hasAff || AffinitySystem.IsAffinityValid(t, sapAff)) + .OrderBy(_ => Random.Shared.Next()) + .FirstOrDefault(); + if (sapBoard is null || sapTile is null + || card.CardType is not ("Spirit" or "SpiritToken")) + { + sapPs.Hand.Add(card); + break; + } + var sapField = GameEngine.ToFieldCardInternal(card, sapTile.Coord); + sapPs.Field.Add(sapField); + sapBoard.PlaceUnit(sapTile.Coord, sapField.InstanceId, sapPs.AccountId); + FireTrigger(ctx.State, new TriggerOccurrence + { + Kind = TriggerEventKind.UnitEnterBattlefield, + ActorId = sapPs.AccountId, + UnitType = sapField.CardType, + Data = new TriggerEventData { SourceId = sapField.InstanceId }, + }); + EvaluateAurasOnEnter(ctx.State, sapField.InstanceId); + ApplyPassivesForSource(ctx.State, sapField.InstanceId, sapPs.AccountId); + ApplyPassivesToNewTarget(ctx.State, sapField.InstanceId); break; + } default: sapPs.Hand.Add(card); break; } } @@ -4135,6 +4292,45 @@ public static class AbilitySystem return result; } + /// + /// True when satisfies the channel-range constraints of a + /// ChannelCardFromZone resolution: the destination player's ArchSpirit range by default + /// (unless IgnoreChannelRange), plus the optional InOwnChannelRange (actor's arch) and + /// InTargetChannelRange (destination player's arch) extra constraints. + /// + private static bool IsWithinChannelConstraints( + GameState state, string actorId, PlayerState destPlayer, + CardInstance card, ChannelCardFromZoneEffect? ccze, Coord coord) + { + var board = state.Board; + if (board is null) return false; + + bool InRangeOf(FieldCard? arch) + { + if (arch?.Position is not { } archPos) return false; + var d = board.HexSides > 0 + ? HexGrid.Distance(archPos, coord, board.HexSides) + : archPos.ManhattanDistance(coord); + return d >= (card.MinChannelRange ?? 1) && d <= (card.MaxChannelRange ?? 2); + } + + // Default constraint (legacy behaviour): destination player's arch range, + // or unconstrained when that arch is not placed. + if (ccze?.IgnoreChannelRange != true + && ccze?.InOwnChannelRange != true + && ccze?.InTargetChannelRange != true) + { + return destPlayer.ArchSpirit?.Position is null || InRangeOf(destPlayer.ArchSpirit); + } + + if (ccze?.InOwnChannelRange == true + && !InRangeOf(state.Players.GetValueOrDefault(actorId)?.ArchSpirit)) + return false; + if (ccze?.InTargetChannelRange == true && !InRangeOf(destPlayer.ArchSpirit)) + return false; + return true; + } + /// Find the first card in the given zone ("Hand"|"Deck"|"Discard"|"Any") matching predicate. private static CardInstance? FindInZone(PlayerState player, string zone, Func predicate) => zone switch @@ -4312,7 +4508,9 @@ public static class AbilitySystem case IsOpponentTurnCondition: return ctx.State.ActivePlayerAccountId != ctx.ActorId; case IsAllyTurnCondition: - return ctx.State.ActivePlayerAccountId == ctx.ActorId; + // A teammate's turn — not the owner's own, not an enemy's. + return ctx.State.ActivePlayerAccountId != ctx.ActorId + && ctx.State.AreAllies(ctx.State.ActivePlayerAccountId, ctx.ActorId); case IsActivePlayerTurnCondition iaptc: return iaptc.Ownership.ToLowerInvariant() == "owner" ? ctx.State.ActivePlayerAccountId == ctx.ActorId @@ -5088,9 +5286,18 @@ public static class AbilitySystem private sealed class TrackedDuration { public DurationModel Duration { get; set; } = new(); + /// AccountId of the ability actor who applied the effect. public string OwnerAccountId { get; set; } = string.Empty; + /// + /// AccountId of the SOURCE UNIT's owner at apply time. Differs from + /// after TakeControl or opponent-cast buffs. + /// Null on records written before this field existed (falls back to OwnerAccountId). + /// + public string? SourceOwnerAccountId { get; set; } /// True for DOT/HOT tick effects (apply each turn); false for reversal effects. public bool IsTick { get; set; } + /// True when the effect was applied by an Aura (used by ReapplyAurasAtTurnStart). + public bool IsAura { get; set; } } /// @@ -5114,8 +5321,13 @@ public static class AbilitySystem EffectJson = JsonSerializer.Serialize(reversal, _jsonOpts), DurationJson = JsonSerializer.Serialize(new TrackedDuration { - Duration = duration, - OwnerAccountId = ctx.ActorId, + Duration = duration, + OwnerAccountId = ctx.ActorId, + SourceOwnerAccountId = ctx.Source is null + ? null + : FindUnitOwner(ctx.State, ctx.Source.InstanceId) + ?? FindCardOwner(ctx.State, ctx.Source.InstanceId)?.AccountId, + IsAura = ctx.IsAuraApplication, }, _jsonOpts), TurnsRemaining = duration.N ?? 0, Label = LabelFromReversal(reversal), @@ -5198,6 +5410,7 @@ public static class AbilitySystem SetBaseAffinity2Effect _ => "Affinity Overridden", ClearPreventDeathEffect _ => "Death Shield", ClearPreventNextDamageEffect _ => "Damage Block", + ReturnControlEffect _ => "Mind Control", SetFixedSacrificeReturnEffect _ => "Sacrifice Override", SetHealthMinimumEffect e => $"HP Min {e.Minimum}", _ => reversal.GetType().Name.Replace("Effect", ""), @@ -5295,7 +5508,6 @@ public static class AbilitySystem break; case DurationType.UntilStartOfOwnerTurn: - case DurationType.UntilStartOfSourceOwnerTurn: if (!isEndOfTurn && currentPlayerId == td.OwnerAccountId) { if (!td.IsTick) ApplyReversal(state, ae, td.OwnerAccountId); @@ -5303,6 +5515,17 @@ public static class AbilitySystem } break; + case DurationType.UntilStartOfSourceOwnerTurn: + // Anchored to the SOURCE UNIT's owner (may differ from the actor after + // TakeControl / opponent-cast buffs). Old records without the field + // fall back to the actor. + if (!isEndOfTurn && currentPlayerId == (td.SourceOwnerAccountId ?? td.OwnerAccountId)) + { + if (!td.IsTick) ApplyReversal(state, ae, td.OwnerAccountId); + toRemove.Add(ae); + } + break; + case DurationType.ForNTurns: if (isEndOfTurn) { @@ -5682,12 +5905,23 @@ public static class AbilitySystem int dist = auraPos.ManhattanDistance(target.Position!.Value); if (dist < min || dist > max) continue; - // Strip stale tracked effects for this source→target pair without reversal. - // Current stats (CurrentMp, CurrentDefense) were already reset by the - // turn transition, so applying the reversal would incorrectly subtract. + // Strip stale AURA-applied tracked effects for this source→target pair + // without reversal. Current stats (CurrentMp, CurrentDefense) were already + // reset by the turn transition, so applying the reversal would incorrectly + // subtract. Non-aura effects from the same source (e.g. an Active-ability + // buff it cast on this target) must NOT be stripped. state.ActiveEffects.RemoveAll(ae => - ae.SourceInstanceId == auraUnit.InstanceId && - ae.TargetRef == target.InstanceId); + { + if (ae.SourceInstanceId != auraUnit.InstanceId || + ae.TargetRef != target.InstanceId) + return false; + try + { + var aeTd = JsonSerializer.Deserialize(ae.DurationJson, _jsonOpts); + return aeTd?.IsAura == true; + } + catch { return false; } + }); // Re-apply fresh — same path as when the unit entered the aura. ApplyAuraEffects(state, auraOwnerId, auraUnit, def, target.InstanceId); @@ -5758,7 +5992,13 @@ public static class AbilitySystem string targetUnitId) { // Honour aura-level activation conditions (e.g. IsOnTileWithAffinity of the aura source). - var ctx = new AbilityContext { State = state, ActorId = auraOwnerId, Source = auraUnit }; + var ctx = new AbilityContext + { + State = state, + ActorId = auraOwnerId, + Source = auraUnit, + IsAuraApplication = true, + }; if (def.ActivationConditions is { Length: > 0 } && !def.ActivationConditions.All(c => EvaluateCondition(c, ctx, auraUnit))) return; diff --git a/Server/src/SOR.Game/Abilities/AbilityValidator.cs b/Server/src/SOR.Game/Abilities/AbilityValidator.cs new file mode 100644 index 0000000..12f816e --- /dev/null +++ b/Server/src/SOR.Game/Abilities/AbilityValidator.cs @@ -0,0 +1,189 @@ +namespace SOR.Game.Abilities; + +using System.Text.Json; +using SOR.Game.Abilities.Models; + +/// +/// Structural validation for authored AbilitiesJson. Used by the admin CardEditor at +/// save time so unplayable content (unparseable JSON, dead triggers, no-op effects, +/// card-type mismatches) is rejected before it reaches the catalog. +/// +/// Keep the supported-trigger set in sync with +/// and the engine's FireTrigger call sites — see SOR.Abilities-Review-and-solutions.md §C3. +/// +public static class AbilityValidator +{ + /// Trigger types the engine both fires and matches. + private static readonly HashSet _supportedTriggers = + [ + typeof(OnTurnStartTrigger), typeof(OnTurnEndTrigger), + typeof(OnChanneledTrigger), typeof(OnAscendTrigger), + typeof(OnTransitionTrigger), typeof(OnUnitMoveTrigger), + typeof(OnUnitAttackTrigger), typeof(OnUnitAbilityActivatedTrigger), + typeof(OnDamageDealtTrigger), typeof(OnDamagePreventedTrigger), + typeof(OnHealedTrigger), typeof(BeforeDamageAppliedTrigger), + typeof(BeforeUnitDeathTrigger), typeof(OnUnitEnterBattlefieldTrigger), + typeof(OnUnitLeaveBattlefieldTrigger),typeof(OnUnitDeathTrigger), + typeof(OnUnitSentToDiscardTrigger), typeof(OnSpiritSacrificedTrigger), + typeof(OnTokenSummonedTrigger), typeof(OnRuinActivationTrigger), + typeof(OnUnitOccupyRuinTrigger), typeof(OnSPGainedTrigger), + typeof(OnSPSpentTrigger), typeof(OnSTGainedTrigger), + typeof(OnSTSpentTrigger), typeof(OnCardDrawnTrigger), + typeof(OnEnterAuraRangeTrigger), typeof(OnLeaveAuraRangeTrigger), + ]; + + /// Effect types with no ExecuteEffect implementation (silent no-ops). + private static readonly HashSet _unimplementedEffects = + [ + typeof(ChannelCardEffect), + typeof(SetStatModMultiplierEffect), + typeof(ModifySacrificeTokenReturnEffect), + ]; + + /// + /// Validates the given AbilitiesJson for a card of the given type + /// ("Spirit" | "ArchSpirit" | "SpiritToken" | "Repentance" | "Instinct" | "Ruin" | "Terramorpha"). + /// Returns a list of human-readable errors; empty = valid. + /// + public static IReadOnlyList Validate(string? abilitiesJson, string cardType) + { + var errors = new List(); + if (string.IsNullOrWhiteSpace(abilitiesJson)) return errors; + + AbilityDefinition[] defs; + try + { + defs = JsonSerializer.Deserialize( + abilitiesJson, AbilitySystem.CreateJsonOptions()) ?? []; + } + catch (JsonException ex) + { + errors.Add($"AbilitiesJson does not deserialize with the game engine's options: {ex.Message}"); + return errors; + } + + bool isEffectCard = cardType is "Repentance" or "Instinct"; + + for (int i = 0; i < defs.Length; i++) + { + var def = defs[i]; + var name = string.IsNullOrWhiteSpace(def.Name) ? $"ability #{i + 1}" : $"\"{def.Name}\""; + + switch (def.Type) + { + case AbilityType.Triggered: + if (def.TriggerEvent is null) + errors.Add($"{name}: Triggered ability has no TriggerEvent."); + else if (!_supportedTriggers.Contains(def.TriggerEvent.GetType())) + errors.Add($"{name}: trigger \"{def.TriggerEvent.GetType().Name}\" is not implemented by the game engine — it will never fire."); + break; + + case AbilityType.Passive: + if (def.ActionGroup is { } pag && pag.LogicOp != ActionGroupLogicOp.And) + errors.Add($"{name}: Passive abilities cannot use OR/XOR action groups (no interactive picks); only leaf actions would execute."); + break; + + case AbilityType.Aura: + if (def.AuraRange is null) + errors.Add($"{name}: Aura ability has no AuraRange — it will never apply."); + break; + } + + if (isEffectCard) + { + if (def.Type != AbilityType.Active) + errors.Add($"{name}: {cardType} cards resolve on channel — only Active abilities execute ({def.Type} will never run)."); + if (def.Range is not null) + errors.Add($"{name}: {cardType} cards are not battlefield units — an ability Range makes every target resolve as out-of-range. Remove the Range."); + } + + foreach (var action in EnumerateActions(def)) + foreach (var effect in EnumerateEffects(action)) + { + if (_unimplementedEffects.Contains(effect.GetType())) + errors.Add($"{name}: effect \"{effect.GetType().Name}\" has no engine implementation (silent no-op)."); + + if (effect is SummonTokenEffect ste) + ValidateTokenDef(ste.TokenDefJson, name, errors); + } + } + + if (isEffectCard && defs.Count(d => d.Type == AbilityType.Active) != 1) + errors.Add($"{cardType} cards must define exactly one Active ability (found {defs.Count(d => d.Type == AbilityType.Active)})."); + + return errors; + } + + private static void ValidateTokenDef(string tokenDefJson, string abilityName, List errors) + { + CardInstance? proto; + try + { + proto = JsonSerializer.Deserialize( + tokenDefJson, AbilitySystem.CreateJsonOptions()); + } + catch (JsonException ex) + { + errors.Add($"{abilityName}: SummonToken TokenDefJson does not deserialize: {ex.Message}"); + return; + } + if (proto is null) + { + errors.Add($"{abilityName}: SummonToken TokenDefJson is empty."); + return; + } + // Nested token abilities must themselves be valid. + if (!string.IsNullOrWhiteSpace(proto.AbilitiesJson)) + foreach (var nested in Validate(proto.AbilitiesJson, "SpiritToken")) + errors.Add($"{abilityName} (token abilities): {nested}"); + } + + /// All actions in a definition: root group tree, branches, aura enter/leave. + private static IEnumerable EnumerateActions(AbilityDefinition def) + { +#pragma warning disable CS0618 // legacy flat Actions still validated + foreach (var a in def.Actions) yield return a; +#pragma warning restore CS0618 + if (def.ActionGroup is { } ag) + foreach (var a in EnumerateGroup(ag)) yield return a; + if (def.OnEnterAuraActions is { } ea) + foreach (var a in EnumerateGroup(ea)) yield return a; + if (def.OnLeaveAuraActions is { } la) + foreach (var a in EnumerateGroup(la)) yield return a; + } + + private static IEnumerable EnumerateGroup(ActionGroup group) + { + foreach (var a in group.Actions) + { + yield return a; + if (a.ChooseOne is { } co) + foreach (var branch in co.Branches) + foreach (var ba in branch.Actions) + yield return ba; + } + foreach (var child in group.Groups) + foreach (var a in EnumerateGroup(child)) + yield return a; + } + + /// All effects in an action, descending into SearchDeck.ThenGroup and ApplyOnEvent trees. + private static IEnumerable EnumerateEffects(Models.Action action) + { + foreach (var e in action.Effects) + { + yield return e; + switch (e) + { + case SearchDeckEffect { ThenGroup: { } tg }: + foreach (var a in EnumerateGroup(tg)) + foreach (var ne in EnumerateEffects(a)) yield return ne; + break; + case ApplyOnEventEffect { ActionGroup: { } aog }: + foreach (var a in EnumerateGroup(aog)) + foreach (var ne in EnumerateEffects(a)) yield return ne; + break; + } + } + } +} diff --git a/Server/src/SOR.Game/Abilities/Models/Conditions.cs b/Server/src/SOR.Game/Abilities/Models/Conditions.cs index 922c878..5c7bb71 100644 --- a/Server/src/SOR.Game/Abilities/Models/Conditions.cs +++ b/Server/src/SOR.Game/Abilities/Models/Conditions.cs @@ -168,14 +168,12 @@ public sealed class ControlledTileCountWithAffinityCondition : Condition // ── §6.6 Extended unit conditions ───────────────────────────────────────────── /// Subject unit's CardType must match. Values: "Spirit", "ArchSpirit", "SpiritToken". -[PolyType(typeof(UnitTypeIsCondition), "UnitTypeIs")] public sealed class UnitTypeIsCondition : Condition { public string UnitType { get; set; } = "Spirit"; } /// Subject unit is owned by the specified player group. -[PolyType(typeof(OwnershipIsCondition), "OwnershipIs")] public sealed class OwnershipIsCondition : Condition { /// "Self" | "Ally" | "Opponent" | "Owner" @@ -183,7 +181,6 @@ public sealed class OwnershipIsCondition : Condition } /// Subject is the exact card instance that owns this ability (by InstanceId). -[PolyType(typeof(IsThisCardCondition), "IsThisCard")] public sealed class IsThisCardCondition : Condition { } /// @@ -192,7 +189,6 @@ public sealed class IsThisCardCondition : Condition { } /// "MovementPoints", "MaxMovementPoints", "MinAttackRange", "MaxAttackRange", /// "MinChannelRange", "MaxChannelRange", "Tier". /// -[PolyType(typeof(UnitPropertyCompareCondition), "UnitPropertyCompare")] public sealed class UnitPropertyCompareCondition : Condition { public string PropertyName { get; set; } = string.Empty; @@ -205,7 +201,6 @@ public sealed class UnitPropertyCompareCondition : Condition /// PropertyName values: "SP", "ST", "SPAccumulation", "HandSize", "DeckSize", "DiscardSize". /// Subject field ("Self", "Owner", "Ally", "Opponent") identifies which player. /// -[PolyType(typeof(PlayerPropertyCompareCondition), "PlayerPropertyCompare")] public sealed class PlayerPropertyCompareCondition : Condition { public string PropertyName { get; set; } = "SP"; @@ -214,7 +209,6 @@ public sealed class PlayerPropertyCompareCondition : Condition } /// The specified player's hand contains at least N cards of the given type and/or affinity. -[PolyType(typeof(HandContainsCountCondition), "HandContainsCount")] public sealed class HandContainsCountCondition : Condition { public string? CardType { get; set; } // null = any @@ -226,7 +220,6 @@ public sealed class HandContainsCountCondition : Condition /// /// X copies of the source card's definition exist in the given zone(s) for the given ownership. /// -[PolyType(typeof(CardDefinitionCountInZoneCondition), "CardDefinitionCountInZone")] public sealed class CardDefinitionCountInZoneCondition : Condition { /// "Hand" | "Deck" | "Discard" | "Battlefield" @@ -238,7 +231,6 @@ public sealed class CardDefinitionCountInZoneCondition : Condition } /// Subject unit is within [Min, Max] Manhattan distance of a unit matching type + ownership. -[PolyType(typeof(IsInRangeOfUnitCondition), "IsInRangeOfUnit")] public sealed class IsInRangeOfUnitCondition : Condition { public int Min { get; set; } = 1; @@ -249,7 +241,6 @@ public sealed class IsInRangeOfUnitCondition : Condition } /// The tile the subject unit occupies is occupied by a unit matching the given type/ownership/filters. -[PolyType(typeof(TileOccupantCondition), "TileOccupant")] public sealed class TileOccupantCondition : Condition { public string UnitType { get; set; } = "Unit"; @@ -258,7 +249,6 @@ public sealed class TileOccupantCondition : Condition } /// At least N surrounding tiles within [Min, Max] distance match the given affinity/occupancy filters. -[PolyType(typeof(SurroundingTileCondition), "SurroundingTile")] public sealed class SurroundingTileCondition : Condition { public int Min { get; set; } = 1; @@ -269,7 +259,6 @@ public sealed class SurroundingTileCondition : Condition } /// Compares the source player's SP accumulation per turn against a value. -[PolyType(typeof(SPAccumulationCompareCondition), "SPAccumulationCompare")] public sealed class SPAccumulationCompareCondition : Condition { public Comparator Comparator { get; set; } = Comparator.GreaterThanOrEqual; @@ -280,7 +269,6 @@ public sealed class SPAccumulationCompareCondition : Condition /// The aggregate channeling cost (SP or ST) of cards matching the given filters in the player's hand /// meets the comparator threshold. /// -[PolyType(typeof(CostOfCardsInHandCondition), "CostOfCardsInHand")] public sealed class CostOfCardsInHandCondition : Condition { /// "SP" | "ST" diff --git a/Server/src/SOR.Game/Abilities/Models/Effects.cs b/Server/src/SOR.Game/Abilities/Models/Effects.cs index aa5fbc4..5adb98e 100644 --- a/Server/src/SOR.Game/Abilities/Models/Effects.cs +++ b/Server/src/SOR.Game/Abilities/Models/Effects.cs @@ -94,6 +94,7 @@ using SOR.Database.Enums; [PolyType(typeof(TakeControlEffect), "TakeControl")] [PolyType(typeof(GrantMovementControlEffect), "GrantMovementControl")] [PolyType(typeof(SetFixedSacrificeReturnEffect),"SetFixedSacrificeReturn")] +[PolyType(typeof(ReturnControlEffect), "__ReturnControl")] // §5.11 Token [PolyType(typeof(SummonTokenEffect), "SummonToken")] // §5.12 Deferred @@ -290,6 +291,12 @@ public sealed class RepositionUnitEffect : Effect // ── §5.10 Control effects ───────────────────────────────────────────────────── public sealed class TakeControlEffect : Effect { public DurationModel Duration { get; set; } = DurationModel.EndOfTurn; } + +/// +/// Internal reversal for : returns the target unit to +/// the given player when the take-control duration expires. Not authorable. +/// +public sealed class ReturnControlEffect : Effect { public string ToAccountId { get; set; } = string.Empty; } public sealed class GrantMovementControlEffect : Effect { public int N { get; set; } = 1; } /// Overrides the sacrifice formula: controller receives exactly StAmount ST instead. public sealed class SetFixedSacrificeReturnEffect : Effect { public int StAmount { get; set; } } @@ -369,6 +376,11 @@ public sealed class ChannelCardFromZoneEffect : Effect /// Who controls the channeled unit. "Self" | "Ally" | "Opponent" | "Random" | "Target" public string UnderControlOf { get; set; } = "Self"; public bool IgnoreChannelCost { get; set; } + /// + /// Reserved. Ability-driven channels are resolved inside an already-validated action + /// and are never subject to the own-turn constraint, so this flag is accepted but has + /// no effect. Kept for forward compatibility with player-initiated channel variants. + /// public bool IgnoreTurnConstraint { get; set; } public bool IgnoreChannelRange { get; set; } public bool IgnoreAffinity { get; set; } diff --git a/Server/src/SOR.Game/Abilities/Models/Filters.cs b/Server/src/SOR.Game/Abilities/Models/Filters.cs index 579012a..0213de3 100644 --- a/Server/src/SOR.Game/Abilities/Models/Filters.cs +++ b/Server/src/SOR.Game/Abilities/Models/Filters.cs @@ -152,7 +152,6 @@ public sealed class TileIsInArchSpiritChannelRangeFilter : Filter // ── Additional filters ──────────────────────────────────────────────────────── /// Unit must be owned by the specified player group. -[PolyType(typeof(OwnershipFilter), "Ownership")] public sealed class OwnershipFilter : Filter { /// "Self" | "Ally" | "Opponent" | "Owner" | "Any" @@ -160,7 +159,6 @@ public sealed class OwnershipFilter : Filter } /// Generic numeric comparison against a named unit property. -[PolyType(typeof(UnitPropertyFilter), "UnitProperty")] public sealed class UnitPropertyFilter : Filter { /// @@ -177,7 +175,6 @@ public sealed class UnitPropertyFilter : Filter /// Tile must be occupied by a unit of the given type and ownership. /// Use instead of when ownership matters. /// -[PolyType(typeof(TileOccupancyFilter), "TileOccupancy")] public sealed class TileOccupancyFilter : Filter { /// "Spirit" | "ArchSpirit" | "SpiritToken" | "Ruin" | "Unit" (any) diff --git a/Server/src/SOR.Game/Abilities/Models/PendingTargetPick.cs b/Server/src/SOR.Game/Abilities/Models/PendingTargetPick.cs index a8982ef..c18e5c8 100644 --- a/Server/src/SOR.Game/Abilities/Models/PendingTargetPick.cs +++ b/Server/src/SOR.Game/Abilities/Models/PendingTargetPick.cs @@ -31,6 +31,13 @@ public sealed class PendingTargetPick /// public string ActionJson { get; set; } = "{}"; + /// + /// JSON array of candidate cards ({instanceId, name, cardType}) for zone-scope picks + /// (Hand/Deck/Discard/AnyZone), where the client cannot enumerate the pool itself. + /// Null for battlefield picks — the client resolves those from visible board state. + /// + public string? CandidatesJson { get; set; } + /// JSON-serialized Action[] — remaining actions to execute after this one resolves. public string ContinuationActionsJson { get; set; } = "[]"; diff --git a/Server/src/SOR.Game/GameMessages.cs b/Server/src/SOR.Game/GameMessages.cs index a622d75..fd271ad 100644 --- a/Server/src/SOR.Game/GameMessages.cs +++ b/Server/src/SOR.Game/GameMessages.cs @@ -1044,7 +1044,12 @@ public sealed record TargetPickRequestPush( /// JSON-serialized Action — full selector for client highlight logic. string ActionJson, /// JSON-serialized AbilityRange? — null when no range constraint. - string? RangeJson); + string? RangeJson, + /// + /// JSON array of candidate cards ({instanceId, name, cardType}) for zone-scope picks. + /// Null for battlefield picks (client resolves those from visible board state). + /// + string? CandidatesJson = null); /// /// Pushed to the chooser when an effect requires a tile selection. diff --git a/Server/src/SOR.Game/Handlers/GameHandlerBase.cs b/Server/src/SOR.Game/Handlers/GameHandlerBase.cs index 9aee8a2..a854ae2 100644 --- a/Server/src/SOR.Game/Handlers/GameHandlerBase.cs +++ b/Server/src/SOR.Game/Handlers/GameHandlerBase.cs @@ -479,7 +479,8 @@ internal abstract class GameHandlerBase ttp.RequestId, ttp.SourceInstanceId, ttp.ActionJson, - ttp.RangeJson)), ct); + ttp.RangeJson, + ttp.CandidatesJson)), ct); } if (state.PendingTilePick is { } tp) diff --git a/Server/tests/SOR.Game.Tests/AbilitySystemRegressionTests.cs b/Server/tests/SOR.Game.Tests/AbilitySystemRegressionTests.cs new file mode 100644 index 0000000..e8b385e --- /dev/null +++ b/Server/tests/SOR.Game.Tests/AbilitySystemRegressionTests.cs @@ -0,0 +1,579 @@ +namespace SOR.Game.Tests; + +using SOR.Database.Enums; +using SOR.Game; +using SOR.Game.Abilities; +using SOR.Game.Grid; +using Xunit; + +/// +/// Regression tests for the ability-system fixes documented in +/// SOR.Abilities-Review-and-solutions.md. Each test targets a scenario that was +/// broken before the 2026-07-02 remediation (tests 1–5 of the doc's §8 test plan). +/// +public sealed class AbilitySystemRegressionTests +{ + private const string P1 = "11111111-1111-1111-1111-111111111111"; + private const string P2 = "22222222-2222-2222-2222-222222222222"; + private const string P3 = "33333333-3333-3333-3333-333333333333"; + + // ── Fixture helpers ─────────────────────────────────────────────────────── + + private static GameState NewState(params (string accountId, int teamIndex)[] players) + { + var state = new GameState + { + SessionId = Guid.NewGuid(), + Phase = GamePhase.Main, + TurnNumber = 3, + Board = Board.Create(6, 6), + ActivePlayerAccountId = players[0].accountId, + PlayerOneAccountId = players[0].accountId, + }; + foreach (var (id, team) in players) + state.Players[id] = new PlayerState + { + AccountId = id, + TeamIndex = team, + CurrentSp = 10, + CurrentSt = 10, + }; + return state; + } + + private static FieldCard PlaceSpirit( + GameState state, string ownerId, int x, int y, + string? abilitiesJson = null, string cardType = "Spirit", + int hp = 10, int damage = 2) + { + var fc = new FieldCard + { + Name = $"{cardType}@{x},{y}", + CardType = cardType, + MaxHealth = hp, + CurrentHealth = hp, + MaxDefense = 0, + CurrentDefense = 0, + Damage = damage, + AbilitiesJson = abilitiesJson, + Position = new Coord(x, y), + IsLeader = cardType == "ArchSpirit", + }; + var player = state.Players[ownerId]; + if (cardType == "ArchSpirit") player.ArchSpirit = fc; + else player.Field.Add(fc); + state.Board!.PlaceUnit(new Coord(x, y), fc.InstanceId, ownerId); + return fc; + } + + private static CardInstance NewCard(string name = "Card", string cardType = "Spirit") + => new() { Name = name, CardType = cardType }; + + // ── §8 Test 1 — Passive authored as ActionGroup (builder shape) applies ── + + [Fact] + public void Passive_AuthoredWithActionGroup_AppliesAndRevokes() + { + // Builder-shaped JSON: ActionGroup only, empty legacy Actions. + const string abilities = """ + [{ + "Type": "Passive", + "Name": "War Cry", + "ActionGroup": { + "LogicOp": "And", + "Actions": [{ + "Target": { + "Scope": "Battlefield", "Type": "Unit", "Ownership": "ExactSelf", + "Chooser": "Self", "Count": { "N": 1, "UpTo": false, "All": false } + }, + "Effects": [ { "$type": "ModifyDamage", "Amount": { "Fixed": 2 } } ] + }], + "Groups": [] + } + }] + """; + + var state = NewState((P1, 0), (P2, 1)); + var unit = PlaceSpirit(state, P1, 1, 1, abilities, damage: 2); + + AbilitySystem.ApplyPassivesForSource(state, unit.InstanceId, P1); + + Assert.Equal(4, unit.Damage); // +2 applied + Assert.Single(state.ActiveEffects); // reversal tracked + + AbilitySystem.RevokePassivesForSource(state, unit.InstanceId); + + Assert.Equal(2, unit.Damage); // reverted + Assert.Empty(state.ActiveEffects); + } + + // ── §8 Test 2 — ArchSpirit triggered ability fires ──────────────────────── + + [Fact] + public void ArchSpirit_TriggeredAbility_FiresOnTurnStart() + { + const string abilities = """ + [{ + "Type": "Triggered", + "Name": "Dawn Draw", + "TriggerEvent": { "$type": "OnTurnStart", "Player": "Owner" }, + "ActionGroup": { + "LogicOp": "And", + "Actions": [{ + "Target": { "Scope": "Player", "Type": "Player", "Ownership": "Owner", "Count": { "N": 1 } }, + "Effects": [ { "$type": "DrawCards", "N": 1, "Player": "Owner" } ] + }], + "Groups": [] + } + }] + """; + + var state = NewState((P1, 0), (P2, 1)); + PlaceSpirit(state, P1, 0, 0, abilities, cardType: "ArchSpirit", hp: 20); + state.Players[P1].Deck.Add(NewCard("Top")); + + AbilitySystem.FireTrigger(state, new TriggerOccurrence + { + Kind = TriggerEventKind.TurnStart, + ActorId = P1, + }); + + Assert.Single(state.Players[P1].Hand); + Assert.Empty(state.Players[P1].Deck); + } + + // ── §8 Test 4 — Triggered ability with pick action at index 1 ──────────── + + [Fact] + public void TriggeredAbility_PickActionAtIndexOne_ResolvesWithOriginalIndex() + { + const string abilities = """ + [{ + "Type": "Triggered", + "Name": "Snipe", + "TriggerEvent": { "$type": "OnTurnStart", "Player": "Owner" }, + "ActionGroup": { + "LogicOp": "And", + "Actions": [ + { + "Target": { "Scope": "Battlefield", "Type": "Unit", "Ownership": "ExactSelf", "Count": { "N": 1 } }, + "Effects": [ { "$type": "ModifyDamage", "Amount": { "Fixed": 1 } } ] + }, + { + "Target": { "Scope": "Battlefield", "Type": "Unit", "Ownership": "Enemy", "Count": { "N": 1 } }, + "Effects": [ { "$type": "DealDamage", "Amount": { "Fixed": 3 }, "BypassDefense": true } ] + } + ], + "Groups": [] + } + }] + """; + + var state = NewState((P1, 0), (P2, 1)); + var source = PlaceSpirit(state, P1, 1, 1, abilities, damage: 2); + var enemy = PlaceSpirit(state, P2, 4, 4, hp: 10); + + AbilitySystem.FireTrigger(state, new TriggerOccurrence + { + Kind = TriggerEventKind.TurnStart, + ActorId = P1, + }); + + // The Enemy-target action (index 1) needs a human pick — engine must pause. + var pending = state.PendingTriggeredTarget; + Assert.NotNull(pending); + + // Client submits the pick with the ORIGINAL action index (1). Before the fix + // the prompt only carried the pick action and the resume threw INSUFFICIENT_TARGETS. + AbilitySystem.ResumeTriggeredAbility(state, P1, pending!.RequestId, + [new AbilityTarget(1, enemy.InstanceId)]); + + Assert.Equal(3, source.Damage); // action 0 auto-resolved (+1) + Assert.Equal(7, enemy.CurrentHealth); // action 1 hit the picked enemy (-3) + Assert.Null(state.PendingTriggeredTarget); + } + + // ── PreventDeath options (DamageIgnored) ───────────────────────────────── + + [Fact] + public void PreventDeath_DamageIgnored_CancelsLethalHitAndConsumesMarker() + { + const string abilities = """ + [{ + "Type": "Active", + "Name": "Smite", + "ActionGroup": { + "LogicOp": "And", + "Actions": [{ + "Target": { "Scope": "Battlefield", "Type": "Unit", "Ownership": "Enemy", "Count": { "N": 1 } }, + "Effects": [ { "$type": "DealDamage", "Amount": { "Fixed": 99 }, "BypassDefense": true } ] + }], + "Groups": [] + } + }] + """; + + var state = NewState((P1, 0), (P2, 1)); + var target = PlaceSpirit(state, P2, 4, 4, hp: 10); + var card = NewCard("Repentance of Smiting", "Repentance"); + card.AbilitiesJson = abilities; + state.Players[P1].Discard.Add(card); // channel flow discards before firing + + state.PreventDeathMarkers[target.InstanceId] = new PreventDeathMarker { DamageIgnored = true }; + + AbilitySystem.FireCardEffects(state, P1, card, + [new AbilityTarget(0, target.InstanceId)]); + + Assert.Equal(10, target.CurrentHealth); // hit fully ignored + Assert.False(state.PreventDeathMarkers.ContainsKey(target.InstanceId)); // marker consumed + Assert.Contains(state.Players[P2].Field, f => f.InstanceId == target.InstanceId); + } + + [Fact] + public void PreventDeath_SetHpOption_SurvivesAtConfiguredHp() + { + const string abilities = """ + [{ + "Type": "Active", + "Name": "Smite", + "ActionGroup": { + "LogicOp": "And", + "Actions": [{ + "Target": { "Scope": "Battlefield", "Type": "Unit", "Ownership": "Enemy", "Count": { "N": 1 } }, + "Effects": [ { "$type": "DealDamage", "Amount": { "Fixed": 99 }, "BypassDefense": true } ] + }], + "Groups": [] + } + }] + """; + + var state = NewState((P1, 0), (P2, 1)); + var target = PlaceSpirit(state, P2, 4, 4, hp: 10); + var card = NewCard("Repentance of Smiting", "Repentance"); + card.AbilitiesJson = abilities; + state.Players[P1].Discard.Add(card); + + state.PreventDeathMarkers[target.InstanceId] = + new PreventDeathMarker { DamageTakenSetToHp = 3 }; + + AbilitySystem.FireCardEffects(state, P1, card, + [new AbilityTarget(0, target.InstanceId)]); + + Assert.Equal(3, target.CurrentHealth); // saved at the configured HP + Assert.Contains(state.Players[P2].Field, f => f.InstanceId == target.InstanceId); + } + + // ── Team-aware Enemy targeting ──────────────────────────────────────────── + + [Fact] + public void EnemyTargeting_ExcludesTeammates() + { + const string abilities = """ + [{ + "Type": "Active", + "Name": "Nova", + "ActionGroup": { + "LogicOp": "And", + "Actions": [{ + "Target": { "Scope": "Battlefield", "Type": "Unit", "Ownership": "Enemy", + "Count": { "N": 1, "All": true } }, + "Effects": [ { "$type": "DealDamage", "Amount": { "Fixed": 1 }, "BypassDefense": true } ] + }], + "Groups": [] + } + }] + """; + + // P1 + P2 are teammates (team 0); P3 is the enemy (team 1). + var state = NewState((P1, 0), (P2, 0), (P3, 1)); + var teammate = PlaceSpirit(state, P2, 2, 2, hp: 10); + var enemy = PlaceSpirit(state, P3, 4, 4, hp: 10); + var card = NewCard("Nova Repentance", "Repentance"); + card.AbilitiesJson = abilities; + state.Players[P1].Discard.Add(card); + + AbilitySystem.FireCardEffects(state, P1, card, clientTargets: null); + + Assert.Equal(10, teammate.CurrentHealth); // ally untouched + Assert.Equal(9, enemy.CurrentHealth); // enemy hit + } + + // ── DOT ticks once per round, not per player-turn ───────────────────────── + + [Fact] + public void DotTick_OnlyFiresOnApplyingPlayersTurnEnd() + { + var state = NewState((P1, 0), (P2, 1)); + var target = PlaceSpirit(state, P2, 4, 4, hp: 10); + + state.ActiveEffects.Add(new ActiveEffect + { + SourceInstanceId = "src", + TargetRef = target.InstanceId, + EffectJson = """{ "$type": "DealDamage", "Amount": { "Fixed": 2 }, "BypassDefense": true }""", + DurationJson = $$"""{ "Duration": { "Type": "ForNTurns", "N": 3 }, "OwnerAccountId": "{{P1}}", "IsTick": true }""", + TurnsRemaining = 3, + }); + + AbilitySystem.TickActiveEffects(state, P2); // not the applier's turn — no tick + Assert.Equal(10, target.CurrentHealth); + + AbilitySystem.TickActiveEffects(state, P1); // applier's turn — tick once + Assert.Equal(8, target.CurrentHealth); + } + + // ── Parse hardening ─────────────────────────────────────────────────────── + + [Fact] + public void ParseAbilities_MalformedJson_ReturnsEmptyInsteadOfThrowing() + { + // "Base" is not a valid StatTarget enum value — previously poisoned the card. + const string malformed = """ + [{ + "Type": "Passive", + "ActionGroup": { "LogicOp": "And", "Actions": [{ + "Target": { "Scope": "Battlefield", "Type": "Unit", "Ownership": "ExactSelf", "Count": { "N": 1 } }, + "Effects": [ { "$type": "ModifyHealth", "Amount": { "Fixed": 1 }, "StatTarget": "Base" } ] + }], "Groups": [] } + }] + """; + + var defs = AbilitySystem.ParseAbilities(malformed); + Assert.Empty(defs); + + // And a card carrying malformed JSON must not break trigger scans. + var state = NewState((P1, 0), (P2, 1)); + PlaceSpirit(state, P1, 1, 1, malformed); + var ex = Record.Exception(() => AbilitySystem.FireTrigger(state, new TriggerOccurrence + { + Kind = TriggerEventKind.TurnStart, + ActorId = P1, + })); + Assert.Null(ex); + } + + // ── Trigger limits live on GameState and survive round-trips ───────────── + + [Fact] + public void TriggerLimitPerTurn_EnforcedViaGameState() + { + const string abilities = """ + [{ + "Type": "Triggered", + "Name": "Once Only", + "TriggerLimitPerTurn": 1, + "TriggerEvent": { "$type": "OnCardDrawn", "Player": "Owner" }, + "ActionGroup": { + "LogicOp": "And", + "Actions": [{ + "Target": { "Scope": "Player", "Type": "Player", "Ownership": "Owner", "Count": { "N": 1 } }, + "Effects": [ { "$type": "ModifySP", "Amount": { "Fixed": 1 } } ] + }], + "Groups": [] + } + }] + """; + + var state = NewState((P1, 0), (P2, 1)); + PlaceSpirit(state, P1, 1, 1, abilities); + + var occ = new TriggerOccurrence { Kind = TriggerEventKind.CardDrawn, ActorId = P1 }; + AbilitySystem.FireTrigger(state, occ); + AbilitySystem.FireTrigger(state, occ); + + Assert.Equal(11, state.Players[P1].CurrentSp); // fired exactly once + Assert.Single(state.TriggerUsesThisTurn); // counter lives on the state + } + + // ── TakeControl: duration-tracked, board-synced, reversed on expiry ─────── + + [Fact] + public void TakeControl_ReturnsUnitToOriginalOwnerWhenDurationExpires() + { + const string abilities = """ + [{ + "Type": "Active", + "Name": "Dominate", + "ActionGroup": { + "LogicOp": "And", + "Actions": [{ + "Target": { "Scope": "Battlefield", "Type": "Unit", "Ownership": "Enemy", "Count": { "N": 1 } }, + "Effects": [ { "$type": "TakeControl", "Duration": { "Type": "UntilEndOfTurn" } } ] + }], + "Groups": [] + } + }] + """; + + var state = NewState((P1, 0), (P2, 1)); + var victim = PlaceSpirit(state, P2, 4, 4, hp: 10); + var card = NewCard("Dominate", "Instinct"); + card.AbilitiesJson = abilities; + state.Players[P1].Discard.Add(card); + + AbilitySystem.FireCardEffects(state, P1, card, + [new AbilityTarget(0, victim.InstanceId)]); + + Assert.Contains(state.Players[P1].Field, f => f.InstanceId == victim.InstanceId); + Assert.DoesNotContain(state.Players[P2].Field, f => f.InstanceId == victim.InstanceId); + Assert.Equal(P1, state.Board!.GetTile(new Coord(4, 4))!.OccupantOwner); + Assert.Single(state.ActiveEffects); // return-control reversal tracked + + // End of turn: control returns to the original owner, board included. + AbilitySystem.ExpireActiveEffects(state, P1, isEndOfTurn: true); + + Assert.Contains(state.Players[P2].Field, f => f.InstanceId == victim.InstanceId); + Assert.DoesNotContain(state.Players[P1].Field, f => f.InstanceId == victim.InstanceId); + Assert.Equal(P2, state.Board!.GetTile(new Coord(4, 4))!.OccupantOwner); + Assert.Empty(state.ActiveEffects); + } + + // ── UntilStartOfSourceOwnerTurn anchors to the source unit's owner ──────── + + [Fact] + public void UntilStartOfSourceOwnerTurn_ExpiresOnSourceOwnersTurnNotActors() + { + var state = NewState((P1, 0), (P2, 1)); + var unit = PlaceSpirit(state, P1, 1, 1, damage: 4); // buffed to 4; reversal -2 + + state.ActiveEffects.Add(new ActiveEffect + { + SourceInstanceId = "src", + TargetRef = unit.InstanceId, + EffectJson = """{ "$type": "ModifyDamage", "Amount": { "Fixed": -2 } }""", + DurationJson = $$""" + { "Duration": { "Type": "UntilStartOfSourceOwnerTurn" }, + "OwnerAccountId": "{{P1}}", "SourceOwnerAccountId": "{{P2}}" } + """, + }); + + // Actor's (P1) turn start: must NOT expire — the anchor is the source owner (P2). + AbilitySystem.ExpireActiveEffects(state, P1, isEndOfTurn: false); + Assert.Equal(4, unit.Damage); + Assert.Single(state.ActiveEffects); + + // Source owner's (P2) turn start: expires and reverts. + AbilitySystem.ExpireActiveEffects(state, P2, isEndOfTurn: false); + Assert.Equal(2, unit.Damage); + Assert.Empty(state.ActiveEffects); + } + + // ── Zone-scope card picks pause with a server-enumerated candidates list ── + + [Fact] + public void ZoneScopeCardPick_PausesWithCandidates_ThenResumesWithCardIds() + { + const string abilities = """ + [{ + "Type": "Active", + "Name": "Pilfer", + "ActionGroup": { + "LogicOp": "And", + "Actions": [{ + "Target": { "Scope": "Hand", "Type": "Card", "Ownership": "Enemy", "Count": { "N": 1 } }, + "Effects": [ { "$type": "SendToDiscard" } ] + }], + "Groups": [] + } + }] + """; + + var state = NewState((P1, 0), (P2, 1)); + var source = PlaceSpirit(state, P1, 1, 1, abilities); + var cardA = NewCard("A"); + var cardB = NewCard("B"); + state.Players[P2].Hand.AddRange([cardA, cardB]); + + // The client can only submit the target PLAYER's accountId for hidden zones. + AbilitySystem.ActivateAbility(state, P1, source.InstanceId, 0, + [new AbilityTarget(0, P2)]); + + var pending = state.PendingTargetPick; + Assert.NotNull(pending); + Assert.NotNull(pending!.CandidatesJson); + Assert.Contains(cardA.InstanceId, pending.CandidatesJson); + Assert.Contains(cardB.InstanceId, pending.CandidatesJson); + + // The chooser picks a real card; the paused action is replayed at index 0. + AbilitySystem.ResumeTargetPick(state, P1, pending.RequestId, + [new AbilityTarget(0, cardA.InstanceId)]); + + Assert.Contains(cardA, state.Players[P2].Discard); + Assert.DoesNotContain(cardA, state.Players[P2].Hand); + Assert.Contains(cardB, state.Players[P2].Hand); + Assert.Null(state.PendingTargetPick); + } + + // ── Missing mandatory targets prompt instead of throwing ───────────────── + + [Fact] + public void MissingMandatoryTargets_PromptInsteadOfInsufficientTargets() + { + const string abilities = """ + [{ + "Type": "Active", + "Name": "Zap", + "ActionGroup": { + "LogicOp": "And", + "Actions": [{ + "Target": { "Scope": "Battlefield", "Type": "Unit", "Ownership": "Enemy", "Count": { "N": 1 } }, + "Effects": [ { "$type": "DealDamage", "Amount": { "Fixed": 2 }, "BypassDefense": true } ] + }], + "Groups": [] + } + }] + """; + + var state = NewState((P1, 0), (P2, 1)); + var source = PlaceSpirit(state, P1, 1, 1, abilities); + var enemy = PlaceSpirit(state, P2, 4, 4, hp: 10); + + // No targets submitted (e.g. after an OR-group Random pick shifted indices). + AbilitySystem.ActivateAbility(state, P1, source.InstanceId, 0, clientTargets: null); + + var pending = state.PendingTargetPick; + Assert.NotNull(pending); // prompt, not INSUFFICIENT_TARGETS + Assert.Null(pending!.CandidatesJson); // battlefield pick — client resolves visually + + AbilitySystem.ResumeTargetPick(state, P1, pending.RequestId, + [new AbilityTarget(0, enemy.InstanceId)]); + + Assert.Equal(8, enemy.CurrentHealth); + Assert.Null(state.PendingTargetPick); + } + + // ── PreventNextDamage shield lives on GameState ─────────────────────────── + + [Fact] + public void PreventNextDamage_ShieldAbsorbsViaGameState() + { + const string abilities = """ + [{ + "Type": "Active", + "Name": "Bolt", + "ActionGroup": { + "LogicOp": "And", + "Actions": [{ + "Target": { "Scope": "Battlefield", "Type": "Unit", "Ownership": "Enemy", "Count": { "N": 1 } }, + "Effects": [ { "$type": "DealDamage", "Amount": { "Fixed": 5 }, "BypassDefense": true } ] + }], + "Groups": [] + } + }] + """; + + var state = NewState((P1, 0), (P2, 1)); + var target = PlaceSpirit(state, P2, 4, 4, hp: 10); + var card = NewCard("Bolt", "Instinct"); + card.AbilitiesJson = abilities; + state.Players[P1].Discard.Add(card); + + state.PreventNextDamageByUnit[target.InstanceId] = 3; // absorb up to 3 + + AbilitySystem.FireCardEffects(state, P1, card, + [new AbilityTarget(0, target.InstanceId)]); + + Assert.Equal(8, target.CurrentHealth); // 5 - 3 absorbed = 2 through + Assert.False(state.PreventNextDamageByUnit.ContainsKey(target.InstanceId)); + } +} diff --git a/Server/tests/SOR.Game.Tests/AbilityValidatorTests.cs b/Server/tests/SOR.Game.Tests/AbilityValidatorTests.cs new file mode 100644 index 0000000..94099ab --- /dev/null +++ b/Server/tests/SOR.Game.Tests/AbilityValidatorTests.cs @@ -0,0 +1,134 @@ +namespace SOR.Game.Tests; + +using SOR.Game.Abilities; +using Xunit; + +/// +/// Tests for the save-time ability validation used by the admin CardEditor. +/// +public sealed class AbilityValidatorTests +{ + private const string ValidActive = """ + [{ + "Type": "Active", + "Name": "Bolt", + "ActionGroup": { + "LogicOp": "And", + "Actions": [{ + "Target": { "Scope": "Battlefield", "Type": "Unit", "Ownership": "Enemy", "Count": { "N": 1 } }, + "Effects": [ { "$type": "DealDamage", "Amount": { "Fixed": 3 } } ] + }], + "Groups": [] + } + }] + """; + + [Fact] + public void ValidAbility_PassesForUnitAndEffectCards() + { + Assert.Empty(AbilityValidator.Validate(ValidActive, "Spirit")); + Assert.Empty(AbilityValidator.Validate(ValidActive, "Repentance")); + Assert.Empty(AbilityValidator.Validate(null, "Spirit")); + Assert.Empty(AbilityValidator.Validate("", "Spirit")); + } + + [Fact] + public void UnparseableJson_IsRejected() + { + const string badEnum = """ + [{ "Type": "Passive", "ActionGroup": { "LogicOp": "And", "Actions": [{ + "Target": { "Scope": "Battlefield", "Type": "Unit", "Ownership": "ExactSelf", "Count": { "N": 1 } }, + "Effects": [ { "$type": "ModifyHealth", "Amount": { "Fixed": 1 }, "StatTarget": "Base" } ] + }], "Groups": [] } }] + """; + var errors = AbilityValidator.Validate(badEnum, "Spirit"); + Assert.Single(errors); + Assert.Contains("deserialize", errors[0]); + } + + [Fact] + public void UnimplementedTrigger_IsRejected() + { + const string json = """ + [{ + "Type": "Triggered", + "Name": "Dead Trigger", + "TriggerEvent": { "$type": "OnStatModified", "Ownership": "Any" }, + "ActionGroup": { "LogicOp": "And", "Actions": [], "Groups": [] } + }] + """; + var errors = AbilityValidator.Validate(json, "Spirit"); + Assert.Contains(errors, e => e.Contains("never fire")); + } + + [Fact] + public void TriggeredWithoutEvent_IsRejected() + { + const string json = """ + [{ "Type": "Triggered", "Name": "Empty", "ActionGroup": { "LogicOp": "And", "Actions": [], "Groups": [] } }] + """; + var errors = AbilityValidator.Validate(json, "Spirit"); + Assert.Contains(errors, e => e.Contains("no TriggerEvent")); + } + + [Fact] + public void UnimplementedEffect_IsRejected() + { + const string json = """ + [{ + "Type": "Active", + "Name": "NoOp", + "ActionGroup": { "LogicOp": "And", "Actions": [{ + "Target": { "Scope": "Battlefield", "Type": "Unit", "Ownership": "Enemy", "Count": { "N": 1 } }, + "Effects": [ { "$type": "ChannelCard", "PayCost": true } ] + }], "Groups": [] } + }] + """; + var errors = AbilityValidator.Validate(json, "Spirit"); + Assert.Contains(errors, e => e.Contains("no engine implementation")); + } + + [Fact] + public void EffectCard_RangeAndNonActive_AreRejected() + { + const string json = """ + [{ + "Type": "Active", + "Name": "Ranged Smite", + "Range": { "Min": 1, "Max": 2 }, + "ActionGroup": { "LogicOp": "And", "Actions": [{ + "Target": { "Scope": "Battlefield", "Type": "Unit", "Ownership": "Enemy", "Count": { "N": 1 } }, + "Effects": [ { "$type": "DealDamage", "Amount": { "Fixed": 1 } } ] + }], "Groups": [] } + }, + { + "Type": "Passive", + "Name": "Never Runs", + "ActionGroup": { "LogicOp": "And", "Actions": [], "Groups": [] } + }] + """; + var errors = AbilityValidator.Validate(json, "Repentance"); + Assert.Contains(errors, e => e.Contains("Remove the Range")); + Assert.Contains(errors, e => e.Contains("only Active abilities execute")); + + // The same definitions are fine on a battlefield unit. + Assert.Empty(AbilityValidator.Validate(json, "Spirit")); + } + + [Fact] + public void PassiveWithOrGroup_IsRejected() + { + const string json = """ + [{ + "Type": "Passive", + "Name": "Choose Buff", + "ActionGroup": { "LogicOp": "Or", "ChooserRole": "Self", "Actions": [{ + "Target": { "Scope": "Battlefield", "Type": "Unit", "Ownership": "ExactSelf", "Count": { "N": 1 } }, + "Effects": [ { "$type": "ModifyDamage", "Amount": { "Fixed": 1 } } ] + }], "Groups": [] } + }] + """; + var errors = AbilityValidator.Validate(json, "Spirit"); + Assert.Contains(errors, e => e.Contains("OR/XOR")); + } +} diff --git a/Server/tests/SOR.Game.Tests/SOR.Game.Tests.csproj b/Server/tests/SOR.Game.Tests/SOR.Game.Tests.csproj new file mode 100644 index 0000000..eb1d2c9 --- /dev/null +++ b/Server/tests/SOR.Game.Tests/SOR.Game.Tests.csproj @@ -0,0 +1,21 @@ + + + + false + + + + + + + + + + + + + + + + +