Add Team Rules While Keeping Dice Choices Intact

Add team play to a dice-building roguelike while preserving modified dice, outcome choices, run state, and solo rules. Plan a reversible, testable patch.

Seele Editorial TeamUpdated November 16, 2026

A team-based ruleset can turn a dice-building roguelike into a cooperative decision game, but it reaches into dice ownership, upgrades, rerolls, outcome choice, run state, and random generation. Preserve the existing roll-modify-choose loop first. Define which state is shared, add one bounded co-op mode, and compare it with a known solo run before changing the rest of the game.

Two fictional adventurers compare a shared dice pool and personal upgrade tracks before a roguelike run.
Ember Relay and its players and dice are fictional; no game was tested.

This is an existing-project continuation guide, not a report of an implemented feature. The characters, rules, sample run, seed, and test outcomes are invented. No source code, build, or actual match was available, so every check below is proposed and still needs execution in the real project.

Map the existing dice loop and state owners

Before changing code, make a clean branch or copy and record how a run works today. Trace the roll, die modification, outcome selection, resource payment, encounter resolution, and reward update. Identify the component that owns each value and whether it survives a room, floor, run, or save. If the game cannot be launched, distinguish code inspection from runtime evidence.

For each state field, decide whether its current owner is a player, a die, the team, an encounter, or the run. A co-op ruleset can share a currency or let players discuss a reward while keeping each character’s dice and upgrades separate. It should not leave ownership implicit; otherwise a reroll or lost resource may be charged twice or disappear after the active player changes.

StateOwnership questionProtect the current mode
Dice and modificationsWho owns the die and its upgrades?Keep solo roll semantics unchanged
Reroll or modify costPersonal pool or team pool?Preserve existing payment order
Outcome selectionActive player, vote, or leader?Keep outcome options deterministic per scenario
Health and rewardsShared run total or per-player value?Do not alter current campaign saves
Turn ownershipWho acts and when does control pass?Retain encounter resolution authority

In the fictional Ember Relay example, the team shares one route resource, each adventurer keeps a personal die set, and the active player proposes a result while both players can spend a once-per-encounter assist. These choices are illustrative only. A real project should start from its existing ownership model and change the smallest amount needed to create the intended cooperation.

Preserve the roll-modify-choose sequence

Do not replace a working dice engine to add a team option. Keep the current order of rolling, modifying faces, paying costs, and selecting the outcome. Add the team rule at the narrow point where the game already commits to ownership or choice. This makes it possible to inspect whether a mismatch comes from turn flow, resource ownership, or the existing die resolver.

A fictional game flow shows dice rolling, a modification step, and a shared team outcome choice.
Team coordination can wrap the current dice sequence instead of replacing it.

Write the rule precedence down. For example: a player ability may modify their own die, a team token may affect one chosen result, and the encounter then resolves the selected outcome. State whether a team effect applies before or after personal upgrades, whether it can stack, and what happens when the target die is unavailable. Avoid adding a general modifier system for future modes before the first team use case is clear.

Godot’s stable RandomNumberGenerator documentation describes per-instance seed and state, and notes that the same seed produces a reproducible pseudo-random sequence. That is an engine-specific capability, not proof that a target game uses it, stays deterministic across engine versions, or is balanced. Trace the game’s real random generator before choosing a test strategy. Keep editorial suggestions about deterministic fixtures separate from verified implementation claims.

Define one small, versioned team ruleset

Keep rule data separate from game execution. A compact ruleset might identify the mode, schema version, player count, turn order, resource ownership policy, outcome selection policy, and a small list of supported team effects. Prefer explicit enums and bounded values over free-form scripts. The rules engine should reject options it does not understand rather than quietly ignore them.

Use a default that preserves the shipped mode. The team rules should be opt-in and stored separately from existing campaign progression unless the project requirements explicitly call for a migration. If older saves do not include mode data, document a deliberate compatibility default and test against copied saves. Godot’s saving tutorial demonstrates selecting persistent fields and serializing them in one engine example; it does not establish a universal run-save design.

For user-authored or configurable rules, validate schema version, known player identifiers, resource policy, effect IDs, turn bounds, and the presence of required defaults before starting. Keep display names separate from rule identifiers. Save a custom ruleset as a draft and avoid mutating built-in presets when a player experiments.

Make the cooperation decision visible

Team play should create a meaningful choice. If one player can always choose the outcome, the other may become a spectator; if every choice requires a vote, the flow may stall. Decide when players may discuss, whether the active turn owner commits, whether a tie has a defined fallback, and how the game behaves when a player disconnects if multiplayer already exists. Do not promise networked co-op if the current game has only local turns.

Expose shared and personal resources with different visual grouping. Before a team effect is spent, show who pays and which dice or outcome it can affect. After resolution, show what changed and who owns the resulting upgrade. Make the solo option remain available, and keep team-only rules out of the ordinary mode’s menus unless clearly labeled.

Plan minimal changes and a rollback

Ask AI to inspect the actual files and propose a file-by-file patch before editing. A first slice might involve a ruleset model, a mode-selection hook, a team ownership adapter around the current result choice, and focused tests. Preserve die faces, modification algorithms, core encounter resolution, solo balance values, and old save readers unless project evidence demonstrates a necessary change.

Set an allowlist and require the complete diff. Unexpected edits to every die, reward table, run manager, or existing game mode should pause implementation. Make a clean commit before applying the patch. If the chosen team data shape requires a campaign save migration, split that risk out and test on copies instead of rolling it into an unreviewed feature change.

Likely scopePossible additionKeep untouched by default
RulesetOne versioned team mode definitionShipped solo preset
OwnershipMap player and team resource IDsDie modification rules
ChoiceOne team outcome decision stepBase roll and encounter resolver
SaveOptional mode field with fallbackExisting progression keys
TestsTeam ownership and solo regression casesProduction reward tables

Test seeded runs and solo regression

Use the test mechanism supported by the real project. If it has a seeded generator, record the seed, game version, player order, and actions. If it does not, use deterministic fixtures or a documented sequence of test dice rather than pretending a random run can be replayed. The same visible roll is only one checkpoint in the behavior; also verify modifications, cost, choice ownership, and final state.

A fictional dice roguelike mockup places two player boards beside a test checklist and a separate solo mode marker.
Illustrative test plan only; no RNG stream or multiplayer behavior was tested.
Proposed checkActionEvidence to collect
Solo baselinePlay a known sequence under existing rulesBuild, run state, roll and outcome trace
Team ownershipSpend a shared resource and a personal rerollBefore/after values and owner IDs
Turn orderSwap who acts first in the same fixtureExpected order and selected outcome
Invalid rulesLoad missing or unknown rule identifiersSafe refusal and actionable message
Save compatibilityOpen a copy of a prior solo runDocumented fallback and preserved progress
RollbackRestore the clean baseline branchOriginal solo loop remains available

This is a proposed matrix, not test evidence. Record what actually happened when it is run: project version, ruleset version, seed or fixture, player order, state before and after each choice, and any difference from the solo baseline. A fictional table image cannot verify RNG reproducibility, team ownership, balance, or save compatibility.

Keep balance claims within evidence

A mode can be mechanically consistent and still produce repetitive or unfair decisions. Use playtests across representative roles, dice builds, and encounter types before making claims about balance. Track which players contribute to decisions, whether assistance is worth its cost, and whether a team resource trivializes a challenge. Do not label a configuration balanced based only on a code review or a handful of invented examples.

To explore a separate dice-building roguelike concept, try SEELE AI Game Maker. It is a concept tool, not an existing-project editor.

Frequently asked questions

What should a team-based dice roguelike ruleset define?

Define whether dice, upgrades, health, currency, and route choices belong to each player or the team. State who chooses a roll outcome and how turns resolve. Start with one cooperative rule change and avoid mixing shared resources with existing solo progression by accident.

How can I keep existing dice modification mechanics intact?

Preserve the current roll, modify, and choose sequence as a baseline. Add team ownership around the resulting state rather than replacing die faces or reroll rules. Compare a known solo run and check that its choices, costs, and results stay consistent after the patch.

Should teammates share one dice pool or keep separate dice?

Choose based on the game’s existing ownership model and the cooperative decision you want. A shared pool can make turns collaborative, while separate pools preserve individual builds. Document how upgrades, rerolls, and losses apply, then test both player orderings before expanding the rules.

How should I test random dice outcomes?

Use recorded seeds or another project-supported deterministic fixture when available, and keep the random generator boundary explicit. Run the same scenario before and after the team rules change. A seeded sequence can aid reproduction, but it does not prove balance or identical behavior across engine versions.

Can AI add cooperative rules to my existing dice game?

AI can inspect supplied files, map the current state flow, and suggest a bounded patch and test matrix. It cannot confirm compatibility without your code and executed runs. Provide a file allowlist, sample run, expected ownership rules, and rollback commit, then review every changed file.

Add team play around the proven dice loop

Map ownership first, define one versioned team ruleset, and add a clear shared decision without replacing the current roll-modify-choose sequence. Keep the solo mode and old saves protected. Test team state, player order, and regressions on a project copy, then retain a concrete rollback path. Treat unrun checks and fictional examples as proposals.

Sources

SEELE AI

Turn this guide into a playable build.

Start with a focused brief, then iterate in the Seele AI Workspace.

Start creating