toosoon-prng 1.0.0

package/src/controllers.ts

@@ -0,0 +1,420 @@
+import type { Gui, GuiController } from 'toosoon-gui';
+
+import prng from './prng';
+
+export enum PRNGControllerTypes {
+  Boolean = 'Boolean',
+  Sign = 'Sign',
+  Int = 'Int',
+  Float = 'Float',
+  HexColor = 'HexColor',
+  Item = 'Item',
+  ObjectProperty = 'ObjectProperty',
+  Weights = 'Weights'
+}
+
+export interface PRNGController<T = unknown> {
+  seed: string;
+  value: T;
+  addGUI(gui: Gui, min?: number, max?: number, step?: number): GuiController;
+  getValue(): T;
+  dispose(): void;
+}
+
+export interface PRNGGroupController<T = unknown> {
+  seed: string;
+  addGUI(gui: Gui, min?: number, max?: number, step?: number): Gui;
+  createController(index: number): PRNGController<T>;
+  getValueAt(index: number): T;
+  dispose(): void;
+}
+
+// *********************
+// Abstract controllers
+// *********************
+abstract class BasePRNGController<T> implements PRNGController<T> {
+  seed: string;
+  abstract value: T;
+  gui!: GuiController;
+
+  constructor(seed: string) {
+    this.seed = seed;
+    prng.addController(this);
+  }
+
+  abstract addGUI(gui: Gui, min?: number, max?: number, step?: number): GuiController;
+
+  abstract getValue(): T;
+
+  dispose() {
+    prng.removeController(this);
+    this.gui?.destroy();
+  }
+}
+
+abstract class BasePRNGGroupController<T> implements PRNGGroupController<T> {
+  seed: string;
+  controllers: PRNGController<T>[] = [];
+  gui!: Gui;
+  guiArgs!: {
+    min?: number;
+    max?: number;
+    step?: number;
+  };
+
+  constructor(seed: string) {
+    this.seed = seed;
+  }
+
+  addGUI(gui: Gui, min?: number, max?: number, step?: number) {
+    this.gui = gui.addFolder(this.seed).close();
+    this.guiArgs = { min, max, step };
+    return this.gui;
+  }
+
+  abstract createController(index: number): PRNGController<T>;
+
+  getValueAt(index: number): T {
+    let controller = this.controllers[index];
+    if (!controller) {
+      controller = this.createController(index);
+      if (this.gui) {
+        controller
+          .addGUI(this.gui, this.guiArgs.min, this.guiArgs.max, this.guiArgs.step)
+          .name(`${this.seed}-${index}`);
+      }
+      this.controllers[index] = controller;
+    }
+    return controller.value;
+  }
+
+  dispose() {
+    this.controllers.forEach((controller) => controller.dispose());
+    this.controllers = [];
+    this.gui?.destroy();
+  }
+}
+
+// *********************
+// Controllers
+// *********************
+export class BooleanController extends BasePRNGController<boolean> {
+  value: boolean;
+  probability: number;
+
+  constructor(seed: string, probability = 0.5) {
+    super(seed);
+
+    this.probability = probability;
+    this.value = this.getValue();
+  }
+
+  addGUI(gui: Gui) {
+    this.gui = gui.add(this, 'value').name(this.seed);
+    return this.gui;
+  }
+
+  getValue() {
+    this.value = prng.randomBoolean(this.seed, this.probability);
+    this.gui?.updateDisplay();
+    return this.value;
+  }
+}
+
+export class SignController extends BasePRNGController<number> {
+  value: number;
+  probability: number;
+
+  constructor(seed: string, probability = 0.5) {
+    super(seed);
+
+    this.probability = probability;
+    this.value = this.getValue();
+  }
+
+  addGUI(gui: Gui) {
+    this.gui = gui.add(this, 'value', [-1, 1]).name(this.seed);
+    return this.gui;
+  }
+
+  getValue() {
+    this.value = prng.randomSign(this.seed, this.probability);
+    this.gui?.updateDisplay();
+    return this.value;
+  }
+}
+
+export class IntController extends BasePRNGController<number> {
+  value: number;
+  min: number;
+  max: number;
+
+  constructor(seed: string, min = 0, max = 1) {
+    super(seed);
+
+    this.min = min;
+    this.max = max;
+    this.value = prng.randomInt(this.seed, min, max);
+  }
+
+  addGUI(gui: Gui, min: number, max: number, step = 1) {
+    this.gui = gui.add(this, 'value', min, max, step).name(this.seed);
+    return this.gui;
+  }
+
+  getValue() {
+    this.value = prng.randomInt(this.seed, this.min, this.max);
+    this.gui?.updateDisplay();
+    return this.value;
+  }
+}
+
+export class FloatController extends BasePRNGController<number> {
+  value: number;
+  min: number;
+  max: number;
+
+  constructor(seed: string, min = 0, max = 1) {
+    super(seed);
+
+    this.min = min;
+    this.max = max;
+    this.value = this.getValue();
+  }
+
+  addGUI(gui: Gui, min: number, max: number, step: number = 0.01) {
+    this.gui = gui.add(this, 'value', min, max, step).name(this.seed);
+    return this.gui;
+  }
+
+  getValue() {
+    this.value = prng.randomFloat(this.seed, this.min, this.max);
+    this.gui?.updateDisplay();
+    return this.value;
+  }
+}
+
+export class HexColorController extends BasePRNGController<string> {
+  value: string;
+
+  constructor(seed: string) {
+    super(seed);
+
+    this.value = this.getValue();
+  }
+
+  addGUI(gui: Gui) {
+    this.gui = gui.addColor(this, 'value').name(this.seed);
+    return this.gui;
+  }
+
+  getValue() {
+    this.value = prng.randomHexColor(this.seed);
+    this.gui?.updateDisplay();
+    return this.value;
+  }
+}
+
+export class ItemController<T = unknown> extends BasePRNGController<T> {
+  value: T;
+  items: T[];
+
+  constructor(seed: string, items: T[]) {
+    super(seed);
+
+    this.items = items;
+    this.value = this.getValue();
+  }
+
+  addGUI(gui: Gui) {
+    this.gui = gui.add(this, 'value', this.items).name(this.seed);
+    return this.gui;
+  }
+
+  getValue() {
+    this.value = prng.randomItem(this.seed, this.items) as T;
+    this.gui?.updateDisplay();
+    return this.value;
+  }
+}
+
+export class ObjectPropertyController<T = unknown> extends BasePRNGController<T> {
+  value: T;
+  object: Object;
+
+  constructor(seed: string, object: Object) {
+    super(seed);
+
+    this.object = object;
+    this.value = this.getValue();
+  }
+
+  addGUI(gui: Gui) {
+    this.gui = gui.add(this, 'value', this.object).name(this.seed);
+    return this.gui;
+  }
+
+  getValue() {
+    this.value = prng.randomObjectProperty(this.seed, this.object) as T;
+    this.gui?.updateDisplay();
+    return this.value;
+  }
+}
+
+type WeightsItems<T> = Array<{ weight: number; value: T }>;
+
+export class WeightsController<T = unknown> extends BasePRNGController<T> {
+  value: T;
+  items: WeightsItems<T>;
+  weights: number[];
+
+  constructor(seed: string, items: WeightsItems<T>) {
+    super(seed);
+
+    this.items = items;
+    this.weights = this.items.map((item) => item.weight);
+    this.value = this.getValue();
+  }
+
+  addGUI(gui: Gui) {
+    this.gui = gui
+      .add(
+        this,
+        'value',
+        this.items.map((item) => item.value)
+      )
+      .name(this.seed);
+    return this.gui;
+  }
+
+  getValue() {
+    const index = prng.randomIndex(this.seed, this.weights);
+    this.value = this.items[index].value;
+    this.gui?.updateDisplay();
+    return this.value;
+  }
+}
+
+// *********************
+// Group Controllers
+// *********************
+export class BooleanGroupController extends BasePRNGGroupController<boolean> {
+  probability: number;
+  controllers: BooleanController[] = [];
+
+  constructor(seed: string, probability: number) {
+    super(seed);
+
+    this.probability = probability;
+  }
+
+  createController(index: number) {
+    return new BooleanController(`${this.seed}-${index}`, this.probability);
+  }
+}
+
+export class SignGroupController extends BasePRNGGroupController<number> {
+  probability: number;
+  controllers: SignController[] = [];
+
+  constructor(seed: string, probability: number) {
+    super(seed);
+
+    this.probability = probability;
+  }
+
+  createController(index: number) {
+    return new SignController(`${this.seed}-${index}`, this.probability);
+  }
+}
+
+export class IntGroupController extends BasePRNGGroupController<number> {
+  min: number;
+  max: number;
+  controllers: IntController[] = [];
+
+  constructor(seed: string, min: number, max: number) {
+    super(seed);
+
+    this.min = min;
+    this.max = max;
+  }
+
+  createController(index: number) {
+    return new IntController(`${this.seed}-${index}`, this.min, this.max);
+  }
+}
+
+export class FloatGroupController extends BasePRNGGroupController<number> {
+  min: number;
+  max: number;
+  controllers: FloatController[] = [];
+
+  constructor(seed: string, min: number, max: number) {
+    super(seed);
+
+    this.min = min;
+    this.max = max;
+  }
+
+  createController(index: number) {
+    return new FloatController(`${this.seed}-${index}`, this.min, this.max);
+  }
+}
+
+export class HexColorGroupController extends BasePRNGGroupController<string> {
+  controllers: HexColorController[] = [];
+
+  // constructor(seed: string) {
+  //   super(seed);
+  // }
+
+  createController(index: number) {
+    return new HexColorController(`${this.seed}-${index}`);
+  }
+}
+
+export class ItemGroupController<T = unknown> extends BasePRNGGroupController<T> {
+  items: T[];
+  controllers: ItemController<T>[] = [];
+
+  constructor(seed: string, items: T[]) {
+    super(seed);
+
+    this.items = items;
+  }
+
+  createController(index: number) {
+    return new ItemController<T>(`${this.seed}-${index}`, this.items);
+  }
+}
+
+export class ObjectPropertyGroupController<T = unknown> extends BasePRNGGroupController<T> {
+  object: Object;
+  controllers: ObjectPropertyController<T>[] = [];
+
+  constructor(seed: string, object: Object) {
+    super(seed);
+
+    this.object = object;
+  }
+
+  createController(index: number) {
+    return new ObjectPropertyController<T>(`${this.seed}-${index}`, this.object);
+  }
+}
+
+export class WeightsGroupController<T = unknown> extends BasePRNGGroupController<T> {
+  items: WeightsItems<T>;
+  controllers: WeightsController<T>[] = [];
+
+  constructor(seed: string, items: WeightsItems<T>) {
+    super(seed);
+
+    this.items = items;
+  }
+
+  createController(index: number) {
+    return new WeightsController<T>(`${this.seed}-${index}`, this.items);
+  }
+}

package/src/index.ts

@@ -0,0 +1,24 @@
+export {
+  BooleanController,
+  SignController,
+  IntController,
+  FloatController,
+  HexColorController,
+  ItemController,
+  ObjectPropertyController,
+  WeightsController,
+  BooleanGroupController,
+  SignGroupController,
+  IntGroupController,
+  FloatGroupController,
+  HexColorGroupController,
+  ItemGroupController,
+  ObjectPropertyGroupController,
+  WeightsGroupController
+} from './controllers';
+
+export { cyrb128, sfc32, mulberry32, jsf32, xoshiro128ss } from './utils';
+
+export type { PRNGControllerTypes, PRNGController, PRNGGroupController } from './controllers';
+
+export { default } from './prng';

package/src/prng.ts

@@ -0,0 +1,112 @@
+import { PRNGController } from './controllers';
+import { cyrb128, jsf32, mulberry32, sfc32, xoshiro128ss } from './utils';
+
+export enum PRNGMethod {
+  jsf32 = 'jsf32',
+  mulberry32 = 'mulberry32',
+  sfc32 = 'sfc32',
+  xoshiro128ss = 'xoshiro128**'
+}
+
+class PRNG {
+  public seed: string = '';
+  public method: PRNGMethod = PRNGMethod.sfc32;
+  public controllers: PRNGController[] = [];
+
+  constructor(seed: string = '') {
+    this.setSeed(seed);
+  }
+
+  public addController(controller: PRNGController) {
+    this.controllers.push(controller);
+  }
+
+  public removeController(controller: PRNGController) {
+    const index = this.controllers.indexOf(controller);
+    this.controllers.splice(index, 1);
+  }
+
+  public setSeed(seed: string) {
+    if (this.seed === seed) return;
+
+    this.seed = seed;
+
+    this.controllers.forEach((controller) => {
+      controller.getValue();
+    });
+  }
+
+  public setMethod(method: PRNGMethod) {
+    this.method = method;
+  }
+
+  public random(seed: string): number {
+    const hashes = cyrb128(this.seed + seed);
+    switch (this.method) {
+      case PRNGMethod.jsf32:
+        return jsf32(hashes[0], hashes[1], hashes[2], hashes[3]);
+      case PRNGMethod.mulberry32:
+        return mulberry32(hashes[0]);
+      case PRNGMethod.sfc32:
+        return sfc32(hashes[0], hashes[1], hashes[2], hashes[3]);
+      case PRNGMethod.xoshiro128ss:
+        return xoshiro128ss(hashes[0], hashes[1], hashes[2], hashes[3]);
+    }
+  }
+
+  public randomBoolean(seed: string, probability: number = 0.5): boolean {
+    return this.random(seed) < probability;
+  }
+
+  public randomSign(seed: string, probability: number = 0.5): number {
+    return this.randomBoolean(seed, probability) ? 1 : -1;
+  }
+
+  public randomInt(seed: string, min: number, max: number) {
+    return Math.floor(this.random(seed) * (max - min + 1) + min);
+  }
+
+  public randomFloat(seed: string, min: number = 0, max: number = 1, precision: number = 2): number {
+    return parseFloat(Math.min(min + this.random(seed) * (max - min), max).toFixed(precision));
+  }
+
+  public randomHexColor(seed: string): string {
+    return '#' + ('00000' + ((this.random(seed) * (1 << 24)) | 0).toString(16)).slice(-6);
+  }
+
+  public randomItem<T = unknown>(seed: string, array: T[] = []): T | undefined {
+    if (array.length === 0) return undefined;
+    return array[this.randomInt(seed, 0, array.length - 1)];
+  }
+
+  public randomObjectProperty(seed: string, object: object): unknown | undefined {
+    const keys = Object.keys(object);
+    const key = this.randomItem(seed, keys);
+    if (key && object.hasOwnProperty(key)) {
+      return object[key as keyof object];
+    }
+  }
+
+  public randomIndex(seed: string, weights: number[] = []): number {
+    if (weights.length === 0) return -1;
+
+    let totalWeight = 0;
+    for (let weight of weights) {
+      totalWeight += weight;
+    }
+
+    if (totalWeight <= 0) console.warn('PRNG.randomIndex()', 'Weights must sum to > 0', totalWeight);
+
+    let random = this.random(seed) * totalWeight;
+    for (let i = 0; i < weights.length; i++) {
+      if (random < weights[i]) return i;
+      random -= weights[i];
+    }
+
+    return 0;
+  }
+}
+
+const prng = new PRNG();
+
+export default prng;

package/src/utils.ts

@@ -0,0 +1,106 @@
+// Seeding random number generator
+// https://stackoverflow.com/questions/521295/seeding-the-random-number-generator-in-javascript
+
+/**
+ * Produce a 128-bit hash value from a string
+ *
+ * @param {string} seed
+ * @return {number}
+ */
+export function cyrb128(seed: string): number[] {
+  let h1 = 1779033703;
+  let h2 = 3144134277;
+  let h3 = 1013904242;
+  let h4 = 2773480762;
+  for (let i = 0, k; i < seed.length; i++) {
+    k = seed.charCodeAt(i);
+    h1 = h2 ^ Math.imul(h1 ^ k, 597399067);
+    h2 = h3 ^ Math.imul(h2 ^ k, 2869860233);
+    h3 = h4 ^ Math.imul(h3 ^ k, 951274213);
+    h4 = h1 ^ Math.imul(h4 ^ k, 2716044179);
+  }
+  h1 = Math.imul(h3 ^ (h1 >>> 18), 597399067);
+  h2 = Math.imul(h4 ^ (h2 >>> 22), 2869860233);
+  h3 = Math.imul(h1 ^ (h3 >>> 17), 951274213);
+  h4 = Math.imul(h2 ^ (h4 >>> 19), 2716044179);
+  return [(h1 ^ h2 ^ h3 ^ h4) >>> 0, (h2 ^ h1) >>> 0, (h3 ^ h1) >>> 0, (h4 ^ h1) >>> 0];
+}
+
+// ******************************************
+// Pseudo-random Number Generator
+// ******************************************
+
+/**
+ * Simple Fast Counter, Generator with a 128-bit state
+ *
+ * @param {number} a
+ * @param {number} b
+ * @param {number} c
+ * @param {number} d
+ * @return {Function}
+ */
+export function sfc32(a: number, b: number, c: number, d: number): number {
+  a >>>= 0;
+  b >>>= 0;
+  c >>>= 0;
+  d >>>= 0;
+  let t = (a + b) | 0;
+  a = b ^ (b >>> 9);
+  b = (c + (c << 3)) | 0;
+  c = (c << 21) | (c >>> 11);
+  d = (d + 1) | 0;
+  t = (t + d) | 0;
+  c = (c + t) | 0;
+  return (t >>> 0) / 4294967296;
+}
+
+/**
+ * Mulberry32, Generator with a 32-bit state
+ *
+ * @param {number} a
+ * @return {Function}
+ */
+export function mulberry32(a: number): number {
+  let t = (a += 0x6d2b79f5);
+  t = Math.imul(t ^ (t >>> 15), t | 1);
+  t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+  return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+}
+
+/**
+ * Jenkins' Small Fast, Generator with a 32-bit state
+ *
+ * @param {number} a
+ * @return {Function}
+ */
+export function jsf32(a: number, b: number, c: number, d: number): number {
+  a |= 0;
+  b |= 0;
+  c |= 0;
+  d |= 0;
+  let t = (a - ((b << 27) | (b >>> 5))) | 0;
+  a = b ^ ((c << 17) | (c >>> 15));
+  b = (c + d) | 0;
+  c = (d + t) | 0;
+  d = (a + t) | 0;
+  return (d >>> 0) / 4294967296;
+}
+
+/**
+ * xoshiro128**, Generator with a 128-bit state
+ *
+ * @param {number} a
+ * @return {Function}
+ */
+export function xoshiro128ss(a: number, b: number, c: number, d: number): number {
+  let t = b << 9;
+  let r = a * 5;
+  r = ((r << 7) | (r >>> 25)) * 9;
+  c ^= a;
+  d ^= b;
+  b ^= c;
+  a ^= d;
+  c ^= t;
+  d = (d << 11) | (d >>> 21);
+  return (r >>> 0) / 4294967296;
+}

package/tsconfig.json

@@ -0,0 +1,24 @@
+{
+  "include": ["src"],
+  "exclude": ["node_modules"],
+  "compilerOptions": {
+    "baseUrl": ".",
+    "outDir": "lib",
+    "target": "es5",
+    "module": "commonjs",
+    "lib": ["DOM", "ESNext"],
+    "allowJs": true,
+    "allowSyntheticDefaultImports": true,
+    "declaration": true,
+    "esModuleInterop": true,
+    "experimentalDecorators": true,
+    "forceConsistentCasingInFileNames": true,
+    "isolatedModules": true,
+    "incremental": true,
+    "noUnusedParameters": true,
+    "noUnusedLocals": true,
+    "resolveJsonModule": true,
+    "skipLibCheck": true,
+    "strict": true
+  }
+}