another machine Procedural Generation GitHub

GoldenRatio performs deterministic procedural generation in aesthetically pleasing distributions.

new GoldenRatio({ seed?: number })

const generator = new GoldenRatio();

shouldEventOccur determines if a time occurs in an organic window

shouldEventOccur({ time: number; eventWindow?: number; cycleLength?: number }): boolean

generator.shouldEventOccur({ 
  time: ,
  eventWindow: 1000,
  cycleLength: 10000
});

generate returns a deterministic but seemingly random value between min and max

generate({ time: number; min?: number; max?: number }): number

generator.generate({ 
  time: 
});

noise2d returns a noise value at coordinates x, y

noise2d({ x: number; y: number }): number

generator.noise2d({ 
  x: ,
  y: 
});

HarmonicSuperposition uses sine wave superpositions to organically trigger events

new HarmonicSuperposition({ baseFrequency: number; components: { amplitude: number; relativeFrequency: number; }[]; threshold: number; onThresholdCrossed?: (time: number, value: number) => void; })

const generator = new HarmonicSuperposition({
  baseFrequency: 0.001,
  threshold: 1.5,
  components: [
    { amplitude: 1.0, relativeFrequency: 1.0 }, 
    { amplitude: 0.5, relativeFrequency: 2.7 }, 
    { amplitude: 0.3, relativeFrequency: 4.1 }
  ]
});

generator.calculate();

...waiting for threshold to be crossed

tuneForEventsPerHour returns an instance of HarmonicSuperposition

HarmonicSuperposition.tuneForEventsPerHour({ desiredEventsPerHour: number, simulationHours: number, onThresholdCrossed?: (time: number, value: number) => void }): HarmonicSuperposition

const generator = HarmonicSuperposition.tuneForEventsPerHour({
  desiredEventsPerHour: 45,
  simulationHours: 24
});



generator.calculate();

...waiting for threshold to be crossed

RandomEngine manages seeded randomness.

new RandomEngine({ seed: string; size: number })

const engine = new RandomEngine({ 
  seed: "", 
  size: 
});

Progress engine cores forward.

random(direction?: number): number[]

engine.position = 
engine.random();

engine.position = 

Move engine cores to a specific position.

move(position: number): number[]

engine.position = 
engine.move();

engine.position = 

3d perlin noise per engine core.

perlin(x?: number; y?: number; z?: number;): number[]

engine.perlin(, , )

Timecode generates temporary Base32 codes.

new Timecode({ length: number; seed: string; seconds: number; }): { generate(time?: number) => { code: string; expiry: number; position: number} }

const timecode = new Timecode({ 
  length: ,
  seconds: ,
  seed: "", 
});
timecode.generate()