Correlated randomness in Slay the Spire 2

Correlated randomness in Slay the Spire 2 - Andy Tockman

portfolio

music

conlangs

video games

board games

puzzles

square dancing

food

Correlated randomness in Slay the Spire 2 2026-06-13 very long (6880 words) gamesvideo gamesslay the spiremath

Here are three true statements about the game of Slay the Spire 2 (in single player):

If you pick Neow's Bones in the Underdocks, the random curse is ~54% likely to be Debt.*

It is impossible to receive Rebound from the Trash Heap event.

Your first fight is 76% likely to drop a potion in Underdocks, and 4% likely to drop a potion in Overgrowth.**

(* assuming neither of the relics from Neow's Bones is New Leaf or Kaleidoscope)

(** assuming your Neow relic doesn't give cards or other relics)

(*** all on the current beta patch, v0.107.0)

What?!

Why? The culprit is unexpected correlation between different random number generators -- knowing the first output of one of the game's RNGs gives information that helps predict the first output of all of the others.

The random number generators of Slay the Spire 2

For now, I will give an extremely simplified explanation of this correlation. If you want more details, I will go into much greater depth at the end of this post. If you don't care, you can skip this section to see all the funny examples below.

The phenomenon of "correlated RNG" (or "CRNG") is already known in the Slay the Spire community, because Slay the Spire 1 had a similar issue, described in detail in Forgotten Arbiter's blog post.[1]

Briefly, in Spire 1, the game used several distinct pseudorandom number generators, to prevent e.g. randomness within a combat from influencing future card rewards. However, they were all initialized to the same starting state, which meant they produced the same sequence of numbers. A crafty player could therefore pay attention to the results of past random events and gain information about future random events.

In an attempt to avoid the same problem, Spire 2 initializes its pseudorandom number generators to different states. The code looks something like this (highly simplified for didactic purposes):

Rng UpFront = new Rng(seed + hash("up_front")); Rng Shuffle = new Rng(seed + hash("shuffle")); Rng UnknownMapPoint = new Rng(seed + hash("unknown_map_point")); Rng CombatCardGeneration = new Rng(seed + hash("combat_card_generation")); Rng CombatPotionGeneration = new Rng(seed + hash("combat_potion_generation")); Rng CombatCardSelection = new Rng(seed + hash("combat_card_selection")); Rng CombatEnergyCosts = new Rng(seed + hash("combat_energy_costs")); Rng CombatTargets = new Rng(seed + hash("combat_targets")); Rng MonsterAi = new Rng(seed + hash("monster_ai")); Rng Niche = new Rng(seed + hash("niche")); Rng CombatOrbGeneration = new Rng(seed + hash("combat_orbs")); Rng TreasureRoomRelics = new Rng(seed + hash("treasure_room_relics")); // ...

There are many more random number generators in the game that I have not listed for brevity; notably, every event has its own RNG.

The hash function essentially produces a "random-looking" number from the input string, but the number is always the same for the same input. So the idea is that the RNG states are shuffled around, but the same seed still always results in the same run.

The problem comes when these seeds are passed to the stock System.Random class in C#. Unfortunately, the pseudorandom number generation algorithm used in C# is almost entirely "linear" in the starting seed.

What this means exactly is a bit complicated -- again, I will go into greater detail later in this post. But the consequence is that two RNGs whose seeds differ by a known fixed amount have their outputs differ by a fuzzier but still-exploitable amount.

How exploitable, you might ask? Well...

Here is a big pile of consequences of CRNG, ranging from amusing-but-unimportant to legitimately impactful on gameplay (some of them even to casual players unaware of it!).

Neow's Bones

I'll start with the first example from the intro. If you pick Neow's Bones in Underdocks, the "random" curse you receive actually has the following approximate distribution:

Clumsy 0.10%

Debt 54.25%

Decay 40.32%

Doubt 1.50%

Guilty 0%

Injury 0%

Normality 0%

Regret 0%

Shame 0%

Writhe 3.82%

However, in Overgrowth, you instead get a curse from this distribution:

Clumsy 0.51%

Debt 0%

Decay 0%

Doubt 0%

Guilty 0.19%

Injury 5.53%

Normality 1.18%

Regret 0%

Shame 18.85%

Writhe 73.74%

This one is quite funny to me -- people all over Reddit and Discord have been lamenting their terrible luck that they keep rolling Debt from Neow's Bones.[2] Even before discovering CRNG, I saw some of these posts insisting it seemed more frequent than random. It is hard to express how instantaneously my brain automatically dismissed them as textbook confirmation bias. And yet...

To understand this one, we need to correlate three sources of randomness:

The "curse relic" available from Neow comes from a call to Neow's...

Correlated randomness in Slay the Spire 2

Related Articles

The Newest Instagram "Exploit" Is the Goofiest I've Seen

Apple WWDC 2026 Livestream

Claude Fable 5

US Government directive to suspend access to Fable 5 and Mythos 5

It's Not Just X. It's Y