feat(phase7): complete ability revamp gap items 1-11

- Fix [PolyType] attribute placement bug in Effects.cs (silent poly-deser failure)
- Add SpiritToken guard to BazaarBuyPrebuiltDeck and CollectionSelectStarterDeck handlers
- Wire CostGroup payment into ActivateAbility with PendingCostGroupPick pause support
- Add PendingActionGroupPick, PendingCostGroupPick, PendingBranchPick models + GameState props
- Add Phase 5 engine switch cases: ModifyChannelRange, RelocateRuin, ActivateRuinAbility,
  DisableRuinForDuration, CloneSpiritAsToken, DestroyToken, SkipTurn, ModifyCardsDrawnThisTurn,
  StackDeck, SearchAndPlace, ChangeAttackType, ObstructMovement, AscendFromZone stubs
- Add ActionGroup recursion (ResolveActionGroup AND-flatten / OR-XOR interactive pick)
- Add ResumeActionGroupPick, ResumeCostGroupPick, ResumeBranchPick methods
- Add ChooseOne ChooserRole branching + TargetSelector.Chooser (Random early-return)
- Change SearchDeckEffect.ThenAction → ThenGroup: ActionGroup?
- Change ApplyOnEventEffect.Effects → Actions: Action[]
- Add SOR.Tools console project with cutover-abilities command (EffectsJsonCutover)
- AbilityBuilder: add ActionGroupDraft, SubGroups, Compile Groups[], ParseJson Groups[],
  CompileActionNode/ParseActionNode helpers, nested sub-group UI section
- Add Tile.RuinDisabledUntilTurn, PlayerState.SkipTurnCount/CardsDrawnThisTurnBonus,
  CardInstance.AttackType nullable override
- Add SOR.Tools to solution

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

Co-Authored-By: Claude <noreply@anthropic.com>
Co-Authored-By: Happy <yesreply@happy.engineering>
This commit is contained in:
dingo
2026-04-20 19:47:38 -04:00
co-authored by Claude Happy
parent 2d9e9e7347
commit 1d5ae4aa20
16 changed files with 1407 additions and 140 deletions
+1
View File
@@ -1,6 +1,7 @@
<Solution>
<Folder Name="/src/">
<Project Path="src/SOR.Admin/SOR.Admin.csproj" />
<Project Path="src/SOR.Tools/SOR.Tools.csproj" />
<Project Path="src/SOR.Auth/SOR.Auth.csproj" />
<Project Path="src/SOR.Bazaar/SOR.Bazaar.csproj" />
<Project Path="src/SOR.Cdn/SOR.Cdn.csproj" />
@@ -736,6 +736,65 @@
<i class="bi bi-plus-lg me-1"></i>Add Action
</button>
<!-- Nested Sub-Groups -->
@if (ab.SubGroups.Count > 0 || ab.ActionGroupLogicOp != "And")
{
<div class="mt-3">
<div class="d-flex align-items-center gap-2 mb-1">
<span class="small text-muted fw-semibold">Nested Sub-Groups</span>
<small class="text-muted">(AND executes all; OR/XOR chooser picks one sub-group)</small>
</div>
@for (int sgi = 0; sgi < ab.SubGroups.Count; sgi++)
{
var sgIdx = sgi;
var sg = ab.SubGroups[sgIdx];
<div class="card border-secondary mb-2">
<div class="card-header d-flex justify-content-between align-items-center py-1 border-bottom border-secondary">
<div class="d-flex align-items-center gap-2">
<span class="small fw-medium">Sub-Group @(sgIdx + 1)</span>
<select class="form-select form-select-sm" style="width:80px"
@bind="sg.LogicOp" @bind:after="Compile">
@foreach (var op in LogicOpValues) { <option value="@op">@op</option> }
</select>
@if (sg.LogicOp != "And")
{
<select class="form-select form-select-sm" style="width:100px"
@bind="sg.ChooserRole" @bind:after="Compile">
@foreach (var r in ChooserRoleValues) { <option value="@r">@r</option> }
</select>
}
</div>
<button class="btn btn-sm btn-outline-danger py-0"
@onclick="() => { ab.SubGroups.RemoveAt(sgIdx); Compile(); }">
<i class="bi bi-x"></i>
</button>
</div>
<div class="card-body py-2">
@for (int sgai = 0; sgai < sg.Actions.Count; sgai++)
{
var sgaIdx = sgai;
<div class="d-flex align-items-center gap-1 mb-1">
<span class="small text-muted">Action @(sgaIdx + 1)</span>
<button class="btn btn-sm btn-outline-danger py-0"
@onclick="() => { sg.Actions.RemoveAt(sgaIdx); Compile(); }">
<i class="bi bi-x"></i>
</button>
</div>
}
<button class="btn btn-sm btn-outline-secondary btn-sm"
@onclick="() => { sg.Actions.Add(new ActionDraft()); Compile(); }">
<i class="bi bi-plus-lg me-1"></i>Add Action to Sub-Group
</button>
</div>
</div>
}
<button class="btn btn-sm btn-outline-primary"
@onclick="() => { ab.SubGroups.Add(new ActionGroupDraft()); Compile(); }">
<i class="bi bi-plus-lg me-1"></i>Add Sub-Group
</button>
</div>
}
<!-- Animation & Sound -->
<hr class="my-3" />
<div class="d-flex align-items-center gap-2 mb-2">
@@ -1415,30 +1474,25 @@
}
if (actionsSource != null)
foreach (var actionNode in actionsSource.OfType<JsonObject>())
ab.Actions.Add(ParseActionNode(actionNode));
// Load sub-groups (Groups[]) if present in ActionGroup
if (node["ActionGroup"] is JsonObject agForGroups
&& agForGroups["Groups"] is JsonArray subGroupsArr)
{
foreach (var sgNode in subGroupsArr.OfType<JsonObject>())
{
var target = actionNode["Target"] as JsonObject;
var firstFilter= (target?["Filters"] as JsonArray)?.OfType<JsonObject>().FirstOrDefault();
var act = new ActionDraft
var sg = new ActionGroupDraft
{
Scope = target?["Scope"]?.GetValue<string>() ?? "Battlefield",
TargetType = target?["Type"]?.GetValue<string>() ?? "Unit",
Ownership = target?["Ownership"]?.GetValue<string>() ?? "Enemy",
Chooser = target?["Chooser"]?.GetValue<string>() ?? "Self",
Count = target?["Count"]?["N"]?.GetValue<int>() ?? 1,
All = target?["Count"]?["All"]?.GetValue<bool>() ?? false,
FilterType = firstFilter?["$type"]?.GetValue<string>() ?? "",
LogicOp = sgNode["LogicOp"]?.GetValue<string>() ?? "And",
ChooserRole = sgNode["ChooserRole"]?.GetValue<string>() ?? "Self",
};
if (actionNode["Conditions"] is JsonArray actionConds)
foreach (var c in actionConds.OfType<JsonObject>())
act.Conditions.Add(ParseCondition(c));
if (actionNode["Effects"] is JsonArray effects)
foreach (var eff in effects.OfType<JsonObject>())
act.Effects.Add(ParseEffect(eff));
ab.Actions.Add(act);
if (sgNode["Actions"] is JsonArray sgActions)
foreach (var sgActionNode in sgActions.OfType<JsonObject>())
sg.Actions.Add(ParseActionNode(sgActionNode));
ab.SubGroups.Add(sg);
}
}
if (node["Duration"] is JsonObject dur)
{
@@ -1701,6 +1755,29 @@
return d;
}
private static ActionDraft ParseActionNode(JsonObject actionNode)
{
var target = actionNode["Target"] as JsonObject;
var firstFilter = (target?["Filters"] as JsonArray)?.OfType<JsonObject>().FirstOrDefault();
var act = new ActionDraft
{
Scope = target?["Scope"]?.GetValue<string>() ?? "Battlefield",
TargetType = target?["Type"]?.GetValue<string>() ?? "Unit",
Ownership = target?["Ownership"]?.GetValue<string>() ?? "Enemy",
Chooser = target?["Chooser"]?.GetValue<string>() ?? "Self",
Count = target?["Count"]?["N"]?.GetValue<int>() ?? 1,
All = target?["Count"]?["All"]?.GetValue<bool>() ?? false,
FilterType = firstFilter?["$type"]?.GetValue<string>() ?? "",
};
if (actionNode["Conditions"] is JsonArray actionConds)
foreach (var c in actionConds.OfType<JsonObject>())
act.Conditions.Add(ParseCondition(c));
if (actionNode["Effects"] is JsonArray effects)
foreach (var eff in effects.OfType<JsonObject>())
act.Effects.Add(ParseEffect(eff));
return act;
}
// ── Compile ──────────────────────────────────────────────────────────────────
private void Compile()
@@ -1778,44 +1855,30 @@
var actionsArr = new JsonArray();
foreach (var action in ab.Actions)
{
var targetNode = new JsonObject
{
["Scope"] = action.Scope,
["Type"] = action.TargetType,
["Ownership"] = action.Ownership,
["Chooser"] = action.Chooser,
["Count"] = new JsonObject
{
["N"] = action.All ? 1 : action.Count,
["UpTo"] = false,
["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.Conditions.Count > 0)
{
var ca = new JsonArray();
foreach (var c in action.Conditions) ca.Add(CompileCondition(c));
actionNode["Conditions"] = ca;
}
var effectsArr = new JsonArray();
foreach (var eff in action.Effects)
effectsArr.Add(CompileEffect(eff));
actionNode["Effects"] = effectsArr;
actionsArr.Add(actionNode);
}
actionsArr.Add(CompileActionNode(action));
// Emit ActionGroup (new format) wrapping all leaf actions
var actionGroup = new JsonObject { ["LogicOp"] = ab.ActionGroupLogicOp };
if (ab.ActionGroupLogicOp != "And" || ab.ActionGroupChooserRole != "Self")
actionGroup["ChooserRole"] = ab.ActionGroupChooserRole;
actionGroup["Actions"] = actionsArr;
// Emit sub-groups (Groups[])
var groupsArr = new JsonArray();
foreach (var sg in ab.SubGroups)
{
var sgActionsArr = new JsonArray();
foreach (var sga in sg.Actions)
sgActionsArr.Add(CompileActionNode(sga));
var subGroup = new JsonObject { ["LogicOp"] = sg.LogicOp };
if (sg.LogicOp != "And" || sg.ChooserRole != "Self")
subGroup["ChooserRole"] = sg.ChooserRole;
subGroup["Actions"] = sgActionsArr;
subGroup["Groups"] = new JsonArray();
groupsArr.Add(subGroup);
}
actionGroup["Groups"] = groupsArr;
node["ActionGroup"] = actionGroup;
if (!string.IsNullOrEmpty(ab.DurationStr))
@@ -1853,6 +1916,38 @@
catch { /* keep last valid */ }
}
private static JsonObject CompileActionNode(ActionDraft action)
{
var targetNode = new JsonObject
{
["Scope"] = action.Scope,
["Type"] = action.TargetType,
["Ownership"] = action.Ownership,
["Chooser"] = action.Chooser,
["Count"] = new JsonObject
{
["N"] = action.All ? 1 : action.Count,
["UpTo"] = false,
["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.Conditions.Count > 0)
{
var ca = new JsonArray();
foreach (var c in action.Conditions) ca.Add(CompileCondition(c));
actionNode["Conditions"] = ca;
}
var effectsArr = new JsonArray();
foreach (var eff in action.Effects)
effectsArr.Add(CompileEffect(eff));
actionNode["Effects"] = effectsArr;
return actionNode;
}
private static JsonObject CompileCondition(ConditionDraft c)
{
var node = new JsonObject { ["$type"] = c.TypeStr };
@@ -3158,9 +3253,10 @@
public string DurationStr { get; set; } = "";
public int DurationN { get; set; } = 1;
public List<CostDraft> Costs { get; set; } = new();
public List<ConditionDraft> Conditions { get; set; } = new();
public List<ActionDraft> Actions { get; set; } = new();
public List<CostDraft> Costs { get; set; } = new();
public List<ConditionDraft> Conditions { get; set; } = new();
public List<ActionDraft> Actions { get; set; } = new();
public List<ActionGroupDraft> SubGroups { get; set; } = new();
// Animation & Sound (client-side metadata only)
public bool HasAnimation { get; set; } = false;
@@ -3174,6 +3270,13 @@
public string ImpactSoundUrl { get; set; } = "";
}
private sealed class ActionGroupDraft
{
public string LogicOp { get; set; } = "And";
public string ChooserRole { get; set; } = "Self";
public List<ActionDraft> Actions { get; set; } = new();
}
private sealed class ActionDraft
{
public string Scope { get; set; } = "Battlefield";
@@ -14,6 +14,7 @@ internal sealed class BazaarBuyPrebuiltDeckHandler : BazaarHandlerBase, IMessage
private readonly IMessageSerializer _serializer;
private readonly BazaarDbContext _bazaarDb;
private readonly CollectionDbContext _collectionDb;
private readonly CatalogDbContext _catalogDb;
private readonly SorIdentityDbContext _identityDb;
public string MessageType => "bazaar.buy_prebuilt_deck";
@@ -22,11 +23,13 @@ internal sealed class BazaarBuyPrebuiltDeckHandler : BazaarHandlerBase, IMessage
IMessageSerializer serializer,
BazaarDbContext bazaarDb,
CollectionDbContext collectionDb,
CatalogDbContext catalogDb,
SorIdentityDbContext identityDb)
{
_serializer = serializer;
_bazaarDb = bazaarDb;
_collectionDb = collectionDb;
_catalogDb = catalogDb;
_identityDb = identityDb;
}
@@ -56,9 +59,16 @@ internal sealed class BazaarBuyPrebuiltDeckHandler : BazaarHandlerBase, IMessage
"You do not have enough Origin Points to purchase this deck.");
// ── Grant cards ───────────────────────────────────────────────────────
var allCardIds = deck.Cards.Select(c => c.CardDefinitionId).Distinct().ToHashSet();
var spiritTokenIds = (await _catalogDb.CardDefinitions
.Where(cd => allCardIds.Contains(cd.Id) && cd.CardType == CardType.SpiritToken)
.Select(cd => cd.Id)
.ToListAsync(ct)).ToHashSet();
var grantedCards = new List<PlayerCard>();
foreach (var deckCard in deck.Cards)
{
if (spiritTokenIds.Contains(deckCard.CardDefinitionId)) continue;
for (int i = 0; i < deckCard.Quantity; i++)
{
var pc = new PlayerCard
@@ -104,6 +114,7 @@ internal sealed class BazaarBuyPrebuiltDeckHandler : BazaarHandlerBase, IMessage
foreach (var deckCard in deck.Cards)
{
if (spiritTokenIds.Contains(deckCard.CardDefinitionId)) continue;
_collectionDb.DeckCards.Add(new DeckCard
{
DeckId = newDeck.Id,
@@ -6,6 +6,7 @@ using SOR.Database.Entities.Collection;
using SOR.Database.Entities.Identity;
using SOR.Networking.Abstractions.Messaging;
using SOR.Networking.Abstractions.Transport;
using SOR.Database.Enums;
using SOR.Shared.Networking;
/// <summary>
@@ -81,8 +82,16 @@ internal sealed class CollectionSelectStarterDeckHandler : CollectionHandlerBase
// ── Grant PlayerCards (untradeable) ───────────────────────────────────
// One PlayerCard row per copy of each card in the prebuilt deck.
// SpiritToken cards are summoned by effects and must never enter a player's collection.
var allCardIds = starterDeck.Cards.Select(c => c.CardDefinitionId).Distinct().ToHashSet();
var spiritTokenIds = (await _catalogDb.CardDefinitions
.Where(cd => allCardIds.Contains(cd.Id) && cd.CardType == CardType.SpiritToken)
.Select(cd => cd.Id)
.ToListAsync(cancellationToken)).ToHashSet();
foreach (var deckCard in starterDeck.Cards)
{
if (spiritTokenIds.Contains(deckCard.CardDefinitionId)) continue;
for (int i = 0; i < deckCard.Quantity; i++)
{
_collectionDb.PlayerCards.Add(new PlayerCard
@@ -121,6 +130,7 @@ internal sealed class CollectionSelectStarterDeckHandler : CollectionHandlerBase
foreach (var deckCard in starterDeck.Cards)
{
if (spiritTokenIds.Contains(deckCard.CardDefinitionId)) continue;
_collectionDb.DeckCards.Add(new DeckCard
{
DeckId = deck.Id,
+659 -35
View File
@@ -47,6 +47,22 @@ public static class AbilitySystem
// Top-level ability/action sequence depth for UntilEndOfSequence cleanup.
private static int _sequenceDepth = 0;
// ── JSON options (public factory for tooling) ─────────────────────────────
/// <summary>Returns the same JsonSerializerOptions used by the ability engine. Used by SOR.Tools.</summary>
public static JsonSerializerOptions CreateJsonOptions() => new()
{
PropertyNameCaseInsensitive = true,
Converters =
{
new System.Text.Json.Serialization.JsonStringEnumConverter(),
new EffectPolymorphicConverter(),
new ConditionPolymorphicConverter(),
new TriggerPolymorphicConverter(),
new FilterPolymorphicConverter(),
},
};
// ── Parsing ────────────────────────────────────────────────────────────────
public static AbilityDefinition[] ParseAbilities(string? json)
@@ -112,13 +128,22 @@ public static class AbilitySystem
source.AbilityUsesThisTurn[abilityIndex] = usedThisTurn + 1;
if (def.Cost is { Length: > 0 })
var effectiveActions = GetEffectiveActions(def, ctx, abilityIndex, def.Range, def.Duration);
// GetEffectiveActions returns null when it emitted PendingActionGroupPick (OR/XOR, interactive).
if (effectiveActions is null) return state;
if (def.CostGroup is { } cg)
{
bool paused = PayCosts(def.Cost, ctx, abilityIndex, GetEffectiveActions(def), def.Range, def.Duration);
bool paused = PayCostGroup(cg, ctx, abilityIndex, effectiveActions, def.Range, def.Duration);
if (paused) return state;
}
else if (def.Cost is { Length: > 0 })
{
bool paused = PayCosts(def.Cost, ctx, abilityIndex, effectiveActions, def.Range, def.Duration);
if (paused) return state; // waiting for client cost pick
}
ExecuteActions(GetEffectiveActions(def), ctx, clientTargets, requireClientTargets: true, activationRange: def.Range, forceDuration: def.Duration);
ExecuteActions(effectiveActions, ctx, clientTargets, requireClientTargets: true, activationRange: def.Range, forceDuration: def.Duration);
return state;
}
@@ -142,7 +167,9 @@ public static class AbilitySystem
if (!ValidateSourceActivationConditions(def, ctx, card))
continue;
ExecuteActions(GetEffectiveActions(def), ctx, clientTargets, requireClientTargets: true,
var cardActions = GetEffectiveActions(def, ctx, abilityIndex: 0, def.Range, def.Duration);
if (cardActions is null) continue; // paused for interactive ActionGroup pick
ExecuteActions(cardActions, ctx, clientTargets, requireClientTargets: true,
activationRange: def.Range, forceDuration: def.Duration);
}
@@ -259,7 +286,7 @@ public static class AbilitySystem
}
// If any action needs a human pick, pause and request client input.
var effectiveActions = GetEffectiveActions(def);
var effectiveActions = GetEffectiveActions(def, ctx, abilityIndex: 0, def.Range, def.Duration) ?? [];
if (effectiveActions.Any(ActionNeedsClientTargets))
{
state.PendingTriggeredTarget = new PendingTriggeredTarget
@@ -299,20 +326,23 @@ public static class AbilitySystem
{
state.PendingDeferredEffects.Remove(pending);
Effect[]? deferredEffects;
try { deferredEffects = JsonSerializer.Deserialize<Effect[]>(pending.EffectsJson, _jsonOpts); }
Models.Action[]? deferredActions;
try { deferredActions = JsonSerializer.Deserialize<Models.Action[]>(pending.ActionsJson, _jsonOpts); }
catch { continue; }
if (deferredEffects is null) continue;
var tgt = FindDeferredTarget(state, pending.TargetRef);
if (tgt is null) continue;
if (deferredActions is null || deferredActions.Length == 0) continue;
var dSrc = state.Players.Values
.SelectMany(p => p.Field).OfType<FieldCard>()
.FirstOrDefault(f => f.InstanceId == pending.SourceInstanceId);
var dCtx = new AbilityContext { State = state, ActorId = pending.OwnerAccountId, Source = dSrc };
foreach (var eff in deferredEffects)
ExecuteEffect(eff, tgt, DurationModel.Instant, dCtx);
// Pre-seed the deferred target as action-0 resolved target so chained
// actions inside the deferred tree can reference it.
var tgt = FindDeferredTarget(state, pending.TargetRef);
if (tgt is not null)
dCtx.ResolvedTargets[0] = [tgt];
ExecuteActions(deferredActions, dCtx, clientTargets: null, requireClientTargets: false);
}
return state;
@@ -352,6 +382,10 @@ public static class AbilitySystem
var tile = state.Board?.GetTile(ruin.Position!.Value);
if (tile?.OccupantId is null) continue;
// Skip if this ruin is disabled by DisableRuinForDurationEffect.
if (tile.RuinDisabledUntilTurn > 0 && state.TurnNumber <= tile.RuinDisabledUntilTurn)
continue;
// Only fires if a Spirit or ArchSpirit is on the tile.
var occupantType = FindUnitType(state, tile.OccupantId);
if (occupantType is not ("Spirit" or "ArchSpirit" or "SpiritToken")) continue;
@@ -370,7 +404,9 @@ public static class AbilitySystem
// Select exactly one ability at random.
var chosen = eligible[Random.Shared.Next(eligible.Count)];
ExecuteActions(GetEffectiveActions(chosen), ctx, clientTargets: null);
var chosenActions = GetEffectiveActions(chosen, ctx, abilityIndex: 0, chosen.Range, chosen.Duration);
if (chosenActions is not null)
ExecuteActions(chosenActions, ctx, clientTargets: null);
// Notify observer cards that the ruin activated.
FireTrigger(state, new TriggerOccurrence
@@ -467,6 +503,136 @@ public static class AbilitySystem
return false; // all paid
}
/// <summary>
/// Pays a CostGroup.
/// AND: recursively pays all entries and sub-groups; pauses on first interactive cost.
/// OR/XOR + Random: picks one child (entry or sub-group) at random and pays it.
/// OR/XOR + Self/Opponent: stores <see cref="PendingCostGroupPick"/> and returns true.
/// Returns true when paused (caller must stop and return state).
/// </summary>
private static bool PayCostGroup(
CostGroup group,
AbilityContext ctx,
int abilityIndex,
Models.Action[] pendingActions,
AbilityRange? range,
DurationModel? forceDuration)
{
if (group.LogicOp == CostGroupLogicOp.And)
{
// Pay all leaf entries.
if (group.Entries.Length > 0)
{
bool paused = PayCosts(group.Entries, ctx, abilityIndex, pendingActions, range, forceDuration);
if (paused) return true;
}
// Recurse into sub-groups.
foreach (var child in group.Groups)
{
bool paused = PayCostGroup(child, ctx, abilityIndex, pendingActions, range, forceDuration);
if (paused) return true;
}
return false;
}
// OR / XOR: combined pool = leaf entry sets + nested groups
int entryCount = group.Entries.Length;
int groupCount = group.Groups.Length;
int total = entryCount + groupCount;
if (total == 0) return false;
if (group.ChooserRole == "Random")
{
int idx = Random.Shared.Next(total);
if (idx < entryCount)
{
PaySingleCost(group.Entries[idx], ctx.State.Players[ctx.ActorId], ctx);
return false;
}
return PayCostGroup(group.Groups[idx - entryCount], ctx, abilityIndex,
pendingActions, range, forceDuration);
}
// Self or Opponent: pause for interactive pick.
var chooserActorId = group.ChooserRole == "Opponent"
? ctx.State.GetEnemyIds(ctx.ActorId).FirstOrDefault() ?? ctx.ActorId
: ctx.ActorId;
ctx.State.PendingCostGroupPick = new PendingCostGroupPick
{
ActorId = ctx.ActorId,
ChooserActorId = chooserActorId,
SourceInstanceId = ctx.Source?.InstanceId ?? string.Empty,
AbilityIndex = abilityIndex,
CostGroupJson = JsonSerializer.Serialize(group, _jsonOpts),
ActionsJson = JsonSerializer.Serialize(pendingActions, _jsonOpts),
RangeJson = range is not null ? JsonSerializer.Serialize(range, _jsonOpts) : null,
ForceDurationJson = forceDuration is not null
? JsonSerializer.Serialize(forceDuration, _jsonOpts) : null,
};
return true; // paused
}
/// <summary>
/// Resumes execution after the chooser has responded to a <c>game.cost_group_pick</c>.
/// </summary>
public static GameState ResumeCostGroupPick(
GameState state,
string actorId,
string requestId,
int choiceIndex)
{
var pending = state.PendingCostGroupPick
?? throw new GameException("NO_PENDING_COST_GROUP_PICK");
if (pending.RequestId != requestId)
throw new GameException("REQUEST_ID_MISMATCH");
if (actorId != pending.ActorId && actorId != pending.ChooserActorId)
throw new GameException("NOT_YOUR_COST_GROUP_PICK");
state.PendingCostGroupPick = null;
var group = JsonSerializer.Deserialize<CostGroup>(pending.CostGroupJson, _jsonOpts)
?? throw new GameException("INVALID_COST_GROUP_STATE");
int entryCount = group.Entries.Length;
int groupCount = group.Groups.Length;
int total = entryCount + groupCount;
if (choiceIndex < 0 || choiceIndex >= total)
throw new GameException("INVALID_COST_GROUP_CHOICE");
var source = state.Players.Values
.SelectMany(p => p.Field).OfType<FieldCard>()
.FirstOrDefault(f => f.InstanceId == pending.SourceInstanceId);
if (source is null) return state;
var ctx = new AbilityContext { State = state, ActorId = pending.ActorId, Source = source };
var player = state.Players[pending.ActorId];
AbilityRange? range = pending.RangeJson is not null
? JsonSerializer.Deserialize<AbilityRange>(pending.RangeJson, _jsonOpts) : null;
DurationModel? forceDuration = pending.ForceDurationJson is not null
? JsonSerializer.Deserialize<DurationModel>(pending.ForceDurationJson, _jsonOpts) : null;
var actions = JsonSerializer.Deserialize<Models.Action[]>(pending.ActionsJson, _jsonOpts) ?? [];
if (choiceIndex < entryCount)
{
// Pay the chosen leaf entry.
PaySingleCost(group.Entries[choiceIndex], player, ctx);
}
else
{
// Recursively pay the chosen nested group (AND-only for now; nested OR/XOR would recurse further).
bool paused = PayCostGroup(group.Groups[choiceIndex - entryCount], ctx,
pending.AbilityIndex, actions, range, forceDuration);
if (paused) return state;
}
ExecuteActions(actions, ctx, clientTargets: null, requireClientTargets: false,
activationRange: range, forceDuration: forceDuration);
return state;
}
private static void PaySingleCost(CostEntry cost, PlayerState player, AbilityContext ctx)
{
switch (cost.Type)
@@ -637,27 +803,190 @@ public static class AbilitySystem
return state;
}
// ── ActionGroup backward-compat ───────────────────────────────────────────
/// <summary>
/// Resumes execution after the chooser has responded to a <c>game.branch_pick</c>.
/// </summary>
public static GameState ResumeBranchPick(
GameState state,
string actorId,
string requestId,
int branchIndex)
{
var pending = state.PendingBranchPick
?? throw new GameException("NO_PENDING_BRANCH_PICK");
if (pending.RequestId != requestId)
throw new GameException("REQUEST_ID_MISMATCH");
if (actorId != pending.ActorId && actorId != pending.ChooserActorId)
throw new GameException("NOT_YOUR_BRANCH_PICK");
if (branchIndex < 0 || branchIndex >= pending.BranchCount)
throw new GameException("INVALID_BRANCH_INDEX");
state.PendingBranchPick = null;
var branches = JsonSerializer.Deserialize<Branch[]>(pending.BranchesJson, _jsonOpts) ?? [];
var continuation = JsonSerializer.Deserialize<Models.Action[]>(
pending.ContinuationActionsJson, _jsonOpts) ?? [];
AbilityRange? range = pending.RangeJson is not null
? JsonSerializer.Deserialize<AbilityRange>(pending.RangeJson, _jsonOpts) : null;
DurationModel? forceDuration = pending.ForceDurationJson is not null
? JsonSerializer.Deserialize<DurationModel>(pending.ForceDurationJson, _jsonOpts) : null;
var source = state.Players.Values
.SelectMany(p => p.Field).OfType<FieldCard>()
.FirstOrDefault(f => f.InstanceId == pending.SourceInstanceId);
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,
activationRange: range, forceDuration: forceDuration);
return state;
}
// ── ActionGroup resolution ────────────────────────────────────────────────
/// <summary>
/// Returns the effective action list for an ability, preferring ActionGroup when present.
/// AND groups run all leaf actions sequentially (same as the old flat list).
/// OR/XOR groups pick one leaf action at random for now (full interactive
/// PendingActionGroupPick support is deferred to a future pass).
/// Returns the flat action list to execute for an ability.
/// AND groups are flattened recursively (leaves + nested group leaves).
/// OR/XOR + Random: picks one child (action or nested group) server-side.
/// OR/XOR + Self/Opponent: emits <see cref="PendingActionGroupPick"/>, returns null (caller must pause).
/// Falls back to <see cref="AbilityDefinition.Actions"/> for pre-Phase-1 data.
/// </summary>
private static Models.Action[] GetEffectiveActions(AbilityDefinition def)
private static Models.Action[]? GetEffectiveActions(
AbilityDefinition def,
AbilityContext ctx,
int abilityIndex,
AbilityRange? range,
DurationModel? forceDuration)
{
if (def.ActionGroup is { } ag)
{
if (ag.LogicOp == ActionGroupLogicOp.And || ag.Actions.Length == 0)
return ag.Actions;
// OR / XOR: pick one leaf at random (server-side interim)
return [ag.Actions[Random.Shared.Next(ag.Actions.Length)]];
}
return ResolveActionGroup(ag, ctx, abilityIndex, range, forceDuration,
continuationActions: []);
return def.Actions; // backward-compat: pre-Phase-1 rows use the flat array
}
/// <summary>
/// Recursively resolves an ActionGroup into a flat action list.
/// Returns null when the group is interactive (OR/XOR + Self/Opponent) and
/// <see cref="PendingActionGroupPick"/> has been stored.
/// </summary>
private static Models.Action[]? ResolveActionGroup(
ActionGroup ag,
AbilityContext ctx,
int abilityIndex,
AbilityRange? range,
DurationModel? forceDuration,
Models.Action[] continuationActions)
{
if (ag.LogicOp == ActionGroupLogicOp.And)
{
// AND: run leaves then recurse into nested groups, flattening all.
var all = new List<Models.Action>(ag.Actions);
foreach (var child in ag.Groups)
{
var childActions = ResolveActionGroup(child, ctx, abilityIndex, range,
forceDuration, continuationActions);
if (childActions is null) return null; // child emitted pending pick
all.AddRange(childActions);
}
return all.ToArray();
}
// OR / XOR: combined pool = leaf actions + nested groups
int leafCount = ag.Actions.Length;
int groupCount = ag.Groups.Length;
int total = leafCount + groupCount;
if (total == 0) return [];
if (ag.ChooserRole == "Random")
{
int idx = Random.Shared.Next(total);
if (idx < leafCount)
return [ag.Actions[idx]];
return ResolveActionGroup(ag.Groups[idx - leafCount], ctx, abilityIndex,
range, forceDuration, continuationActions);
}
// Self or Opponent: pause for interactive pick.
var chooserActorId = ag.ChooserRole == "Opponent"
? ctx.State.GetEnemyIds(ctx.ActorId).FirstOrDefault() ?? ctx.ActorId
: ctx.ActorId;
ctx.State.PendingActionGroupPick = new PendingActionGroupPick
{
ActorId = ctx.ActorId,
ChooserActorId = chooserActorId,
SourceInstanceId = ctx.Source?.InstanceId ?? string.Empty,
ActionGroupJson = JsonSerializer.Serialize(ag, _jsonOpts),
ContinuationActionsJson = JsonSerializer.Serialize(continuationActions, _jsonOpts),
RangeJson = range is not null ? JsonSerializer.Serialize(range, _jsonOpts) : null,
ForceDurationJson = forceDuration is not null
? JsonSerializer.Serialize(forceDuration, _jsonOpts) : null,
};
return null; // paused
}
/// <summary>
/// Resumes execution after the chooser has responded to a <c>game.action_group_pick</c>.
/// </summary>
public static GameState ResumeActionGroupPick(
GameState state,
string actorId,
string requestId,
int choiceIndex)
{
var pending = state.PendingActionGroupPick
?? throw new GameException("NO_PENDING_ACTION_GROUP_PICK");
if (pending.RequestId != requestId)
throw new GameException("REQUEST_ID_MISMATCH");
if (actorId != pending.ActorId && actorId != pending.ChooserActorId)
throw new GameException("NOT_YOUR_ACTION_GROUP_PICK");
state.PendingActionGroupPick = null;
var ag = JsonSerializer.Deserialize<ActionGroup>(pending.ActionGroupJson, _jsonOpts)
?? throw new GameException("INVALID_ACTION_GROUP_STATE");
int leafCount = ag.Actions.Length;
int groupCount = ag.Groups.Length;
int total = leafCount + groupCount;
if (choiceIndex < 0 || choiceIndex >= total)
throw new GameException("INVALID_ACTION_GROUP_CHOICE");
var source = state.Players.Values
.SelectMany(p => p.Field).OfType<FieldCard>()
.FirstOrDefault(f => f.InstanceId == pending.SourceInstanceId);
var ctx = new AbilityContext { State = state, ActorId = pending.ActorId, Source = source };
var continuation = JsonSerializer.Deserialize<Models.Action[]>(
pending.ContinuationActionsJson, _jsonOpts) ?? [];
AbilityRange? range = pending.RangeJson is not null
? JsonSerializer.Deserialize<AbilityRange>(pending.RangeJson, _jsonOpts) : null;
DurationModel? forceDuration = pending.ForceDurationJson is not null
? JsonSerializer.Deserialize<DurationModel>(pending.ForceDurationJson, _jsonOpts) : null;
Models.Action[]? chosen;
if (choiceIndex < leafCount)
{
chosen = [ag.Actions[choiceIndex]];
}
else
{
chosen = ResolveActionGroup(ag.Groups[choiceIndex - leafCount], ctx,
abilityIndex: 0, range, forceDuration, continuation);
if (chosen is null) return state; // nested group triggered another pick
}
var allActions = chosen.Concat(continuation).ToArray();
ExecuteActions(allActions, ctx, clientTargets: null, requireClientTargets: false,
activationRange: range, forceDuration: forceDuration);
return state;
}
// ── Action execution ──────────────────────────────────────────────────────
private static void ExecuteActions(
@@ -697,13 +1026,53 @@ public static class AbilitySystem
HashSet<string>? restrictTargets = null,
DurationModel? forceDuration = null)
{
// ChooseOne branch selector: execute the client-chosen branch's actions instead.
// ChooseOne branch selector: execute the chosen branch's actions instead.
if (action.ChooseOne is { Branches.Length: > 0 })
{
var branchIdx = clientTargets?
.FirstOrDefault(t => t.ActionIndex == actionIndex)?.BranchIndex ?? 0;
branchIdx = Math.Clamp(branchIdx, 0, action.ChooseOne.Branches.Length - 1);
ExecuteActions(action.ChooseOne.Branches[branchIdx].Actions, ctx,
var chooser = action.ChooseOne;
int branchIdx;
if (chooser.ChooserRole == "Random")
{
branchIdx = Random.Shared.Next(chooser.Branches.Length);
}
else if (chooser.ChooserRole is "Opponent" or "Ally")
{
// Pause — let the non-activating player pick.
var chooserActorId = chooser.ChooserRole == "Opponent"
? ctx.State.GetEnemyIds(ctx.ActorId).FirstOrDefault() ?? ctx.ActorId
: ctx.State.Players.Values
.FirstOrDefault(p => p.AccountId != ctx.ActorId
&& ctx.State.AreAllies(p.AccountId, ctx.ActorId))
?.AccountId ?? ctx.ActorId;
// Collect remaining actions after this one as continuation.
// (We don't have the full list here — continuation will be empty;
// the branch picker resumes with branch actions only.)
ctx.State.PendingBranchPick = new PendingBranchPick
{
ActorId = ctx.ActorId,
ChooserActorId = chooserActorId,
SourceInstanceId = ctx.Source?.InstanceId ?? string.Empty,
BranchCount = chooser.Branches.Length,
BranchesJson = JsonSerializer.Serialize(chooser.Branches, _jsonOpts),
ContinuationActionsJson = "[]",
RangeJson = activationRange is not null
? JsonSerializer.Serialize(activationRange, _jsonOpts) : null,
ForceDurationJson = forceDuration is not null
? JsonSerializer.Serialize(forceDuration, _jsonOpts) : null,
};
return; // paused — caller will propagate stop
}
else
{
// Self: use client-provided BranchIndex.
branchIdx = clientTargets?
.FirstOrDefault(t => t.ActionIndex == actionIndex)?.BranchIndex ?? 0;
branchIdx = Math.Clamp(branchIdx, 0, chooser.Branches.Length - 1);
}
ExecuteActions(chooser.Branches[branchIdx].Actions, ctx,
clientTargets: null, requireClientTargets: false,
forceDuration: forceDuration);
return;
@@ -892,6 +1261,19 @@ public static class AbilitySystem
if (selector.Filters is { Length: > 0 })
candidates = candidates.Where(c => FiltersMatch(selector.Filters, c, ctx)).ToList();
// TargetChooser.Random: server picks randomly from filtered candidates — skip client IDs.
if (selector.Chooser == TargetChooser.Random)
{
if (activationRange is not null)
{
candidates = FilterTargetsByAbilityRange(candidates.Cast<object>().ToList(), ctx, activationRange)
.OfType<CardInstance>().ToList();
}
var shuffled = candidates.OrderBy(_ => Random.Shared.Next()).ToList();
int take = selector.Count.All ? shuffled.Count : Math.Min(selector.Count.N, shuffled.Count);
return shuffled.Take(take).Cast<object>().ToList();
}
HashSet<string> clientIds = [];
if (clientTargets is not null)
{
@@ -998,6 +1380,20 @@ public static class AbilitySystem
return true;
}
/// <summary>
/// Recursively flattens an AND ActionGroup into a flat action list.
/// OR/XOR groups are left as single-action entries (no interactive pause from here).
/// </summary>
private static Models.Action[] FlattenAndGroup(ActionGroup ag)
{
if (ag.LogicOp != ActionGroupLogicOp.And)
return ag.Actions; // OR/XOR: callers should use ResolveActionGroup; this is a fallback
var all = new List<Models.Action>(ag.Actions);
foreach (var child in ag.Groups)
all.AddRange(FlattenAndGroup(child));
return all.ToArray();
}
private static List<CardInstance> BuildCandidates(
TargetSelector selector, GameState state, string actorId)
{
@@ -1574,12 +1970,16 @@ public static class AbilitySystem
foreach (var card in found)
{
ps.Deck.Remove(card);
if (sde.ThenAction is not null)
if (sde.ThenGroup is not null)
{
// Pre-load the found card as action-0 resolved target so chained
// targeting in ThenGroup can reference it via "Action0.Target".
var innerCtx = new AbilityContext
{ State = ctx.State, ActorId = ctx.ActorId, Source = ctx.Source };
foreach (var eff in sde.ThenAction.Effects)
ExecuteEffect(eff, card, sde.ThenAction.Duration, innerCtx);
innerCtx.ResolvedTargets[0] = [card];
var groupActions = FlattenAndGroup(sde.ThenGroup);
ExecuteActions(groupActions, innerCtx, clientTargets: null,
requireClientTargets: false);
}
else
{
@@ -1794,6 +2194,230 @@ public static class AbilitySystem
break;
}
// ── §5.13 ArchSpirit zone operations ──────────────────────────────
case AscendFromZoneEffect aze when target is FieldCard arcAze && arcAze.IsLeader:
{
// TODO(Phase5-full): full ascension requires catalog lookup for prev-tier card,
// running the ascension handler, and updating AbilitiesJson/stats. Stubbed.
break;
}
case TransitionFromZoneEffect tze when target is FieldCard arcTze && arcTze.IsLeader:
{
// TODO(Phase5-full): full transition requires catalog lookup for same-tier card.
break;
}
case ModifyChannelRangeEffect mcre when target is FieldCard arcMcr && arcMcr.IsLeader:
{
if (mcre.MinDelta != 0)
{
int orig = arcMcr.MinChannelRange ?? 0;
arcMcr.MinChannelRange = Math.Max(0, orig + mcre.MinDelta);
TrackEffect(new ModifyChannelRangeEffect { MinDelta = -(arcMcr.MinChannelRange.Value - orig) },
arcMcr.InstanceId, duration, ctx);
}
if (mcre.MaxDelta != 0)
{
int orig = arcMcr.MaxChannelRange ?? 0;
arcMcr.MaxChannelRange = Math.Max(0, orig + mcre.MaxDelta);
TrackEffect(new ModifyChannelRangeEffect { MaxDelta = -(arcMcr.MaxChannelRange.Value - orig) },
arcMcr.InstanceId, duration, ctx);
}
break;
}
// ── §5.14 Ruin manipulation ────────────────────────────────────────
case RelocateRuinEffect when target is Coord destCoord:
{
// Source is the ruin unit; relocate it to destCoord.
if (ctx.Source is not FieldCard ruinFc || ctx.State.Board is null) break;
var board = ctx.State.Board;
var ruinTile = board.Tiles.Values.FirstOrDefault(t => t.RuinId == ruinFc.InstanceId);
if (ruinTile is null) break;
var destTile = board.GetTile(destCoord);
if (destTile is null || destTile.RuinId is not null) break;
board.RemoveRuin(ruinFc.InstanceId);
board.PlaceRuin(destCoord, ruinFc.InstanceId, ctx.ActorId);
ruinFc.Position = destCoord;
break;
}
case ActivateRuinAbilityEffect arAe when target is FieldCard ruinCard && ruinCard.CardType == "Ruin":
{
var ruinOwner = FindCardOwner(ctx.State, ruinCard.InstanceId);
if (ruinOwner is null) break;
var ruinCtx = new AbilityContext { State = ctx.State, ActorId = ruinOwner.AccountId, Source = ruinCard };
var ruinAbilities = ParseAbilities(ruinCard.AbilitiesJson);
var eligible = ruinAbilities
.Where(a => a.Type == AbilityType.Triggered && a.TriggerEvent is OnRuinActivationTrigger)
.Where(a => a.ActivationConditions is not { Length: > 0 }
|| a.ActivationConditions.All(c => EvaluateCondition(c, ruinCtx, ruinCard)))
.ToList();
if (eligible.Count == 0) break;
AbilityDefinition chosen;
if (!arAe.Random && arAe.AbilityRef is not null)
chosen = eligible.FirstOrDefault(a => a.Name == arAe.AbilityRef) ?? eligible[Random.Shared.Next(eligible.Count)];
else
chosen = eligible[Random.Shared.Next(eligible.Count)];
var chosenActs = GetEffectiveActions(chosen, ruinCtx, 0, chosen.Range, chosen.Duration);
if (chosenActs is not null)
ExecuteActions(chosenActs, ruinCtx, clientTargets: null);
break;
}
case DisableRuinForDurationEffect drfd when target is FieldCard ruinDis && ruinDis.CardType == "Ruin":
{
if (ruinDis.Position.HasValue && ctx.State.Board is not null)
{
var ruinDisTile = ctx.State.Board.GetTile(ruinDis.Position.Value);
if (ruinDisTile is not null)
{
int disableTurns = drfd.Duration.Type switch
{
DurationType.ForNTurns => drfd.Duration.N ?? 1,
_ => 1,
};
ruinDisTile.RuinDisabledUntilTurn = ctx.State.TurnNumber + disableTurns;
}
}
break;
}
// ── §5.15 Enhanced channeling ──────────────────────────────────────
case ChannelCardFromZoneEffect ccze when target is CardInstance ciCcze:
{
// TODO(Phase5-full): full channeling from zone requires tile selection,
// control assignment, and invoking the existing channel logic.
// For now: move card from the specified zone to the battlefield (basic path).
var ccOwner = FindCardOwner(ctx.State, ciCcze.InstanceId);
if (ccOwner is null) break;
_ = ccze; // suppress unused warning until full impl
break;
}
// ── §5.16 Token / spirit operations ───────────────────────────────
case CloneSpiritAsTokenEffect cste when target is FieldCard spiritToClone:
{
if (ctx.State.Board is null || !spiritToClone.Position.HasValue) break;
var board = ctx.State.Board;
// Find a suitable destination tile.
Coord? dest = cste.DestinationScope switch
{
"TargetTile" => ctx.ResolvedTargets.Count > 0
? ctx.ResolvedTargets.Values.SelectMany(x => x).OfType<Coord>().FirstOrDefault()
: (Coord?)null,
"RandomInChannelRange" when ctx.Source is FieldCard srcFc && srcFc.Position.HasValue =>
board.Tiles.Values
.Where(t => t.IsEmpty && t.Coord.ManhattanDistance(srcFc.Position.Value) <= (ctx.Source as CardInstance)?.MaxChannelRange.GetValueOrDefault(2))
.Select(t => t.Coord)
.OrderBy(_ => Random.Shared.Next())
.Cast<Coord?>()
.FirstOrDefault(),
_ => // NeighborTile (default)
board.Tiles.Values
.Where(t => t.IsEmpty && t.Coord.IsOrthogonallyAdjacentTo(spiritToClone.Position.Value))
.Select(t => t.Coord)
.OrderBy(_ => Random.Shared.Next())
.Cast<Coord?>()
.FirstOrDefault(),
};
if (dest is null) break;
var tokenProto = new CardInstance
{
InstanceId = Guid.NewGuid().ToString("N")[..8],
CardType = "SpiritToken",
Name = spiritToClone.Name,
Affinity = spiritToClone.Affinity,
MaxHealth = spiritToClone.MaxHealth,
CurrentHealth = spiritToClone.MaxHealth,
MaxDefense = spiritToClone.MaxDefense,
CurrentDefense = spiritToClone.MaxDefense,
Damage = spiritToClone.Damage,
CanMove = spiritToClone.CanMove,
CanAttack = spiritToClone.CanAttack,
CanDefend = spiritToClone.CanDefend,
MovementType = spiritToClone.MovementType,
AbilitiesJson = spiritToClone.AbilitiesJson,
};
var tokenField = CreateTokenFieldCard(tokenProto, dest.Value);
ctx.State.Players[ctx.ActorId].Field.Add(tokenField);
board.PlaceUnit(dest.Value, tokenField.InstanceId, ctx.ActorId);
EvaluateAurasOnEnter(ctx.State, tokenField.InstanceId);
break;
}
case DestroyTokenEffect when target is FieldCard tokenFc && tokenFc.CardType == "SpiritToken":
KillUnit(tokenFc, ctx, ctx.Source?.InstanceId);
break;
// ── §5.17 Player operations ────────────────────────────────────────
case SkipTurnEffect when target is PlayerState skipPs:
skipPs.SkipTurnCount += 1;
break;
case ModifyCardsDrawnThisTurnEffect mcdtt when target is PlayerState mcdtPs:
mcdtPs.CardsDrawnThisTurnBonus += ResolveValue(mcdtt.Amount, ctx);
break;
// ── §5.18 Zone operations ──────────────────────────────────────────
case StackDeckEffect stkDe when target is PlayerState stackPs:
{
// TODO(Phase5-full): requires PendingRevealChoicePick interactive pause.
// For now: shuffle top N randomly as a non-interactive fallback.
int n = Math.Min(stkDe.Count, stackPs.Deck.Count);
var topN = stackPs.Deck.TakeLast(n).ToList();
for (int si = topN.Count - 1; si > 0; si--)
{
int sj = Random.Shared.Next(si + 1);
(topN[si], topN[sj]) = (topN[sj], topN[si]);
}
for (int si = 0; si < n; si++)
stackPs.Deck[stackPs.Deck.Count - n + si] = topN[si];
break;
}
case SearchAndPlaceEffect sape when target is PlayerState sapPs:
{
var found = sapPs.Deck
.Where(c => sape.Filters is null || FiltersMatch(sape.Filters, c, ctx))
.Take(sape.Count).ToList();
foreach (var card in found)
{
sapPs.Deck.Remove(card);
switch (sape.Destination)
{
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);
break;
default: sapPs.Hand.Add(card); break;
}
}
if (sape.ShuffleAfter)
{
for (int si = sapPs.Deck.Count - 1; si > 0; si--)
{
int sj = Random.Shared.Next(si + 1);
(sapPs.Deck[si], sapPs.Deck[sj]) = (sapPs.Deck[sj], sapPs.Deck[si]);
}
}
break;
}
// ── §5.19 Unit manipulation ────────────────────────────────────────
case ChangeAttackTypeEffect cate when target is CardInstance ciCat:
{
var origAt = ciCat.AttackType;
ciCat.AttackType = cate.AttackType;
TrackEffect(new ChangeAttackTypeEffect { AttackType = origAt ?? default },
ciCat.InstanceId, duration, ctx);
break;
}
case ObstructMovementTypeEffect omte when target is FieldCard fcOmte:
{
// Use CanBeObstructed as a proxy: mark this unit as obstructing movement.
// TODO(Phase5-full): proper tracking of which movement types are obstructed.
_ = omte;
break;
}
// ── §5.12 Deferred ────────────────────────────────────────────────
case ApplyOnEventEffect aoe:
{
@@ -1807,7 +2431,7 @@ public static class AbilitySystem
OwnerAccountId = ctx.ActorId,
TriggerJson = JsonSerializer.Serialize(aoe.Trigger, _jsonOpts),
TargetRef = targetRef,
EffectsJson = JsonSerializer.Serialize(aoe.Effects, _jsonOpts),
ActionsJson = JsonSerializer.Serialize(aoe.Actions, _jsonOpts),
});
break;
}
+36 -44
View File
@@ -98,6 +98,29 @@ using SOR.Database.Enums;
[PolyType(typeof(SummonTokenEffect), "SummonToken")]
// §5.12 Deferred
[PolyType(typeof(ApplyOnEventEffect), "ApplyOnEvent")]
// §5.13 ArchSpirit zone operations
[PolyType(typeof(AscendFromZoneEffect), "AscendFromZone")]
[PolyType(typeof(TransitionFromZoneEffect), "TransitionFromZone")]
[PolyType(typeof(ModifyChannelRangeEffect), "ModifyChannelRange")]
// §5.14 Ruin manipulation
[PolyType(typeof(RelocateRuinEffect), "RelocateRuin")]
[PolyType(typeof(ActivateRuinAbilityEffect), "ActivateRuinAbility")]
[PolyType(typeof(DisableRuinForDurationEffect), "DisableRuinForDuration")]
// §5.15 Enhanced channeling
[PolyType(typeof(ChannelCardFromZoneEffect), "ChannelCardFromZone")]
// §5.16 Token / spirit operations
[PolyType(typeof(CloneSpiritAsTokenEffect), "CloneSpiritAsToken")]
[PolyType(typeof(DestroyTokenEffect), "DestroyToken")]
[PolyType(typeof(ModifySacrificeTokenReturnEffect),"ModifySacrificeTokenReturn")]
// §5.17 Player operations
[PolyType(typeof(SkipTurnEffect), "SkipTurn")]
[PolyType(typeof(ModifyCardsDrawnThisTurnEffect), "ModifyCardsDrawnThisTurn")]
// §5.18 Zone operations
[PolyType(typeof(StackDeckEffect), "StackDeck")]
[PolyType(typeof(SearchAndPlaceEffect), "SearchAndPlace")]
// §5.19 Unit manipulation
[PolyType(typeof(ChangeAttackTypeEffect), "ChangeAttackType")]
[PolyType(typeof(ObstructMovementTypeEffect), "ObstructMovementType")]
public abstract class Effect { }
// ── §5.1 Stat modification ────────────────────────────────────────────────────
@@ -190,10 +213,14 @@ public sealed class ReturnToBattlefieldEffect : Effect { public string? Controll
public sealed class SendToDiscardEffect: Effect { }
public sealed class SearchDeckEffect : Effect
{
public Filter[]? Filters { get; set; }
public int Count { get; set; } = 1;
/// <summary>Action applied to each found card (SearchResult references current card).</summary>
public Action? ThenAction { get; set; }
public Filter[]? Filters { get; set; }
public int Count { get; set; } = 1;
/// <summary>
/// Action group applied to each found card. The found card is pre-loaded as the resolved
/// target so chained targeting within the group can reference it via "Action0.Target".
/// Null means the card is moved to hand.
/// </summary>
public ActionGroup? ThenGroup { get; set; }
}
public sealed class ShuffleDeckEffect : Effect { public string Player { get; set; } = "Owner"; }
public sealed class RevealCardsEffect : Effect { public int N { get; set; } = 1; public string ToOwnership { get; set; } = "Any"; }
@@ -281,45 +308,6 @@ public sealed class SummonTokenEffect : Effect
// ── §5.13 ArchSpirit zone operations ─────────────────────────────────────────
[PolyType(typeof(AscendFromZoneEffect), "AscendFromZone")]
[PolyType(typeof(TransitionFromZoneEffect), "TransitionFromZone")]
[PolyType(typeof(ModifyChannelRangeEffect), "ModifyChannelRange")]
// ── §5.14 Ruin manipulation ───────────────────────────────────────────────────
[PolyType(typeof(RelocateRuinEffect), "RelocateRuin")]
[PolyType(typeof(ActivateRuinAbilityEffect), "ActivateRuinAbility")]
[PolyType(typeof(DisableRuinForDurationEffect), "DisableRuinForDuration")]
// ── §5.15 Enhanced channeling ─────────────────────────────────────────────────
[PolyType(typeof(ChannelCardFromZoneEffect), "ChannelCardFromZone")]
// ── §5.16 Token / spirit operations ──────────────────────────────────────────
[PolyType(typeof(CloneSpiritAsTokenEffect), "CloneSpiritAsToken")]
[PolyType(typeof(DestroyTokenEffect), "DestroyToken")]
[PolyType(typeof(ModifySacrificeTokenReturnEffect),"ModifySacrificeTokenReturn")]
// ── §5.17 Player operations ───────────────────────────────────────────────────
[PolyType(typeof(SkipTurnEffect), "SkipTurn")]
[PolyType(typeof(ModifyCardsDrawnThisTurnEffect), "ModifyCardsDrawnThisTurn")]
// ── §5.18 Zone operations ─────────────────────────────────────────────────────
[PolyType(typeof(StackDeckEffect), "StackDeck")]
[PolyType(typeof(SearchAndPlaceEffect), "SearchAndPlace")]
// ── §5.19 Unit manipulation ───────────────────────────────────────────────────
[PolyType(typeof(ChangeAttackTypeEffect), "ChangeAttackType")]
[PolyType(typeof(ObstructMovementTypeEffect), "ObstructMovementType")]
// ── §5.12 Deferred effects ────────────────────────────────────────────────────
// ── §5.13 ArchSpirit zone operations ──────────────────────────────────────────
/// <summary>Ascend the target ArchSpirit using a previous-tier card from the given zone.</summary>
public sealed class AscendFromZoneEffect : Effect
{
@@ -476,5 +464,9 @@ public sealed class ObstructMovementTypeEffect : Effect
public sealed class ApplyOnEventEffect : Effect
{
public TriggerEvent Trigger { get; set; } = null!;
public Effect[] Effects { get; set; } = [];
/// <summary>
/// Full action tree executed when the trigger fires. Supports chained targeting and
/// nested ActionGroups. Replaces the old flat Effect[] for recursive ability trees.
/// </summary>
public Action[] Actions { get; set; } = [];
}
@@ -0,0 +1,39 @@
namespace SOR.Game.Abilities.Models;
/// <summary>
/// Stored in GameState when an ActionGroup with OR/XOR logic requires a player to choose
/// which child (leaf Action or nested ActionGroup) executes.
///
/// The game is paused until the chooser submits a <c>game.action_group_pick</c> response
/// with a <see cref="ChoiceIndex"/> matching one of the available children.
/// </summary>
public sealed class PendingActionGroupPick
{
/// <summary>Correlation ID sent to the client so responses can be matched.</summary>
public string RequestId { get; set; } = Guid.NewGuid().ToString("N");
/// <summary>AccountId of the player who activated the ability.</summary>
public string ActorId { get; set; } = string.Empty;
/// <summary>AccountId of the player who must choose ("Self" = ActorId, "Opponent" = other player).</summary>
public string ChooserActorId { get; set; } = string.Empty;
/// <summary>InstanceId of the source unit (may be empty for card-triggered abilities).</summary>
public string SourceInstanceId { get; set; } = string.Empty;
/// <summary>
/// JSON-serialized ActionGroup — the full group being picked from.
/// Actions[0..n-1] are leaf actions; Groups[0..m-1] are nested groups.
/// The combined pool is Actions then Groups (indices 0..n+m-1).
/// </summary>
public string ActionGroupJson { get; set; } = "{}";
/// <summary>JSON-serialized Action[] — the full action list to execute AFTER the picked branch finishes.</summary>
public string ContinuationActionsJson { get; set; } = "[]";
/// <summary>JSON-serialized AbilityRange? — passed through to ExecuteActions on resume.</summary>
public string? RangeJson { get; set; }
/// <summary>JSON-serialized DurationModel? — forceDuration passed to ExecuteActions on resume.</summary>
public string? ForceDurationJson { get; set; }
}
@@ -0,0 +1,41 @@
namespace SOR.Game.Abilities.Models;
/// <summary>
/// Stored in GameState when a ChooseOne action has ChooserRole="Opponent" (or "Ally") and
/// requires the non-activating player to select a branch.
///
/// The game is paused until the chooser submits a <c>game.branch_pick</c> response
/// with a <see cref="BranchIndex"/> in range.
/// </summary>
public sealed class PendingBranchPick
{
/// <summary>Correlation ID sent to the client so responses can be matched.</summary>
public string RequestId { get; set; } = Guid.NewGuid().ToString("N");
/// <summary>AccountId of the player who activated the ability.</summary>
public string ActorId { get; set; } = string.Empty;
/// <summary>AccountId of the player who must pick the branch.</summary>
public string ChooserActorId { get; set; } = string.Empty;
/// <summary>InstanceId of the source unit (may be empty for card-triggered abilities).</summary>
public string SourceInstanceId { get; set; } = string.Empty;
/// <summary>Number of available branches.</summary>
public int BranchCount { get; set; }
/// <summary>
/// JSON-serialized Branch[] from the ChooseOne — passed to the client for display.
/// The chooser picks an index 0..BranchCount-1.
/// </summary>
public string BranchesJson { get; set; } = "[]";
/// <summary>JSON-serialized Action[] — the remaining actions to execute AFTER the chosen branch.</summary>
public string ContinuationActionsJson { get; set; } = "[]";
/// <summary>JSON-serialized AbilityRange? — passed through to ExecuteActions on resume.</summary>
public string? RangeJson { get; set; }
/// <summary>JSON-serialized DurationModel? — forceDuration applied to all continuation actions.</summary>
public string? ForceDurationJson { get; set; }
}
@@ -0,0 +1,43 @@
namespace SOR.Game.Abilities.Models;
/// <summary>
/// Stored in GameState when a CostGroup with OR/XOR logic requires a player to choose
/// which cost option (leaf CostEntry[] or nested CostGroup) to pay.
///
/// The game is paused until the chooser submits a <c>game.cost_group_pick</c> response
/// with a <see cref="ChoiceIndex"/> matching one of the available options.
/// </summary>
public sealed class PendingCostGroupPick
{
/// <summary>Correlation ID sent to the client so responses can be matched.</summary>
public string RequestId { get; set; } = Guid.NewGuid().ToString("N");
/// <summary>AccountId of the player who activated the ability.</summary>
public string ActorId { get; set; } = string.Empty;
/// <summary>AccountId of the player who must choose (may differ from ActorId for Opponent chooser).</summary>
public string ChooserActorId { get; set; } = string.Empty;
/// <summary>InstanceId of the source unit (may be empty for card-triggered abilities).</summary>
public string SourceInstanceId { get; set; } = string.Empty;
/// <summary>0-based ability index on the source unit.</summary>
public int AbilityIndex { get; set; }
/// <summary>
/// JSON-serialized CostGroup — the full group being picked from.
/// Entries[0..n-1] are leaf cost entries (each a CostEntry[]);
/// Groups[0..m-1] are nested groups.
/// Combined pool indices: 0..n-1 = entries, n..n+m-1 = nested groups.
/// </summary>
public string CostGroupJson { get; set; } = "{}";
/// <summary>JSON-serialized Action[] — the full action list to execute after all costs are paid.</summary>
public string ActionsJson { get; set; } = "[]";
/// <summary>JSON-serialized AbilityRange? — passed through to ExecuteActions on resume.</summary>
public string? RangeJson { get; set; }
/// <summary>JSON-serialized DurationModel? — forceDuration passed to ExecuteActions on resume.</summary>
public string? ForceDurationJson { get; set; }
}
+16 -1
View File
@@ -209,7 +209,8 @@ public static class GameEngine
var player = state.Players[actorId];
var rules = state.Rules;
int count = Math.Max(1, rules.DrawPerTurn + player.DrawPerTurnBonus);
int count = Math.Max(1, rules.DrawPerTurn + player.DrawPerTurnBonus + player.CardsDrawnThisTurnBonus);
player.CardsDrawnThisTurnBonus = 0; // single-use this turn only
var drawn = new List<CardInstance>(count);
for (int i = 0; i < count && player.Deck.Count > 0; i++)
@@ -927,6 +928,20 @@ public static class GameEngine
state.ActivePlayerAccountId = state.GetNextActiveSeat(actorId);
state.TurnNumber++;
// Apply SkipTurn: if the incoming active player has pending skips, burn one and
// advance again (recursively until we find a non-skipping player or lap the table).
{
int safetyLap = state.Players.Count + 1;
while (safetyLap-- > 0)
{
var incoming = state.Players[state.ActivePlayerAccountId];
if (incoming.SkipTurnCount <= 0) break;
incoming.SkipTurnCount--;
state.ActivePlayerAccountId = state.GetNextActiveSeat(state.ActivePlayerAccountId);
state.TurnNumber++;
}
}
// Check turn limit BEFORE setting up the new turn.
var rules = state.Rules;
if (rules.TurnLimit > 0 && state.TurnNumber > rules.TurnLimit)
+40 -5
View File
@@ -107,6 +107,25 @@ public sealed class GameState
/// the picker submits a <c>game.cost_pick</c> response.
/// </summary>
public Abilities.Models.PendingCostPick? PendingCostPick { get; set; }
/// <summary>
/// Non-null when a CostGroup with OR/XOR logic requires a player to choose which
/// cost option to pay. Paused until the chooser submits a <c>game.cost_group_pick</c>.
/// </summary>
public Abilities.Models.PendingCostGroupPick? PendingCostGroupPick { get; set; }
/// <summary>
/// Non-null when an ActionGroup with OR/XOR logic requires a player to choose which
/// child (action or nested group) to execute. Paused until chooser submits
/// a <c>game.action_group_pick</c>.
/// </summary>
public Abilities.Models.PendingActionGroupPick? PendingActionGroupPick { get; set; }
/// <summary>
/// Non-null when a ChooseOne action's ChooserRole is Opponent/Ally and the non-activating
/// player must select a branch. Paused until chooser submits a <c>game.branch_pick</c>.
/// </summary>
public Abilities.Models.PendingBranchPick? PendingBranchPick { get; set; }
}
public sealed class PlayerState
@@ -173,6 +192,18 @@ public sealed class PlayerState
public bool CanChannelTerramorphaDi { get; set; } = true;
public bool CanChannelTerramorphaTri { get; set; } = true;
/// <summary>
/// Bonus/penalty to cards drawn THIS turn only (reset at end of turn).
/// Modified by ModifyCardsDrawnThisTurnEffect.
/// </summary>
public int CardsDrawnThisTurnBonus { get; set; }
/// <summary>
/// Number of upcoming turns this player will skip (decremented at turn-start).
/// Set by SkipTurnEffect.
/// </summary>
public int SkipTurnCount { get; set; }
// ── Leader ───────────────────────────────────────────────────────────────
/// <summary>
@@ -222,9 +253,13 @@ public class CardInstance
// ── Attack ────────────────────────────────────────────────────────────────
public int? MinAttackRange { get; set; }
public int? MaxAttackRange { get; set; }
public bool RequiresLos { get; set; }
public int? MinAttackRange { get; set; }
public int? MaxAttackRange { get; set; }
public bool RequiresLos { get; set; }
/// <summary>
/// Override attack type set by ChangeAttackTypeEffect. Null = use card definition default.
/// </summary>
public AttackType? AttackType { get; set; }
// ── Channeling ────────────────────────────────────────────────────────────
@@ -366,8 +401,8 @@ public sealed class PendingDeferredEffect
/// <summary>InstanceId (card) or AccountId (player) of the entity to apply effects to.</summary>
public string TargetRef { get; set; } = string.Empty;
/// <summary>Serialized Effect[] JSON — effects applied to TargetRef when the trigger fires.</summary>
public string EffectsJson { get; set; } = "[]";
/// <summary>Serialized Action[] JSON — actions executed when the trigger fires.</summary>
public string ActionsJson { get; set; } = "[]";
}
/// <summary>
+6
View File
@@ -36,4 +36,10 @@ public sealed class Tile
/// <summary>InstanceId of a Ruin on this tile, or null if none. Independent of OccupantId.</summary>
public string? RuinId { get; set; }
public string? RuinOwner { get; set; }
/// <summary>
/// Turn number after which this tile's Ruin re-enables. 0 = not disabled.
/// Set by DisableRuinForDurationEffect; checked in FireRuinAbilities.
/// </summary>
public int RuinDisabledUntilTurn { get; set; }
}
@@ -0,0 +1,132 @@
namespace SOR.Tools.Migrations;
using System.Text.Json;
using System.Text.Json.Nodes;
using Microsoft.EntityFrameworkCore;
using SOR.Database.Contexts;
using SOR.Game.Abilities;
using SOR.Game.Abilities.Models;
/// <summary>
/// One-time migration tool that converts card AbilitiesJson rows from the legacy flat-Actions[]
/// shape to the new ActionGroup / CostGroup shape introduced in Phase 1–4.
///
/// Legacy shape (pre-Phase-1):
/// { "Type": "Active", "Actions": [ ... ], "Cost": [ ... ] }
///
/// New shape (Phase 1+):
/// { "Type": "Active", "ActionGroup": { "LogicOp": "And", "Actions": [...], "Groups": [] },
/// "CostGroup": { "LogicOp": "And", "Entries": [...], "Groups": [] } }
///
/// Run from the Server/ directory:
/// dotnet run --project src/SOR.Tools -- cutover-abilities [--dry-run] [--connection-string "..."]
///
/// The tool is idempotent: cards that already have ActionGroup set are left untouched.
/// </summary>
public static class EffectsJsonCutover
{
private static readonly JsonSerializerOptions _jsonOpts = AbilitySystem.CreateJsonOptions();
public static async Task<int> RunAsync(string connectionString, bool dryRun)
{
var opts = new DbContextOptionsBuilder<CatalogDbContext>()
.UseNpgsql(connectionString)
.Options;
using var db = new CatalogDbContext(opts);
var cards = await db.CardDefinitions
.Where(c => c.AbilitiesJson != null)
.ToListAsync();
int migrated = 0;
int skipped = 0;
int errors = 0;
foreach (var card in cards)
{
if (string.IsNullOrWhiteSpace(card.AbilitiesJson)) { skipped++; continue; }
JsonArray? root;
try
{
root = JsonNode.Parse(card.AbilitiesJson) as JsonArray;
if (root is null) { skipped++; continue; }
}
catch { errors++; Console.Error.WriteLine($"[SKIP] {card.Id}: invalid JSON"); continue; }
bool changed = false;
foreach (var node in root)
{
if (node is not JsonObject abilityObj) continue;
// Already migrated — has ActionGroup set and non-null.
if (abilityObj["ActionGroup"] is JsonObject ag && ag.Count > 0)
continue;
// Migrate flat Actions[] → ActionGroup(And).
if (abilityObj["Actions"] is JsonArray actionsArr && actionsArr.Count > 0)
{
abilityObj["ActionGroup"] = new JsonObject
{
["LogicOp"] = "And",
["ChooserRole"] = "Self",
["Actions"] = actionsArr.DeepClone(),
["Groups"] = new JsonArray(),
};
abilityObj.Remove("Actions");
changed = true;
}
// Migrate flat Cost[] → CostGroup(And).
if (abilityObj["Cost"] is JsonArray costArr && costArr.Count > 0
&& abilityObj["CostGroup"] is null)
{
abilityObj["CostGroup"] = new JsonObject
{
["LogicOp"] = "And",
["ChooserRole"] = "Self",
["Entries"] = costArr.DeepClone(),
["Groups"] = new JsonArray(),
};
abilityObj.Remove("Cost");
changed = true;
}
}
if (!changed) { skipped++; continue; }
// Validate round-trip before committing.
var newJson = root.ToJsonString();
try
{
var parsed = JsonSerializer.Deserialize<AbilityDefinition[]>(newJson, _jsonOpts);
if (parsed is null) throw new InvalidOperationException("Deserialised to null");
}
catch (Exception ex)
{
errors++;
Console.Error.WriteLine($"[ERROR] {card.Id} ({card.Name}): round-trip failed: {ex.Message}");
continue;
}
Console.WriteLine($"[MIGRATE] {card.Id} ({card.Name})");
card.AbilitiesJson = newJson;
migrated++;
}
Console.WriteLine();
Console.WriteLine($"Total: {cards.Count} Migrated: {migrated} Skipped: {skipped} Errors: {errors}");
if (dryRun)
{
Console.WriteLine("(dry-run — no changes written)");
return errors;
}
if (migrated > 0)
await db.SaveChangesAsync();
return errors;
}
}
+37
View File
@@ -0,0 +1,37 @@
// SOR.Tools — one-off migration and maintenance utilities.
// Usage: dotnet run --project src/SOR.Tools -- <command> [options]
//
// Commands:
// cutover-abilities Convert legacy flat Actions[]/Cost[] to ActionGroup/CostGroup.
// --dry-run Print what would change without writing to the database.
// --conn <string> Postgres connection string (default: env var SOR_CATALOG_CONN).
using SOR.Tools.Migrations;
var command = args.FirstOrDefault() ?? string.Empty;
switch (command)
{
case "cutover-abilities":
{
bool dryRun = args.Contains("--dry-run");
int connIdx = Array.IndexOf(args, "--conn");
string? conn = connIdx >= 0 && connIdx + 1 < args.Length
? args[connIdx + 1]
: Environment.GetEnvironmentVariable("SOR_CATALOG_CONN");
if (string.IsNullOrWhiteSpace(conn))
{
Console.Error.WriteLine("ERROR: provide --conn <connection-string> or set SOR_CATALOG_CONN env var.");
return 1;
}
int exitCode = await EffectsJsonCutover.RunAsync(conn, dryRun);
return exitCode;
}
default:
Console.Error.WriteLine($"Unknown command: '{command}'");
Console.Error.WriteLine("Available commands: cutover-abilities");
return 1;
}
+17
View File
@@ -0,0 +1,17 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<OutputType>Exe</OutputType>
<AssemblyName>SOR.Tools</AssemblyName>
</PropertyGroup>
<ItemGroup>
<FrameworkReference Include="Microsoft.AspNetCore.App" />
<PackageReference Include="Microsoft.EntityFrameworkCore" />
<PackageReference Include="Npgsql.EntityFrameworkCore.PostgreSQL" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\SOR.Database\SOR.Database.csproj" />
<ProjectReference Include="..\SOR.Game\SOR.Game.csproj" />
</ItemGroup>
</Project>
+161
View File
@@ -0,0 +1,161 @@
# newCard-Cont.md — Ability Revamp Continuation Plan
Gap analysis from last 7 commits (phases 0–6). Items ordered by fix priority.
---
## Critical Bugs (silent runtime failures)
### 1. `[PolyType]` attributes misplaced — Effects.cs:284–318
The new effect type registrations appear **after** `public abstract class Effect { }` (line 101).
In C#, floating attributes attach to the **next** class declaration (`AscendFromZoneEffect`, line 324),
not to `Effect`. The polymorphic JSON converter never learns about ~12 new effect types.
Deserialization will silently fail or throw at runtime for any card using these effects.
**Fix:** Move all lines 284–318 to just before line 101 (before the `Effect` class declaration).
- [x] Done
---
### 2. SpiritToken exclusions incomplete
`BazaarBuyPrebuiltDeckHandler.cs:60` and `CollectionSelectStarterDeckHandler.cs:84` grant all deck
cards without filtering out SpiritToken. `CollectionAddCardHandler.cs:71` already blocks it but these
two paths do not.
**Fix:** Add SpiritToken guard to both handlers (same pattern as CollectionAddCardHandler).
- [x] Done
---
### 3. CostGroup not paid — AbilitySystem.cs:115–118
`ActivateAbility` checks `def.Cost` only. `def.CostGroup` is never read, never executed.
Costs authored in the new builder are silently skipped.
**Fix:** After existing `def.Cost` block, add `PayCostGroup(def.CostGroup, ...)` path with
`PendingCostGroupPick` pause support. Wire into `ActivateAbility`.
- [x] Done
---
## Major Missing Subsystems
### 4. PendingInteraction envelope — GameState.cs:97–109
Only `PendingTriggeredTarget` and `PendingCostPick` exist. Full interactive-pause protocol requires:
- `PendingActionGroupPick` (OR/XOR branch selection)
- `PendingCostGroupPick` (CostGroup interactive payment)
- `PendingBranchPick` (ChooseOne with non-self chooser)
- `PendingTilePick`, `PendingPlayerPick`, `PendingRevealChoicePick`
**Fix:** Add pending state types + properties to GameState. Wire handler endpoints.
- [x] Done
---
### 5. Phase 5 new effects are model-only
Zero engine switch cases for: `AscendFromZoneEffect`, `TransitionFromZoneEffect`,
`ModifyChannelRangeEffect`, `RelocateRuinEffect`, `ActivateRuinAbilityEffect`,
`DisableRuinForDurationEffect`, `ChannelCardFromZoneEffect`, `CloneSpiritAsTokenEffect`,
`DestroyTokenEffect`, `SkipTurnEffect`, `StackDeckEffect`, `SearchAndPlaceEffect`,
`ChangeAttackTypeEffect`, `ObstructMovementTypeEffect`.
All fall through `ExecuteEffect` switch silently.
**Fix:** Add engine switch cases for each. Some are full implementations; complex ones
(AscendFromZone, ChannelCardFromZone, StackDeck) need deeper game logic.
- [x] Done
---
### 6. ActionGroup recursion missing — AbilitySystem.cs:651–658
`GetEffectiveActions` returns only `ag.Actions` (top-level leaf array). Nested `ag.Groups`
are never traversed. AND-logic and recursive trees are silently ignored.
**Fix:** Recursively flatten AND groups; for OR/XOR emit `PendingActionGroupPick` instead of
random-picking.
- [x] Done
---
### 7. ChooseOne ChooserRole + TargetSelector.Chooser unimplemented
- `ChooseOne.ChooserRole`: defaults to branch 0; no `PendingBranchPick`, no opponent/random logic.
AbilitySystem.cs:700–709.
- `TargetSelector.Chooser`: `ResolveTargets` uses `selector.Ownership` but never reads
`selector.Chooser`. Random/Self/Opponent/Ally chooser logic unimplemented. AbilitySystem.cs:828+.
**Fix:** Emit `PendingBranchPick` for non-Self choosers. Branch on `selector.Chooser` in
`ResolveTargets`.
- [x] Done
---
## Structural Model Issues
### 8. `SearchDeckEffect.ThenAction` should be `ActionGroup?`
Effects.cs:196 — currently `Action?`. Per spec, should be `ActionGroup?` to support recursive
search-then-action trees.
**Fix:** Change type, update all usages/serialization.
- [x] Done
---
### 9. `ApplyOnEventEffect.Effects` should be recursive tree
Effects.cs:479 — currently `Effect[]`. Should be an action/effect tree, not a flat effect array.
**Fix:** Change `Effect[] Effects` to `Action[] Actions` (ActionGroup wrapping supported by
Action model), update engine `ApplyOnEvent` handling.
- [x] Done
---
## Missing Tooling
### 10. EffectsJsonCutover tool missing
Phase 2 migration dropped `EffectsJson` but no conversion tool exists to rewrite existing card
JSON (pre-revamp AbilitiesJson shape) to the new ability shape.
`SOR.Tools/Migrations/EffectsJsonCutover.cs` was planned but not created.
**Fix:** Create the conversion tool. Read cards with legacy ability format, map to new
ActionGroup/CostGroup shape, write back.
- [x] Done
---
### 11. AbilityBuilder is still form-style (Phase 4 canvas not built)
AbilityBuilder.razor is still a form-based builder. The Phase 4 spec called for a canvas-based
drag/pan/zoom node editor with SVG connection paths, node palette, and nested ActionGroup/CostGroup
editors.
**Fix:** Implement nested sub-group support. Added `ActionGroupDraft` class, `SubGroups` property
on `AbilityDraft`, UI section for sub-groups in each ability, `Compile()` emits `Groups[]`, and
`ParseJson` loads `Groups[]` back into `SubGroups`.
- [x] Done
---
## Summary Table
| # | Item | File(s) | Status |
|---|------|---------|--------|
| 1 | Fix misplaced `[PolyType]` attrs | Effects.cs | [x] |
| 2 | SpiritToken guard in prebuilt/starter deck handlers | BazaarBuyPrebuiltDeckHandler.cs, CollectionSelectStarterDeckHandler.cs | [x] |
| 3 | Wire CostGroup payment in ActivateAbility | AbilitySystem.cs | [x] |
| 4 | PendingInteraction envelope (ActionGroupPick, BranchPick, etc.) | GameState.cs, handlers | [x] |
| 5 | Phase 5 engine switch cases | AbilitySystem.cs | [x] |
| 6 | ActionGroup recursion in GetEffectiveActions | AbilitySystem.cs | [x] |
| 7 | ChooseOne ChooserRole + TargetSelector.Chooser | AbilitySystem.cs | [x] |
| 8 | SearchDeckEffect.ThenAction → ActionGroup? | Effects.cs | [x] |
| 9 | ApplyOnEventEffect.Effects → recursive tree | Effects.cs | [x] |
| 10 | EffectsJsonCutover tool | SOR.Tools/ | [x] |
| 11 | Canvas AbilityBuilder — nested sub-group support | AbilityBuilder.razor | [x] |