Files
sor/Server/tests/SOR.Game.Tests/AbilitySystemRegressionTests.cs
dingoandClaude Fable 5 4961696fee Ability system: zone-scope card picks, target-pick prompts, builder filter editor, tests
Server engine (SOR.Game):
- Zone-scope card targets (Hand/Deck/Discard/AnyZone) pause with a server-
  enumerated candidates list (PendingTargetPick.CandidatesJson) instead of
  failing when the client submits player accountIds for hidden zones
- Missing mandatory target picks now prompt (PendingTargetPick) rather than
  throwing INSUFFICIENT_TARGETS; all post-pick resume flows run with
  requireClientTargets so actions never silently auto-hit the first candidate
- ChannelCardFromZone: Filters + InOwn/InTargetChannelRange enforced via shared
  IsWithinChannelConstraints (incl. player-picked tile validation)
- TakeControl duration reversal via internal __ReturnControl effect; board
  occupant-owner kept in sync both ways
- TrackedDuration gains SourceOwnerAccountId (UntilStartOfSourceOwnerTurn now
  anchors correctly) and IsAura (aura reapply no longer strips unrelated buffs)
- RevealCards honours N for player targets; IsAllyTurn means teammate's turn;
  content-keyed ParseAbilities cache; AbilityValidator for save-time linting;
  duplicate PolyType attributes removed (converter reads base registry only)

Admin builder (AbilityBuilder/CardEditor):
- Full multi-filter editor (28 filter types with parameter fields) replacing
  the single param-less dropdown; raw-JSON ChooseOne editor per action
- Cost PickMode, TriggerLimitPerGame, SourceZoneGate inputs
- Save-time ability validation with error list (blocks invalid saves)

Client (Godot):
- Card-list picker for zone-scope target picks; OR/XOR-root abilities skip
  speculative upfront targeting; ally units included in team-aware highlight
  pools (Game.get_ally_units); state re-sync on rejected pick responses

Tests: new SOR.Game.Tests project (21 passing) covering the regression suite
from SOR.Abilities-Review-and-solutions.md §8 plus validator rules.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-04 06:23:17 -04:00

580 lines
22 KiB
C#
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
namespace SOR.Game.Tests;
using SOR.Database.Enums;
using SOR.Game;
using SOR.Game.Abilities;
using SOR.Game.Grid;
using Xunit;
/// <summary>
/// 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).
/// </summary>
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));
}
}