systemic-game-design-course/course/10-spellgrid/scenarios.md

Module 10 scenarios: SpellGrid

Each heading is a test name. The Rust test lives in tests/rust/test_10.rs and the TypeScript test in tests/ts/test_10.test.ts; both state exactly what is written here.

SpellGrid is the course's own small game: Part I's card engine and Part II's grid engine in one level. The harness adds one constructor, newSpellGrid(level, cards) (Rust: new_spell_grid(level, cards)), returning a SpellGrid:

• Every Part II function works as in Modules 6–9: place, rules, activeRules, hasProperty, move, posOf, kindsAt, step, won, lost.
• The level format gains two optional fields (course/schema/level.schema.json): cards, a list of { card, x, y }, and hand, a list of card names. Each entry of cards is a minion in play for player 0 and a grid object at (x, y) whose noun is the card's "noun" field ("noun": "KEG" makes an object of kind "keg"). Each name in hand is a card in player 0's hand.
• cards (the constructor's second argument) is a list of extra card definitions, added to the course's cards. Every test here passes an empty list.
• One id space: a minion's id is its grid object's id. place, posOf, hasProperty and health all take it, and log() reports it. A hero, or a card that isn't on the grid, gets an id no grid object has.
• cast(card, target?) (Rust: cast(card, Some(target)) or None) casts a spell from player 0's hand, as one Sequence. The card leaves the hand. Casting a card that isn't in the hand is an error, and so is casting a spell that hits a chosen minion (Spark) without a target; neither changes anything.
• play(card, x, y) plays a minion from player 0's hand onto the empty tile (x, y), as one Sequence (Module 4's play: it enters the board, then its Battlecry resolves), and returns its id. Playing onto a tile that holds anything is an error.
• setChooser(choose) is Module 5's: it makes Assemble's choices ("base", "donor", "half").
• health(id), hero(player), nameOf(id), log() and clearLog() are Part I's, with ids translated as above. minionAt(x, y) is the id of the minion on that tile, or null (Rust: Option<Id>). hand() lists the card names in player 0's hand, in order.
• withNaiveAuraTiming() is a test hook (Rust: with_naive_aura_timing()). It reverses the two steps at the end of an outermost Phase, so that the Aura Update runs before the Death Creation Step and not after it. Only test_10_level_3_naive_would_differ calls it.

The three seams between the engines, each tested below:

1. Rules become modifiers. A rule in force <TRIGGER> IS DOUBLE (DEATHRATTLE IS DOUBLE) is a trigger multiplier like Baron Rivendare's (times: 2, stacking: "max"), for every player's minions. DEATHRATTLE IS NOT DOUBLE caps that trigger at one activation, whatever else multiplies it. The rule takes effect at the next Aura Update, like a minion's aura.
2. Hazards mark, the death step removes. A minion that a hazard (or OPEN/SHUT, or X IS NOT X) destroys is marked pending destroy, in one Sequence. Module 3's Death Creation Step removes it, and its Deathrattle resolves.
3. Grid changes reparse. A minion that leaves play leaves the grid, and an effect that writes on the grid (spawnText: "put the word W on this minion's tile") writes there. Both happen when the Sequence ends, and then the rules are parsed again, before anything else.

Casting is not a turn: there is no win check until the next step.

SpellGrid's own cards ("game": "spellgrid" in course/catalog.json; not Hearthstone cards):

Card	Type	Stats	Noun	Text
Powder Keg	minion, 2	1/1	KEG	Deathrattle: Deal 1 damage to all minions.
Bramble Wall	minion, 1	0/3	BRAMBLE	(none)
Thorn Hedge	minion, 1	0/2	HEDGE	(none)
Grave Warden	minion, 3	1/1	WARDEN	Your minions trigger their Deathrattles twice. (Baron-like, with 1 Health)
Ember Moth	minion, 1	1/1	MOTH	Taunt. Deathrattle: Deal 2 damage to the enemy hero. (split 1)
Rune Scribe	minion, 2	1/1	SCRIBE	Deathrattle: Write WIN on this tile. (split 0)
Tin Knight	minion, 2	1/3	KNIGHT	(none)
Spark	spell, 1			Deal 1 damage to a minion.
Graft	spell, 2			Assemble a Deathrattle minion.

Graft is Module 5's assemble effect: the chooser picks a base from the Deathrattle minions among the course's cards, a donor, and a half, and the Assembled minion goes to the hand. It keeps the base's name, stats and noun. Whirlwind ("Deal 1 damage to ALL minions.") is the Hearthstone card from Module 3.

New words: the nouns KEG, BRAMBLE, HEDGE, WARDEN, MOTH, SCRIBE, KNIGHT and DEATHRATTLE, and the property DOUBLE. A sentence like DEATHRATTLE (0,0) IS (1,0) DOUBLE (2,0) is three text objects, as in Modules 6–9.

test_10_spatial_rule_feeds_interceptor

• Setup: a level 6 wide and 3 high with DEATHRATTLE (0,0) IS (1,0) and nothing at (2,0); cards Powder Keg at (0,2) and Bramble Wall at (2,2); hand ["Spark"].
• Assertions 1: activeRules() doesn't contain "DEATHRATTLE IS DOUBLE".
• Action 1: place("text:DOUBLE", 2, 0).
• Assertions 2: activeRules() contains "DEATHRATTLE IS DOUBLE".
• Action 2: clearLog(), then cast("Spark", keg).
• Assertions 3:
  • The log holds exactly two Triggered { source: keg, trigger: "deathrattle" }.
  • health(bramble) is 1: two Deathrattles of 1 damage each.
  • posOf(keg) is null and posOf(bramble) is (2,2).
  • hand() is empty.

test_10_not_cancels_spatial_modifier

• Setup: a level 6 wide and 4 high with DEATHRATTLE (0,0) IS (1,0) DOUBLE (2,0) and DEATHRATTLE (0,1) IS (1,1) NOT (2,1) DOUBLE (3,1); cards Grave Warden at (0,3), Powder Keg at (1,3) and Bramble Wall at (2,3); hand ["Spark"].
• Assertions 1: rules() contains "DEATHRATTLE IS DOUBLE" and "DEATHRATTLE IS NOT DOUBLE"; activeRules() contains "DEATHRATTLE IS NOT DOUBLE" but not "DEATHRATTLE IS DOUBLE".
• Action: clearLog(), then cast("Spark", keg).
• Assertions 2:
  • The log holds exactly one Triggered { source: keg, trigger: "deathrattle" }, although the Grave Warden was in play when the keg died: the negated rule caps the card's aura too.
  • health(bramble) is 2.
  • posOf(warden) is null: the Deathrattle's 1 damage killed it, in the next Death Creation Step.

test_10_grid_and_card_doublers_take_max

• Setup: a level 6 wide and 3 high with DEATHRATTLE (0,0) IS (1,0) DOUBLE (2,0); cards Grave Warden at (0,2), Powder Keg at (1,2) and Bramble Wall at (2,2); hand ["Spark"].
• Action: clearLog(), then cast("Spark", keg).
• Assertions:
  • The log holds exactly two Triggered { source: keg, trigger: "deathrattle" }: the rule's multiplier and the Warden's both have stacking: "max", so together they double, not quadruple.
  • health(bramble) is 1.

test_10_hazard_feeds_death_step

• Setup: a level 5 wide and 4 high with KEG (0,0) IS (1,0) YOU (2,0) AND (3,0) MELT (4,0) and LAVA (0,1) IS (1,1) HOT (2,1); an object lava at (2,3); cards Powder Keg at (1,3) and Bramble Wall at (4,3).
• Action: clearLog(), then step("right").
• Assertions:
  • The log is exactly [Destroyed { id: keg }, DeathPhase { round: 1 }, Triggered { source: keg, trigger: "deathrattle" }, Damaged { target: bramble, amount: 1 }]: the keg melted, as a pending destroy that Module 3's Death Creation Step removed, and its Deathrattle resolved in the Death Phase.
  • posOf(keg) is null, kindsAt(2,3) is ["lava"] and health(bramble) is 2.
  • lost() is true: the keg was the only YOU object.

test_10_spawned_text_triggers_reparse

• Setup: a level 5 wide and 3 high with BABA (0,0) IS (1,0) YOU (2,0) and BABA (0,1) IS (1,1); card Rune Scribe at (2,1), on the empty end of BABA IS; hand ["Spark"]. Then place("baba", 4, 2).
• Assertions 1: rules() doesn't contain "BABA IS WIN".
• Action 1: cast("Spark", scribe).
• Assertions 2:
  • kindsAt(2,1) is ["text:WIN"]: the scribe's Deathrattle wrote WIN on its tile, and the scribe left the grid.
  • rules() contains "BABA IS WIN" and hasProperty(baba, "WIN") is true, straight after the cast: the grid was reparsed when the Sequence ended.
  • won() is false: casting is not a turn.
• Action 2: step("left").
• Assertions 3: won() is true.

test_10_targeted_spell_needs_target

• Setup: a level 3 wide and 1 high with card Bramble Wall at (0,0); hand ["Spark"].
• Action 1: cast("Spark"), with no target.
• Assertions 1: it is an error (Rust: a panic; TypeScript: it throws), and nothing changed: hand() is still ["Spark"] and health(bramble) is 3. Spark's effect hits a chosen minion, so a cast without one would waste the card.
• Action 2: cast("Spark", bramble).
• Assertions 2: health(bramble) is 2 and hand() is empty.

test_10_level_1_solution

Level levels/l1-double-tap.json. The Bramble Wall (3 Health) is STOP and blocks the only way to the flag. Whirlwind and one Powder Keg Deathrattle do 2 damage, one short.

• Inputs: step("up"), step("up") (pushing DOUBLE through the gap in the wall to finish DEATHRATTLE IS DOUBLE), then cast("Whirlwind").
• Assertions 1: activeRules() contains "DEATHRATTLE IS DOUBLE" before the cast. After it, the keg's Deathrattle has triggered twice and posOf(bramble) is null.
• Inputs: step("down"), step("down"), step("left"), step("down"), step("down"), step("right").
• Assertions 2: won() is false, and kindsAt(5,6) is ["baba"]: Baba stands where the bramble was.
• Input: step("right").
• Assertions 3: won() is true.

test_10_level_2_solution

Level levels/l2-spliced-corpse.json. BABA IS ends on a lava tile. MOTH IS PUSH AND MELT is written, but there is no moth: the hand holds only Graft.

• Setup: setChooser answering "Ember Moth" for the base, "Rune Scribe" for the donor and "bottom" for the half.
• Input: cast("Graft").
• Assertions 1: hand() is ["Ember Moth (Assembled)"]: the moth's noun and Taunt, the scribe's Deathrattle.
• Input: play("Ember Moth (Assembled)", 4, 3), returning moth.
• Assertions 2: kindsAt(4,3) is ["moth"], and nameOf(moth) is "Ember Moth (Assembled)".
• Inputs: step("left"), then step("left"), which pushes the moth onto the lava.
• Assertions 3:
  • posOf(moth) is null and kindsAt(2,3) is ["lava", "text:WIN"]: the moth melted and its Deathrattle wrote WIN where it died.
  • rules() contains "BABA IS WIN", and won() is true after that same step: the reparse after the Sequence came before the win check.

test_10_level_3_solution

Level levels/l3-simultaneous-paradox.json. The player is a Tin Knight (KNIGHT IS YOU, 3 Health). The Thorn Hedge (2 Health) is STOP and blocks the flag. The Grave Warden and the Powder Keg have 1 Health each.

• Input: cast("Whirlwind").
• Assertions 1:
  • The keg's Deathrattle triggered exactly once: the Warden died in the same Death Creation Step, and the Aura Update after that step removed its aura before the Death Phase.
  • health(knight) is 1, and posOf(hedge), posOf(keg) and posOf(warden) are null.
• Inputs: step("right") five times.
• Assertions 2: won() is true.

test_10_level_3_naive_would_differ

The same level and the same inputs, on a SpellGrid with withNaiveAuraTiming() called first.

• Assertions:
  • The keg's Deathrattle triggered twice: the Warden's aura was still in the snapshot when the Death Phase began.
  • posOf(knight) is null, lost() is true and won() is false: the second Deathrattle killed the knight along with the hedge. This is the trap the level is built on.