We Take Our Dice
VERY Seriously.
Mathematics at its purest.

Your d20 has a secret

We love physical dice. The weight, the clatter, that moment of suspense as the die settles. But here's the uncomfortable truth that dice manufacturers would rather you not think about: your shiny math rocks are not perfectly fair.

None of this means physical dice are bad. They are a ritual, a tradition, a sensory experience. But if you want true mathematical fairness, you need something better.

How we roll (literally)

Every single dice roll in ArchitectRPG, from initiative to damage to death saves, uses the Web Crypto API's crypto.getRandomValues() function. This is a cryptographically secure pseudorandom number generator (CSPRNG) backed by your operating system's hardware entropy pool.

function cryptoRandomInt(min: number, max: number): number {
  const range = max - min + 1;
  // Calculate the largest multiple of range that fits in 32 bits
  const maxValid = Math.floor(0xFFFFFFFF / range) * range;
  const arr = new Uint32Array(1);
  let val: number;
  do {
    // Draw from hardware entropy via Web Crypto API
    crypto.getRandomValues(arr);
    val = arr[0];
    // Reject values that would cause modulo bias
  } while (val >= maxValid);
  return min + (val % range);
}

The wall between dice and narrative

We call it the "Iron Rules, Silk Tongue" architecture. The rules engine is iron: deterministic, auditable, incorruptible. The AI narrator is silk: creative, dramatic, evocative. They never cross. The AI cannot influence dice outcomes any more than a sports commentator can change the score.

Here's what happens in the 200 milliseconds between "I attack the troll" and "Your blade finds its mark":

The AI receives the mechanical result (hit, 13 damage) as a fait accompli. It cannot re-roll, fudge, or "adjust for drama." If you roll a natural 1 on a death save, the narrator will describe it beautifully, but that character is still in trouble.

The brutally honest comparison

We are not going to pretend digital dice are better in every way. Physical dice have something we will never replicate. But on the maths? We win. Decisively.

Three nat 1s in a row and you think we hate you

We hear this. You rolled three natural 1s in a row and you are convinced the system hates you. Here is why that feeling is perfectly normal and mathematically expected:

Receipts. We keep receipts.

Every dice roll in every game session is logged with full provenance. Purpose, die type, raw result, modifier, total, whether it was a critical. No roll is ever lost, hidden, or retroactively changed. Your combat log is a complete, auditable record of every mechanical decision the system made.

interface DiceRollRecord {
  purpose: string;        // "Brynn attacks Troll with Greatsword"
  dieType: string;        // "d20"
  result: number;         // 17 (raw roll, untouched)
  modifier: number;       // +7 (STR mod + proficiency)
  total: number;          // 24 (result + modifier)
  critical: "success"     // Natural 20
           | "fuckup"     // Natural 1
           | null;        // Normal roll
}

Why Math.random() gets an F

For the technically curious: JavaScript's Math.random() uses the xorshift128+ algorithm in V8 (Chrome/Node.js). It is fast and statistically decent, but it has properties that make it unsuitable for dice:

• xPredictable. Given enough output, the internal state can be reconstructed and future values predicted. A sufficiently motivated player could theoretically predict dice rolls.
• xNot uniformly distributed at fine granularity. It produces 64-bit floats, and the mapping to integers introduces subtle biases depending on the range.
• xSeeded from a single timestamp. Two servers starting at similar times could produce correlated sequences.

crypto.getRandomValues() has none of these problems. It is backed by hardware entropy, resistant to prediction, and uniformly distributed by design. It is the same API used by TLS, password generators, and cryptographic key generation. If it is good enough to protect your bank account, it is good enough for your attack roll.

Enough talk. Roll something.

Do not take our word for it. Roll a few hundred times and see for yourself. Every result below is generated using the exact same code path as a live game session.