card-game Checked

# Pseudocode. A card is in exactly one zone at a time; moving = remove here, add there.
def draw(n):
    for _ in range(n):
        if not deck:
            if not discard:          # truly empty: deck-out (lose, or take fatigue)
                on_deck_out(); return
            deck.extend(discard)     # reshuffle discard into deck
            discard.clear()
            shuffle(deck, rng)       # use a seeded RNG (see save-systems for replays)
        hand.append(deck.pop())

### 2. Card as data + effect resolution

# Pseudocode. Effects are a data list interpreted by the engine — not bespoke code per card.
card = {
    "id": "fireball", "cost": 3, "type": "spell",
    "effects": [ {"op": "damage", "amount": 6, "target": "chosen_enemy"} ],
}
def play(card, caster):
    if resources[caster] < card.cost: return False     # can't afford
    resources[caster] -= card.cost
    move(card, from_zone=hand, to_zone=play_or_discard(card))
    for fx in card.effects:
        resolve_effect(fx, caster)                      # one interpreter handles every card
    return True

### 3. Turn structure as a phase machine

# Pseudocode. Fixed phases keep timing windows (triggers, priority) unambiguous.
PHASES = ["untap", "draw", "main", "combat", "end"]
def take_turn(player):
    for phase in PHASES:
        enter_phase(player, phase)        # fire "on_phase" triggers here
        if phase == "draw":   draw(1)
        if phase == "main":   await player_plays_cards()
        if phase == "combat": resolve_combat()
        if phase == "end":    discard_to_hand_limit(player); clear_temporary_effects()

Pitfalls / failure modes

• **A card existing in two zones at once** → duplication/loss bugs. Enforce "exactly one zone";

move = remove-then-add, and assert no card appears twice.

• **Forgetting to reshuffle** → draws silently fail or crash on empty deck. Reshuffle discard,

or define deck-out/fatigue explicitly (Pattern 1).

• **One function per card** → unmaintainable and untestable. Make effects **data** interpreted

by a small set of operations (Pattern 2).

• **Ambiguous effect order / simultaneous triggers** → nondeterministic outcomes. Resolve in a

defined order (a queue or stack); document LIFO vs. FIFO (refs).

• **Unseeded shuffle in a game that needs replays/undo** → can't reproduce. Use a seeded RNG.
• **No hand limit / no answers** → degenerate hoarding or unbeatable threats. Add a hand cap and

ensure removal exists for every threat archetype.

• **Targeting state leaks** → a cancelled play leaves the board mid-targeting. Make play

atomic: validate cost + targets first, then commit.

Composition (build it from these skills)

• **Card content:** godot-resources / unity-scriptableobjects — define each card as a data asset.
• **UI:** game-ui-ux for layout, scaling, and focus navigation; godot-ui-control for hand layout, drag/drop, zone counts, and targeting prompts.
• **Persistence/replays:** save-systems for collection, run state (roguelike deckbuilder), and seeded replays.
• **Opponent AI:** game-ai for an AI that evaluates playable cards and picks targets.
• **Animation/feedback:** the engine animation skill for card movement; audio-design for cues.
• **Scripting:** godot-gdscript / unity-csharp-scripting for the effect interpreter.

References

• For the effect queue/stack, keywords/triggers, targeting, deckbuilder vs. constructed

archetypes, and shuffle fairness, read references/effect-resolution.md.