A second playable faction can give a marble auto-battler a fresh strategy layer, but it can also affect launch rules, collision behavior, round timing, and the match resolver. Begin by preserving the current faction and shared arena simulation. Define asymmetry through a small set of visible choices or bounded abilities, then test one matchup before expanding to other arenas.

This article describes a proposed way to extend an existing game. No project, physics setup, build, or match logs were available. The faction designs and test cases are invented examples; nothing here should be read as a measured balance result or verified implementation.
Record the current faction and match loop
Start from a clean branch or copied project. Trace how a round starts, which player chooses a launch, which configuration controls the marble and arena, how the match advances, and what determines the outcome. Record the current faction’s options and inspect the actual collision shapes, physics materials, mass, launch force, arena geometry, and simulation settings before suggesting any changes.
Godot’s RigidBody3D documentation describes the class as implementing full 3D physics and notes that properties such as mass can affect simulation behavior. This is a narrow engine reference, not proof of what the target game uses. A marble auto-battler may use a custom solver or a different engine entirely. Verify the real project’s simulation path rather than assuming an engine-specific component.
| Existing behavior | Baseline to capture | Protect by default |
|---|---|---|
| Round flow | Turn order, launch phase, resolution trigger | Shared match state transitions |
| Marble simulation | Shape, mass, surface, impulse, arena | Existing physics and collision rules |
| Faction choices | Available launch or tactical actions | Current faction and its legal options |
| Outcome | Scoring, tie, reset, and reward rules | Result calculation and progression |
Ask AI to map the files it actually sees and identify the one place where faction data enters the match. Require a proposal that lists allowed edits and untouched systems before code changes. If the model invents an arena file, component, or resolver that does not exist, stop and clarify the project structure instead of accepting a speculative patch.
Make asymmetry visible through player decisions
A faction can feel distinct without changing the shared marble physics. One could choose among launch lanes; another could place a single route marker before a round. The differences should be visible before a match and bounded by clear uses, timing, target rules, and reset behavior. A player should be able to explain why the choice matters without needing hidden collision bonuses.
In the fictional Cinder Circuit example, the Ember Guild chooses a launch lane and the Tide Cartographers can mark one gate per round. Both factions use the same marble geometry and track. These rules are invented teaching examples, not an implemented balance proposal. The point is to test whether a tactical choice creates identity before adding physics modifiers.

Define a faction record with a stable ID, display name, allowed abilities, usage limits, and any setup prompts. Keep cosmetic assets and rule effects separate. If an ability changes force, spin, mass, or collision response, treat it as a physics feature with its own regression scope, not as a harmless faction field.
Keep faction configuration out of shared physics
Pass validated faction configuration into the existing match setup, then let the current round and simulation code remain in charge. Avoid duplicating the arena, marble class, collision solver, or result logic just to support a second faction. A clear adapter is easier to review than two nearly identical match paths that can drift.
State when faction abilities apply: before launch, once per round, during a defined action window, or after the result. Specify what happens if a target gate is absent, a player skips a choice, or a round restarts. The system should reject unsupported ability IDs rather than silently applying a fallback that changes the expected result.
If the project uses randomness, trace the actual generator and capture a supported seed or fixture for repeatable tests. Godot’s RandomNumberGenerator documents per-instance seed and state, and says a given seed produces a reproducible sequence. That does not guarantee deterministic physics, identical results across engine versions, or reproducibility in an unrelated target game. Record the engine and project version with any replay comparison.
Plan one limited, reversible vertical slice
Pick one representative arena and one matchup. Add the second faction to the existing selection flow, configure its one bounded ability, and use the current resolver and shared track. Do not retrofit every map, tutorial, AI opponent, ranking mode, and campaign save in the first patch. A narrow slice reveals which systems actually depend on faction identity.
Ask AI to list candidate files for the selection data, faction configuration, one UI prompt, and focused tests. Keep an allowlist. Existing marble physics, collision layers, launch values, score calculation, round ownership, and original faction data should remain unchanged unless inspection demonstrates a specific dependency. Capture a baseline commit before accepting edits.
| Feature slice | Potential edit | Unchanged reference |
|---|---|---|
| Faction entry | One faction definition and visible icon | Current faction settings |
| Ability prompt | One selection before launch | Round start and turn order |
| Arena use | One marked gate or lane choice | Marble shape and collision setup |
| Resolution | Pass validated config to current flow | Shared outcome resolver |
| Tests | Same arena, swapped player order | Existing faction baseline |
Review the complete diff, including serialized data and inspector defaults. Ask AI to explain each new value and the removal procedure. If the patch edits physics values, do not accept it as part of the same small rule change; isolate it and add the tests needed to evaluate the physics consequences.
Test matchups and rollback
Run the original faction against itself on the reference arena, then compare each faction in both player orders. Check ability limits, round reset, missing targets, skipped selection, and same-seed or fixture behavior when the project can provide it. Do not infer balance from one win or an appealing visual mockup. Gather enough real matches for the project’s design question before making a public balance claim.

| Proposed check | Action | Evidence to record |
|---|---|---|
| Original regression | Replay the original faction on the reference arena | Project version, setup, launch and outcome |
| Order swap | Swap factions between player slots | Order, options, and observed result |
| Ability limit | Attempt to use the ability twice in one round | Expected rejection or reset rule |
| Missing target | Use the ability on an arena without its target | Safe message or defined fallback |
| Repeatability | Replay a recorded seed or fixture | Seed, engine version, state trace |
| Rollback | Restore the baseline commit | Original match flow remains selectable |
This matrix is a proposal, not executed evidence. Record the version, arena, faction IDs, player order, random seed or fixture, ability choices, observed state, and outcome for each actual test. If a new faction changes simulation settings unexpectedly, compare the diff first and revert to the clean baseline before widening the change.
Keep balance claims tied to play data
Asymmetric choices can be interesting while still producing a dominant faction or an unavoidable opening. Test representative arenas, player orders, and skill levels. Track win/loss and the choices that led there, but also inspect whether an ability had a meaningful counterplay. Label early results as limited observations, not proof of fairness. A faction that changes physical properties may need a much broader test plan than one that changes only setup options.
To explore a separate marble auto-battler concept, try SEELE AI Game Maker. It is a concept tool, not an existing-project editor.
Frequently asked questions
What makes a faction asymmetric in a marble auto-battler?
Give each faction a distinct decision or ability, such as choosing a launch lane or once-per-round path marker, while keeping the shared match rules understandable. Asymmetry should create different planning choices, not rely on hidden changes to marble physics that players cannot read.
Should a new faction change marble mass or friction?
Only change physical properties when the design explicitly requires a different marble feel and the existing simulation can support it. First try faction-specific setup choices or bounded abilities. If physics changes are necessary, isolate them and test collisions, launch behavior, and resolution across the actual target builds.
How can I preserve the existing faction and match flow?
Capture the current faction’s round sequence, arena, launch inputs, collision settings, and outcome rules. Add the new faction behind a separate configuration and keep the shared resolver unchanged. Compare a known baseline matchup before changing more arenas or rewriting the simulation.
How do I test an asymmetric faction fairly?
Use representative arenas and repeated matchups, swap player order, and record faction configuration, seed or fixture, and observed outcomes. Check ability limits and interactions as well as wins. A planned test matrix or one seeded replay is not proof of balance or cross-platform determinism.
Can AI add a new faction to my existing marble game?
AI can inspect supplied project files, propose a bounded faction configuration, and draft regression cases. It cannot prove the physics or faction balance without the actual project and executed matches. Provide a file allowlist, reference matchup, expected ability rules, and rollback commit, then review the complete diff.
Add faction identity without replacing the simulation
Capture the current arena and faction behavior, define a small visible ability, and pass validated configuration into the existing match flow. Keep physics, round resolution, and the original faction unchanged by default. Test the same arena and swapped player orders, record actual outcomes, and keep a baseline commit ready so the new feature can be removed safely.


