Bug Tracking for Deckbuilding Roguelikes

Deckbuilding roguelikes, the wildly popular genre of building a deck of cards over a procedurally-generated run, combine two bug-rich systems: the card-combo interactions of a deckbuilder, where cards synergize in a vast combinatorial space, and the procedural runs of a roguelike, where each run generates different cards, relics, enemies, and events. The bugs come from both and from their combination, a card interaction that breaks, a run that generates a problematic situation, a relic-and-card synergy that produces an infinite loop or a broken state. Capturing both the deck and the run seed is the key. Tracking deckbuilding roguelike bugs means capturing that combined card-and-run context.

Two bug-rich systems combine

A deckbuilding roguelike fuses two systems that each generate bugs and that together compound: the deckbuilder, where the player builds a deck and the cards interact and synergize in a vast combinatorial space, like any card game, and the roguelike, where each run is procedurally generated with different cards, relics, enemies, and events. The combination is the genre appeal, building a powerful synergistic deck over a procedural run, and it is doubly bug-rich, since the card interactions and the procedural generation each produce bugs and their combination produces more.

The bugs come from both systems and their intersection: a card-combo interaction that breaks, as in any deckbuilder, a procedural run that generates a problematic situation, as in any roguelike, and crucially a combination, a relic that interacts with a card to produce an infinite loop, a generated situation that breaks a card interaction, the kind of emergent bug that the two systems compounding create. Understanding that deckbuilding roguelikes combine two bug-rich systems, with bugs from the card interactions, the procedural runs, and their compounding combination, frames the bug tracking: capture both the deck and card state and the run seed and generation, since the bugs span both.

Capture the deck and card interactions

The deckbuilder half depends on cards and their interactions, so capture the deck and the card-interaction context, the deck list, the cards in play and hand, the relics and other modifiers, and the interaction that occurred, since a card-combo bug emerges from the specific cards and their interaction, like any deckbuilder. Capture the deck and the relevant card and relic state when an interaction bug is reported.

Relics and other run modifiers are especially important in deckbuilding roguelikes, since they modify the cards and create powerful synergies, and a relic-and-card interaction that breaks, produces an infinite loop, or generates a broken state is a characteristic bug, like the combo bugs of a deckbuilder amplified by the relics. Capture the relics and synergies in play with the deck and cards, so a card-and-relic interaction bug becomes diagnosable, revealing the combination that broke. Capturing the deck and card interactions, including the relics and synergies, covers the deckbuilder half, where the card-combo and relic-synergy bugs live, providing the card-and-modifier state from which an interaction bug emerged.

Capture the run seed and state

The roguelike half depends on procedural generation, so capture the run seed and the run state, the seed that generated the run, the path taken, the current point in the run, the relics, cards, and resources accumulated, since a run bug or an emergent bug depends on the procedural run and reproducing it requires regenerating the run, like any roguelike. Capture the seed and run state when a bug is reported.

If your run generation is deterministic from a seed, the seed regenerates the same run, and the run state, the path, the accumulated cards and relics, the current situation, lets you reach the point where the bug occurred, much as you would replay a roguelike seed to a depth. With the seed and run state, you can regenerate the run and reach the situation the bug emerged in. Capturing the run seed and state is the foundation for the roguelike half, providing the procedural run and the position in it from which a run or emergent bug emerged, letting you regenerate and reach the situation, which combined with the deck captures the full deckbuilding-roguelike state.

Capture the combat state for the compounding bugs

The compounding bugs, where the card interactions and the run combine, often manifest in combat, where the deck is played against the generated enemies, so capture the combat state when a bug occurs in combat, the board, the cards in play and hand, the enemies and their states, the relics and effects active, since the compounding bug emerges from the deck playing out against the run-generated combat situation. This combat state captures the intersection of the two systems.

The infinite loops and broken states that are the most dramatic deckbuilding roguelike bugs often occur in combat, where a card-and-relic combination, against a particular enemy or situation, produces an unbounded loop or a broken result, the deckbuilder combo bug amplified by the run context. Capture the full combat state, the cards, relics, effects, enemies, so a compounding combat bug becomes diagnosable, revealing the combination of deck and situation that broke. Capturing the combat state for the compounding bugs covers the intersection of the two systems, where the deck interactions and the run situation combine into the emergent bugs that are characteristic of the genre, completing the deck-and-run context.

Setting it up with Bugnet

Add an in-game report option and attach the deck and card state, the relics and synergies, the run seed and state, and the combat state as a serialized snapshot and custom fields. Bugnet stores them so a deckbuilding roguelike bug arrives with the deck-and-run context needed to regenerate the run, set up the deck and combat, and reproduce a card-interaction, run-generation, or compounding bug in the genre doubly-combinatorial space.

Enable automatic crash capture for the infinite loops that crash or hang, and group identical issues into occurrence counts, since when many players hit the same card-relic combination bug, the cluster confirms it and reveals the combination. With the deck and seed captured, a deckbuilding roguelike bug becomes reproducible, letting you regenerate the run, set up the deck and combat, and watch the interaction that broke, which for a genre combining the combinatorial card interactions of a deckbuilder with the procedural runs of a roguelike is exactly the combined context needed to reproduce and fix its compounding emergent bugs.

Build a deck-and-seed regression suite

Because deckbuilding roguelike bugs are reproducible from the deck and seed, and the systems are deterministic, the genre suits a deck-and-seed regression suite, where each captured bug becomes a test that sets up the deck, regenerates the run from the seed, reaches the situation, and asserts the correct result, no infinite loop, correct interaction. A fix can be verified against the exact deck-and-run situation, with deterministic repeatability.

This suite is essential because the genre combines two combinatorial systems, the card interactions and the procedural generation, and a change to a card, relic, or generation can break interactions elsewhere in the vast combined space, often in combinations you did not anticipate, like a deckbuilder and a roguelike compounded. Running the deck-and-seed suite after changes catches these regressions. Over time the suite becomes a collection of the card-relic combinations and run situations your players have created and found bugs in, providing the interaction coverage a deckbuilding roguelike needs to keep its compounding card-and-run systems resolving correctly as you add cards, relics, and content, which the doubly-combinatorial space makes especially valuable.

Deckbuilding roguelikes compound card combos with procedural runs. Capture the deck, the seed, and the combat state.