card-game

Q: How do I install card-game?

Run npx skills add https://github.com/gamedev-skills/awesome-gamedev-agent-skills --skill card-game in your project. The skills CLI detects the agents you use and copies the skill into the right folder. For Claude Code you can also place the skill folder at ~/.claude/skills/card-game/ (personal) or .claude/skills/card-game/ (project).

by gamedev-skillsMedia & Creative

Build a card game: card data, deck/hand/discard zones, draw/shuffle/reshuffle, a turn structure, costs, and effect resolution. Use for a deckbuilder, TCG/CCG, or roguelike deckbuilder.

Installs: 6.4K
Last 24h: +324
Trending rank: #911
Security: Pass

Install

Works with every agent the skills CLI supports.

npx skills add https://github.com/gamedev-skills/awesome-gamedev-agent-skills --skill card-game

01
Install
Run the command in your project. The CLI asks which agents to install for.
02
Describe the task
Ask your agent for something this skill covers. It loads card-game automatically when relevant.
03
Review the result
The agent follows the SKILL.md steps, scripts and references bundled with the skill.

Security audits

Independent scans of the skill's instructions and bundled files.

Gen Agent Trust Hub PassSAFE ·The card-game skill provides architectural guidance and pseudocode for game development. It is safe and follows best practices for data-driven game logic.

Socket PassNo alerts

Snyk PassLOW ·Risk: LOW · No issues

SKILL.md

The instructions your agent reads when the skill is triggered.

Card Game

A playbook for card games — card data, the deck/hand/discard zones, the turn structure, and how card effects resolve. This is a compositional skill: it models cards as data and wires them to UI. It does not re-teach data assets or UI nodes; it defines the zone model, the draw machinery, and the effect-resolution rules that keep a card game correct and bug-free.

When to use

Use when building any game where the core objects are cards moving between zones (deck → hand → play → discard): deckbuilder, TCG/CCG, solitaire, roguelike deckbuilder.
Use when designing draw/shuffle/reshuffle, turn structure, card costs, or how effects resolve.

When not to use: board/tile state with matching rules → puzzle. RPG with an incidental card battler → start from rpg. For defining cards as assets, use godot-resources / unity-scriptableobjects; for the hand/drag UI, use godot-ui-control.

Core loop

Draw to your hand → spend resources to play cards → effects resolve and change the board → end the turn (cleanup/discard) → opponent/next phase → repeat until a win condition. Depth comes from the combinations a hand allows; the engine's job is to resolve them unambiguously.

Must-have systems

Card data — id, name, cost, type, text, and an effect spec (data, not code).
Zones — deck (draw pile), hand, play/board, discard, exile/removed; cards live in exactly one.
Draw + shuffle + reshuffle — draw from deck to hand; reshuffle discard into deck when empty.
Turn structure — phases (untap/draw/main/combat/end) as a state machine.
Resource system — mana/energy/actions that gate how much you do per turn.
Effect resolution — apply a card's effects in a defined order; handle targets and triggers.
Win/loss condition — life total, deck-out, objective.
UI — hand layout, drag/drop or tap-to-play, zone counts, targeting affordances.

Design knobs

Knob	Effect	Notes
Starting hand / draw-per-turn	tempo, consistency	More draw = less variance.
Hand size limit	hoarding vs. use	Discard down at end of turn.
Deck size (min)	consistency	Smaller = more reliable combos.
Resource curve	what's playable when	"Mana curve" paces power.
Card rarity / power budget	balance	Stronger cards cost more / are rarer.
Determinism vs. randomness	skill vs. swing	Shuffle + random effects add variance.
Reshuffle rules	deck-out, fatigue	Reshuffle discard, or punish empty deck.
Removal / answers	counterplay	Every threat needs an answer in the pool.

Patterns

1. Zones + draw with automatic reshuffle

# 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, chosen_targets):
    # Validate everything first; a failed check must leave zones and resources untouched.
    if resources[caster] < card.cost: return False      # can't afford
    if not targets_legal(card, chosen_targets): return False
    resources[caster] -= card.cost                      # commit: pay, then move, then resolve
    move(card, from_zone=hand, to_zone=play_or_discard(card))
    for fx in card.effects:
        resolve_effect(fx, caster, chosen_targets)      # 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 instance (not the engine's global one) and save its state with the run; see refs §6 for the per-engine calls.
Off-by-one in the shuffle's random index → some orders never occur (a biased deck). Engine ranges differ: Godot randi_range(a, b) and Phaser RND.between(a, b) include b; Unity Random.Range(int, int) excludes it.
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.

FAQ

What does the card-game skill do?

Build a card game: card data, deck/hand/discard zones, draw/shuffle/reshuffle, a turn structure, costs, and effect resolution. Use for a deckbuilder, TCG/CCG, or roguelike deckbuilder.

How do I install card-game?

Run npx skills add https://github.com/gamedev-skills/awesome-gamedev-agent-skills --skill card-game in your project. The skills CLI detects the agents you use and copies the skill into the right folder. For Claude Code you can also place the skill folder at ~/.claude/skills/card-game/ (personal) or .claude/skills/card-game/ (project).

Which AI agents can use card-game?

Any agent that supports the open Agent Skills format (a folder with a SKILL.md file), including Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, Windsurf, Cline, OpenCode and more.

Is card-game safe to install?

Security partners have reviewed it: Gen Agent Trust Hub passed; Socket passed; Snyk passed. As with any skill, read the SKILL.md and bundled scripts before installing.

Who maintains card-game?

It is published by gamedev-skills in gamedev-skills/awesome-gamedev-agent-skills. It has 6,393 recorded installs.