U-Random Demo

Basic Random Generation

Same seed + position = same result every time

Overview

get_noise_01(position, seed) → number
Generates deterministic random value between 0-1 using Squirrel3 algorithm
RandomSeries(seed) → object
Creates a random number generator with automatic position tracking

RandomSeries Methods

get() → number
Get next value 0-1
get_float(from, to) → number
Get next value in range
get_int(from, to) → number
Get next integer in range

Examples

// Consistent random value
const value = get_noise_01(100, 42);

// Random series generator
const rng = new RandomSeries(123);
const next = rng.get();
const dice = rng.get_int(1, 6);

Noise Visualization

1D Noise Pattern

100 200

2D Noise Pattern

200 5

Noise Patterns

Noise Generation

The noise function produces deterministic pseudo-random values based on position and seed. Perfect for procedural generation where consistency is required.

Usage Examples

// Generate terrain height
for (let x = 0; x < width; x++) {
  const height = get_noise_01(x, terrainSeed);
  drawTerrain(x, height * maxHeight);
}

// 2D texture generation
for (let y = 0; y < height; y++) {
  for (let x = 0; x < width; x++) {
    const pos = x + y * width;
    const value = get_noise_01(pos, seed);
    setPixel(x, y, value);
  }
}

Distribution Analysis

Quality Analysis

Statistical Properties

The Squirrel3 algorithm produces well-distributed random values with good statistical properties. Analysis shows uniform distribution across the 0-1 range.

Expected Values

// Statistical expectations
Mean: ~0.5
Standard Deviation: ~0.289
Range: 0.0 to 1.0

// Testing randomness quality
const samples = 10000;
let sum = 0;
for (let i = 0; i < samples; i++) {
  sum += get_noise_01(i, seed);
}
const mean = sum / samples;

Procedural Terrain

Random Color Palette

Particle System

Procedural Generation

Use deterministic random values for consistent procedural content generation across multiple runs or sessions.

Game Examples

// Procedural terrain generation
function generateTerrain(seed) {
  const heights = [];
  for (let x = 0; x < width; x++) {
    let height = 0;
    height += get_noise_01(x * 0.01, seed) * 0.5;
    height += get_noise_01(x * 0.02, seed + 1) * 0.25;
    heights.push(height);
  }
  return heights;
}

// Random enemy spawning
const rng = new RandomSeries(levelSeed);
const enemyCount = rng.get_int(5, 15);
for (let i = 0; i < enemyCount; i++) {
  const x = rng.get_float(0, mapWidth);
  const y = rng.get_float(0, mapHeight);
  spawnEnemy(x, y);
}

Seed Comparison

Different seeds produce completely different but consistent sequences

Reproducibility

Seeds allow exact reproduction of random sequences. Critical for debugging, testing, and creating shareable content.

Comparison Examples

// Save and restore game state
const worldSeed = 12345;
const world = generateWorld(worldSeed);

// Players can share seeds
shareSeed(worldSeed);

// Recreate exact same world
const sameWorld = generateWorld(worldSeed);

// Different seeds = different content
const world1 = generateWorld(111);
const world2 = generateWorld(222);

Seed Tree System

Master Seed Generator

Game World Preview

Same master seed always produces identical worlds

Seed Tree Design

Hierarchical Generation

A seed tree uses a master seed to generate deterministic sub-seeds for different game systems. This ensures consistency while allowing new features to be added later.

Implementation Pattern

// Master seed generates sub-seeds
function generateSubSeed(masterSeed, feature) {
  const featureHash = make_hash(feature);
  return get_noise_01(featureHash, masterSeed) * 0x7FFFFFFF;
}

// Use sub-seeds for different systems
const terrainSeed = generateSubSeed(masterSeed, 'terrain');
const enemySeed = generateSubSeed(masterSeed, 'enemies');
const lootSeed = generateSubSeed(masterSeed, 'loot');

// New features use same master seed
const weatherSeed = generateSubSeed(masterSeed, 'weather');

Quality Analysis

Quality Metrics

Statistical Tests

Evaluates the randomness quality by measuring distribution uniformity, chi-square goodness of fit, and autocorrelation.

Quality Indicators

// Chi-square test for uniformity
function chiSquareTest(samples, bins) {
  const expected = samples / bins;
  let chiSquare = 0;
  for (let i = 0; i < bins; i++) {
    const diff = histogram[i] - expected;
    chiSquare += (diff * diff) / expected;
  }
  return chiSquare;
}

// Autocorrelation analysis
const lag1 = autocorrelation(values, 1);