One of the stranger advantages of making games after spending years around machine learning is that you develop an unhealthy desire to turn apparently simple questions into datasets.
How much health should the Gravedigger have? How quickly should enemies reach him? How many enemies should Grave Sweep kill? How often should the player level up? How much stronger should Burial Slam be than the normal attack? How much healing can exist before taking damage stops mattering?
The traditional answer is, correctly, play the game.
But there is another useful answer: make the computer play it ten thousand times first.
This is not an AI playing the game
Monte Carlo simulation is not a magic system that watches the screen and announces the correct balance. We build a simplified mathematical version of a run. It knows things like player health, attack damage, attack cadence, enemy health, enemy speed, incoming pressure, upgrade choices, healing opportunities and how the Bells increase the problem.
Then we vary them. One simulated Gravedigger might play aggressively. Another keeps distance. Another makes coherent upgrade choices. Another assembles something unfortunate. One gets Iron Burial. Another chooses Ossuary. Another spends half the run at low health under Blood Rite.
Ten thousand simulated nights are considerably cheaper than ten thousand actual nights.
The useful part is not finding “the answer”
Suppose we are deciding whether Grave Sweep should do 30, 34 or 38 damage. At first glance, changing four points sounds trivial. It is not.
That number interacts with enemy health breakpoints. Those breakpoints change how many attacks it takes to kill something. That changes how long enemies remain close enough to attack. That changes incoming damage. That changes survival time. Survival time changes XP gained. XP changes the number of upgrades. Upgrades change damage again.
Game balance is less about finding a perfect number than discovering which numbers make the whole system behave sensibly.
A simulation lets us compare thousands of versions of that chain quickly. We can test combinations of player HP, stamina, damage, enemy health, enemy speed, spawn pressure, XP curves, healing and build strength and start discarding entire regions of bad ideas.
Too generous? Almost everybody survives regardless of build. Too brutal? Most runs collapse before anything interesting has time to happen. Too much healing? Damage becomes temporary decoration. Too little progression? The player reaches the final Bell still holding essentially the same shovel they started with.
The player is not an equation
There is an obvious problem with all of this. Humans are weird.
A mathematical Gravedigger does not panic because twenty Restless Dead suddenly appear from behind a tree. It does not miss. It does not discover an absurd strategy we failed to anticipate. It does not chase an optional encounter while sitting at 14 health because there might be something shiny inside.
It also cannot tell us that an attack technically performs well but feels terrible.
So simulation is not the authority. It is a filter. We use it to find promising ranges, obvious failures and suspicious interactions. Then those numbers go back into Unity and face the much less cooperative testing instrument known as a human being.
Builds make the problem much worse
A normal action game might ask us to balance one attack against one enemy. A roguelite asks what happens when the attack becomes wider, gains another follow-up swing, starts throwing Bones, hits enemies into scenery, triggers something on Overkill and is then transformed again by a Bell Omen.
This is where simulation becomes especially useful. We can sample different build strategies rather than testing only an imaginary “average” build.
- Does Iron Burial consistently become too strong?
- Does Ossuary take too long before Bones become useful?
- Does Blood Rite create a death spiral or make survival trivial?
- Do coherent builds substantially outperform random ones?
- Can hybrid builds still work?
- Does one card appear in every successful run?
The simulation does not decide whether those things are fun. It tells us where to look.
It also catches bugs wearing balance costumes
If an upgrade is supposed to stop appearing after reaching its maximum rank, ten thousand simulated selections provide a lot of opportunities for it to misbehave. If an eligibility rule produces an impossible card combination, we see it. If some multiplier eventually becomes infinite, we would rather discover that in a report than during Bell IV with seventy undead on screen.
Progression-state failures are not “balance.” They are bugs. Bugs occasionally become very convincing game-design discussions if nobody catches them early enough.
So machine learning made our shovel better?
Indirectly. The useful inheritance is less glamorous than that. It is knowing how to frame a question, parameterise a system, run many controlled experiments, look at distributions instead of one lucky result, and distrust a beautiful average when the failures underneath it are horrible.
That mindset transfers surprisingly well to games.
We still have to swing the shovel. We still have to watch enemies move. We still have to decide whether Burial Slam produces the appropriate amount of dirt.
But before we ask someone to spend twenty minutes discovering that our newest balance idea was mathematically doomed from the beginning, we can now kill several thousand imaginary Gravediggers first.
The Bureau considers this a significant improvement in working conditions.