Random Number Generation in Games: Fairness, Fun, and Mechanics

Randomness Is the Heart of Games

Without randomness, every game session would play identically. Cards would always draw in the same order, enemies would follow the same patrol routes, and loot would always drop the same items. Randomness is what makes games replayable, surprising, and emotionally engaging.

But randomness in games is not the same as randomness in cryptography. Game RNG prioritizes speed, reproducibility, and designer control — not unpredictability against attackers.

Where Games Use Randomness

PRNGs Suitable for Games

Games need fast, deterministic PRNGs that produce good statistical distributions. Cryptographic generators are overkill and too slow for the volume of random calls games make per frame.

Xorshift128+

The default in V8 (Chrome/Node.js). Fast, good distribution, 128-bit state.

// Simplified xorshift128+ (educational)
let state0 = 1, state1 = 2;
function xorshift128plus() {
  let s1 = state0;
  let s0 = state1;
  state0 = s0;
  s1 ^= s1 << 23;
  s1 ^= s1 >> 17;
  s1 ^= s0;
  s1 ^= s0 >> 26;
  state1 = s1;
  return (s0 + s1) >>> 0;
}

PCG (Permuted Congruential Generator)

A newer family combining LCG speed with better statistical quality. Gaining adoption in game engines.

Mersenne Twister (MT19937)

The default in Python and many game engines. Extremely long period (2^19937 - 1), but large state (2.5 KB). Overkill for most games but widely available.

Seeded RNG for Reproducibility

Games often need reproducible randomness — the same seed should produce the same world. This is essential for:

• Deterministic replays: Record seed + player inputs, not full game state
• Shared worlds: Multiplayer games synchronize seeds so all clients generate the same terrain
• Debugging: Reproduce bugs by replaying with the same seed

// Seeded PRNG for game worlds
class SeededRNG {
  constructor(seed) {
    this.seed = seed;
  }

  next() {
    this.seed = (this.seed * 16807 + 0) % 2147483647;
    return this.seed / 2147483647;
  }

  // Random integer in range [min, max)
  nextInt(min, max) {
    return Math.floor(this.next() * (max - min)) + min;
  }
}

const world = new SeededRNG(42);
const treeX = world.nextInt(0, 800);
const treeY = world.nextInt(0, 600);

Loot Drop Mechanics

Weighted Random Selection

Not all items drop with equal probability. Weighted selection assigns probabilities proportional to weights:

function weightedRandom(items) {
  const totalWeight = items.reduce((sum, item) => sum + item.weight, 0);
  let roll = Math.random() * totalWeight;

  for (const item of items) {
    roll -= item.weight;
    if (roll <= 0) return item;
  }
  return items[items.length - 1];
}

// Usage
const loot = weightedRandom([
  { name: 'Common Sword', weight: 60 },
  { name: 'Rare Shield',  weight: 25 },
  { name: 'Epic Ring',    weight: 10 },
  { name: 'Legendary Staff', weight: 5 },
]);

Pity Systems

Pure random drops frustrate players when luck is bad. Pity timers guarantee a rare drop after N failed attempts:

function lootWithPity(attempts, threshold = 10) {
  if (attempts >= threshold) {
    return { name: 'Guaranteed Rare', rarity: 'rare' };
  }

  const dropChance = 0.05 + (attempts * 0.005); // Soft pity
  if (Math.random() < dropChance) {
    return { name: 'Rare Item', rarity: 'rare' };
  }
  return { name: 'Common Item', rarity: 'common' };
}

Player Perception of Fairness

Players perceive randomness differently than mathematicians. Key findings from game design research:

Streak Breaking

If a player misses 3+ times in a row, some games silently boost the next hit chance to prevent frustration:

function combatRoll(consecutiveMisses) {
  let hitChance = 0.7;
  if (consecutiveMisses >= 3) {
    hitChance = Math.min(hitChance + 0.15 * consecutiveMisses, 0.95);
  }
  return Math.random() < hitChance;
}

Procedural Generation

For terrain and level generation, combine multiple PRNG calls with noise functions:

// Simple 1D terrain using midpoint displacement
function generateTerrain(width, roughness, rng) {
  const terrain = new Array(width).fill(0);
  terrain[0] = rng.nextInt(30, 70);
  terrain[width - 1] = rng.nextInt(30, 70);

  let step = width - 1;
  let scale = roughness;

  while (step > 1) {
    const half = Math.floor(step / 2);
    for (let i = half; i < width; i += step) {
      const avg = (terrain[i - half] + terrain[i + half]) / 2;
      terrain[i] = avg + (rng.next() - 0.5) * scale;
    }
    step = half;
    scale *= 0.5;
  }
  return terrain;
}

Key Takeaways

• Games need fast, deterministic PRNGs — cryptographic security is unnecessary
• Seeded RNG enables reproducible worlds, replays, and synced multiplayer
• Weighted random selection is the standard for loot drops and encounters
• Pity systems and streak breaking manage player frustration with bad luck
• Player perception of fairness often matters more than mathematical fairness
• Procedural generation combines PRNG with noise functions for natural-looking content

Try It Yourself

Generate random numbers for any game mechanic with our Random Number Generator. Set custom ranges, generate unique values, or create weighted distributions — all interactively.

Related Guides

• Random Number Guide — types of RNG and how they work
• Probability and Statistics Tools — distributions, permutations, and combinatorics