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.

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.
| State | Ownership question | Protect the current mode |
|---|---|---|
| Dice and modifications | Who owns the die and its upgrades? | Keep solo roll semantics unchanged |
| Reroll or modify cost | Personal pool or team pool? | Preserve existing payment order |
| Outcome selection | Active player, vote, or leader? | Keep outcome options deterministic per scenario |
| Health and rewards | Shared run total or per-player value? | Do not alter current campaign saves |
| Turn ownership | Who 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.

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 scope | Possible addition | Keep untouched by default |
|---|---|---|
| Ruleset | One versioned team mode definition | Shipped solo preset |
| Ownership | Map player and team resource IDs | Die modification rules |
| Choice | One team outcome decision step | Base roll and encounter resolver |
| Save | Optional mode field with fallback | Existing progression keys |
| Tests | Team ownership and solo regression cases | Production 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.

| Proposed check | Action | Evidence to collect |
|---|---|---|
| Solo baseline | Play a known sequence under existing rules | Build, run state, roll and outcome trace |
| Team ownership | Spend a shared resource and a personal reroll | Before/after values and owner IDs |
| Turn order | Swap who acts first in the same fixture | Expected order and selected outcome |
| Invalid rules | Load missing or unknown rule identifiers | Safe refusal and actionable message |
| Save compatibility | Open a copy of a prior solo run | Documented fallback and preserved progress |
| Rollback | Restore the clean baseline branch | Original 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.


