@v12-engine/engine 0.1.0 → 0.4.0

package/dist/remains.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"remains.js","names":[],"sources":["../src/remains.ts"],"sourcesContent":["import { defineComponent } from './components'\nimport type { GamePack } from './packs/pack'\nimport type { ResourceId, UnitTypeDef } from './defs'\nimport type { Entity, PlayerId } from './entity'\nimport { defineEngineEvent } from './events'\nimport { defineHook } from './hooks'\nimport { MAP_NEUTRAL } from './map'\nimport { earn } from './player'\nimport type { System } from './registry'\nimport type { World } from './world'\nimport { deposit } from './entity'\n\n/*\n * Remains that are things, an opt-in pack (master plan OH4): a building that falls leaves rubble that blocks the way\n * (a resource with its footprint) until workers clear it, gathering it as a resource (stone, or what the game says);\n * a unit that falls can drop a pile of a resource, picked up by the first unit of a player's that walks over it. What\n * the screen shows of a death (`remains` of the view: a crater, scorch) stays the view's; these are of the world.\n */\n\n/**\n * What rubble or a pile is to be, as a game says it for a death: the unit type it is, and how much of its resource it\n * holds (the type's `resource.amount` when left out)\n *\n * @beta\n */\nexport interface RemainsSpec {\n\t/** The unit type of the rubble or pile left behind, a resource-bearing type */\n\ttype: string\n\t/** How much of the resource it holds; the type's `resource.amount` when left out */\n\tamount?: number\n}\n\n/**\n * What the remains of a game are made of (`remainsPack`)\n *\n * @beta\n */\nexport interface RemainsOptions {\n\t/**\n\t * The rubble a fallen building leaves, put down where it stood once it is gone: a type (a resource with a footprint,\n\t * see `rubbleType`), worked out for the death, or `null` for none. None when left out\n\t */\n\trubble?: string | ((world: World, dead: Entity) => RemainsSpec | string | null | undefined)\n\t/**\n\t * The pile a fallen unit drops: a type (a resource with no footprint, see `pileType`) and how much, or `null` for\n\t * none. None when left out\n\t */\n\tpiles?: (world: World, dead: Entity, killer: Entity | undefined) => RemainsSpec | null | undefined\n\t/** How near a unit comes to a pile to pick it up, in cells: 0.8 when left out */\n\treach?: number\n\t/** Who may pick a pile up: any unit of a player's that is not a structure, when left out */\n\tpicksUp?: (world: World, unit: Entity, pile: Entity) => boolean\n}\n\n/**\n * What a pile holds: the resource and how much. Told to everyone, for its look and its tooltip\n *\n * @beta\n */\nexport const pileOf = defineComponent<{ kind: ResourceId; amount: number }>({ id: 'core.pile', replicate: 'everyone' })\n\n/** The piles there are and the rubble to put down once the building it is of is gone, kept with the world */\nexport const remains = defineComponent<{ piles: number[]; rubble: Record<number, { type: string; amount?: number; x: number; z: number }> }>({ id: 'core.remains', default: () => ({ piles: [], rubble: {} }) })\n\n/**\n * A pile was picked up: by whom (a unit's id and its owner), what and how much\n *\n * @beta\n */\nexport const pileTaken = defineEngineEvent<{ pile: number; by: number; player: PlayerId; kind: ResourceId; amount: number }>({ id: 'core.pileTaken', replicate: 'everyone' })\n\n/** The player the map's neutral things are of: rubble and piles are */\nfunction neutralOf(world: World): PlayerId {\n\tfor (const player of world.players.values()) if (player.neutral) return player.id\n\treturn MAP_NEUTRAL\n}\n\n/** Spawns remains of a type, holding so much of their resource */\nfunction putDown(world: World, spec: RemainsSpec, x: number, z: number): Entity | undefined {\n\tif (!world.registry.units.has(spec.type)) return undefined\n\tconst entity = world.spawn(spec.type, neutralOf(world), { x, z })\n\tif (spec.amount !== undefined && entity.get(deposit)) entity.get(deposit)!.amount = spec.amount\n\treturn entity\n}\n\n/**\n * A type of rubble, to put in the game's units: a resource that blocks its footprint, gathered (cleared) as `kind`\n * by the game's workers, with no look of its own (the game's looks give it one)\n *\n * @beta\n */\nexport function rubbleType(def: {\n\tid: string\n\tname?: string\n\tfootprint: { w: number; d: number }\n\tkind: ResourceId\n\tamount?: number\n\tslots?: number\n}): UnitTypeDef {\n\treturn {\n\t\tid: def.id,\n\t\tname: def.name ?? 'Rubble',\n\t\tkind: 'resource',\n\t\tradius: Math.max(def.footprint.w, def.footprint.d) / 2,\n\t\tfootprint: def.footprint,\n\t\tstats: { health: 1 },\n\t\tsight: 0,\n\t\tresource: { id: def.kind, amount: def.amount ?? 100, slots: def.slots ?? 3 }\n\t} as UnitTypeDef\n}\n\n/**\n * A type of pile, to put in the game's units: something lying on the ground that blocks nothing, is fought by nobody,\n * and is handed (`pileOf`: its kind and how much) to who walks over it. `kind` and `amount` are what it holds when the\n * death that drops it says nothing else\n *\n * @beta\n */\nexport function pileType(def: {\n\tid: string\n\tname?: string\n\tkind: ResourceId\n\tamount?: number\n}): UnitTypeDef & { pile: { kind: ResourceId; amount: number } } {\n\treturn {\n\t\tid: def.id,\n\t\tname: def.name ?? 'Pile',\n\t\tkind: 'unit',\n\t\tradius: 0.2,\n\t\tstats: { health: 1, moveSpeed: 0 },\n\t\tsight: 0,\n\t\tinvulnerable: true,\n\t\tignored: true,\n\t\tpile: { kind: def.kind, amount: def.amount ?? 10 }\n\t} as UnitTypeDef & { pile: { kind: ResourceId; amount: number } }\n}\n\n/**\n * Remains that are things for a game (`RemainsOptions`): rubble where buildings fell, piles where units did. The game\n * is the same otherwise; its units list the types (`rubbleType`, `pileType`, or its own)\n *\n * @beta\n */\nexport function remainsPack(options: RemainsOptions = {}): GamePack {\n\tconst reach = options.reach ?? 0.8\n\tconst picksUp = options.picksUp ?? ((_world: World, unit: Entity) => !unit.isStructure && !unit.isResource && unit.alive && !unit.get(pileOf))\n\n\tconst deathHook = defineHook({\n\t\thook: 'death',\n\t\tid: 'core.remains.death',\n\t\trun(world, event) {\n\t\t\tconst { entity: dead, killer } = event\n\t\t\tconst state = world.state(remains)\n\t\t\tif (dead.isStructure && options.rubble) {\n\t\t\t\tconst said = typeof options.rubble === 'function' ? options.rubble(world, dead) : options.rubble\n\t\t\t\tconst spec = typeof said === 'string' ? { type: said } : said\n\t\t\t\t// put down once the building is gone: its cells are its own until then\n\t\t\t\tif (spec) state.rubble[dead.id] = { ...spec, x: dead.pos.x, z: dead.pos.z }\n\t\t\t} else if (!dead.isStructure && !dead.isResource && options.piles) {\n\t\t\t\tconst spec = options.piles(world, dead, killer)\n\t\t\t\tconst pile = spec && putDown(world, spec, dead.pos.x, dead.pos.z)\n\t\t\t\tif (!pile) return\n\t\t\t\t// what it holds: what the death says, else its type's (`pileType`)\n\t\t\t\tconst kept = (pile.def as { pile?: { kind: ResourceId; amount: number } }).pile\n\t\t\t\tconst kind = kept?.kind ?? world.registry.resources[0]?.id ?? 'gold'\n\t\t\t\tpile.set(pileOf, { kind, amount: spec.amount ?? kept?.amount ?? 10 })\n\t\t\t\tstate.piles.push(pile.id)\n\t\t\t}\n\t\t}\n\t})\n\tconst removeHook = defineHook({\n\t\thook: 'remove',\n\t\tid: 'core.remains.remove',\n\t\trun(world, entity) {\n\t\t\tconst state = world.state(remains)\n\t\t\tconst rubble = state.rubble[entity.id]\n\t\t\tif (!rubble) return\n\t\t\tdelete state.rubble[entity.id]\n\t\t\tputDown(world, rubble, rubble.x, rubble.z)\n\t\t}\n\t})\n\tconst near: Entity[] = []\n\tconst pickUp: System = {\n\t\tname: 'core.remains.piles',\n\t\tupdate(world: World) {\n\t\t\tconst state = world.state(remains)\n\t\t\tif (!state.piles.length) return\n\t\t\tstate.piles = state.piles.filter((id) => {\n\t\t\t\tconst pile = world.get(id)\n\t\t\t\tconst holds = pile?.get(pileOf)\n\t\t\t\tif (!pile?.alive || !holds) return false\n\t\t\t\tfor (const unit of [...world.spatial.query(pile.pos.x, pile.pos.z, reach, near)]) {\n\t\t\t\t\tif (world.player(unit.owner).neutral || !picksUp(world, unit, pile)) continue\n\t\t\t\t\tconst dx = unit.pos.x - pile.pos.x\n\t\t\t\t\tconst dz = unit.pos.z - pile.pos.z\n\t\t\t\t\tconst within = reach + unit.def.radius\n\t\t\t\t\tif (dx * dx + dz * dz > within * within) continue\n\t\t\t\t\tconst { kind, amount } = holds\n\t\t\t\t\tearn(world.player(unit.owner).resources, kind, amount)\n\t\t\t\t\tworld.events.emit(pileTaken, { pile: pile.id, by: unit.id, player: unit.owner, kind, amount })\n\t\t\t\t\tworld.kill(pile, unit, false, 'taken')\n\t\t\t\t\treturn false\n\t\t\t\t}\n\t\t\t\treturn true\n\t\t\t})\n\t\t}\n\t}\n\treturn {\n\t\tid: 'remains',\n\t\toptions,\n\t\tcomponents: [remains, pileOf],\n\t\tevents: [pileTaken],\n\t\thooks: [deathHook, removeHook],\n\t\tsystems: [pickUp]\n\t}\n}\n"],"mappings":"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"}

package/dist/replication.d.ts

@@ -1,8 +1,8 @@
 /**
  * What a player is told of a world, written with what it tells of (design review E7): an event of the world becomes an
  * event on a player's screen by the rule beside the code that emits it (`replicateEvent`), and a part of the snapshot is
- * captured by the feature it is of (`SnapshotPart`). A seat (`LocalSession`) runs what its game has of them
- * (`Registry.replications`, `Registry.snapshotParts`: the engine's, then the packs'), for what its player may know
+ * captured by the feature it is of (`SnapshotField`). A seat (`LocalSession`) runs what its game has of them
+ * (`Registry.replications`, `Registry.snapshotFields`: the engine's, then the packs'), for what its player may know
  * (`SessionView`)
  */
 import type { Entity, PlayerId } from './entity';
@@ -12,12 +12,13 @@ import type { World } from './world';
 import { type TeamMemory } from './session/memory';
 /**
  * A seat's side of a world: whose it is, and what they may know of it now. What the rules that tell a player of the
- * world ask (`replicateEvent`, `SnapshotPart`, an event of a game's own's `replicate`), and what a seat keeps for them
+ * world ask (`replicateEvent`, `SnapshotField`, an event of a game's own's `replicate`), and what a seat keeps for them
  * (`keep`)
  *
  * @beta
  */
 export declare class SessionView {
+    /** The world the session view is a seat's window onto */
     readonly world: World;
     /** The seat's player: from whose side it sees, an observer's too */
     readonly player: PlayerId;
@@ -30,7 +31,9 @@ export declare class SessionView {
     /** What the seat was told since its last snapshot, for the next one */
     events: SessionEvent[];
     private readonly kept;
-    constructor(world: World, 
+    constructor(
+    /** The world the session view is a seat's window onto */
+    world: World, 
     /** The seat's player: from whose side it sees, an observer's too */
     player: PlayerId, options?: {
         observer?: boolean;
@@ -88,16 +91,18 @@ export declare function replicateEvent<T, A extends keyof SessionEvents>(event:
 /**
  * A part of the snapshot a player is sent, captured by the feature it is of: the projectiles, the items on the
  * ground, the score. Before the entities (`head`) or after the players; left out of the snapshot where it gives
- * nothing (`undefined`). Listed by the engine for its own, by a pack in `GamePack.snapshotParts` (a key of its own
+ * nothing (`undefined`). Listed by the engine for its own, by a pack in `GamePack.snapshotFields` (a key of its own
  * added to `Snapshot` by declaration merging)
  *
  * @beta
  */
-export interface SnapshotPart<K extends keyof Snapshot = keyof Snapshot> {
+export interface SnapshotField<K extends keyof Snapshot = keyof Snapshot> {
+    /** The key of `Snapshot` this field fills */
     readonly key: K;
     /** Before the entities and the players, where the tick's own facts are (the hour, the outcome) */
     readonly head?: boolean;
+    /** Reads this part of the snapshot for the seat's view; undefined leaves it out of the snapshot */
     capture(view: SessionView): Snapshot[K] | undefined;
 }
 /** What the seat was told since its last snapshot (`Snapshot.events`) */
-export declare const eventsPart: SnapshotPart<keyof Snapshot>;
+export declare const eventsPart: SnapshotField<keyof Snapshot>;

package/dist/replication.js

@@ -0,0 +1,100 @@
+import { teamMemory } from "./session/memory.js";
+//#region src/replication.ts
+/**
+* A seat's side of a world: whose it is, and what they may know of it now. What the rules that tell a player of the
+* world ask (`replicateEvent`, `SnapshotField`, an event of a game's own's `replicate`), and what a seat keeps for them
+* (`keep`)
+*
+* @beta
+*/
+var SessionView = class {
+	world;
+	player;
+	/** Who only watches, and sees everything (`LocalSession.observer`) */
+	observer;
+	/** Whether the seat is a computer player's, which is told only what a brain reads (`LocalSession.forComputer`) */
+	forComputer;
+	/** How many effects of the rules are kept for their stop to be told (`LocalSession` options' `mostEffects`) */
+	mostEffects;
+	/** What the seat was told since its last snapshot, for the next one */
+	events = [];
+	kept = /* @__PURE__ */ new Map();
+	constructor(world, player, options = {}) {
+		this.world = world;
+		this.player = player;
+		this.observer = options.observer ?? false;
+		this.forComputer = options.forComputer ?? false;
+		this.mostEffects = options.mostEffects ?? 1024;
+	}
+	/** The player's team: theirs now, as the rules may move them to another (`setTeam`) */
+	get team() {
+		return this.world.player(this.player).team;
+	}
+	/** Whether an owner is the player or an ally of theirs: an observer's is everyone */
+	isAlly = (owner) => this.observer || this.world.areAllies(owner, this.player);
+	/** Whether the player's team sees a spot of the map right now: an observer sees all of it */
+	sees = (x, z) => this.observer || this.world.fog.isVisible(this.team, x, z);
+	/** Whether the player's team can see the entity right now: its side's always */
+	knows = (entity) => this.isAlly(entity.owner) || !entity.hidden && this.world.isVisibleTo(entity, this.team);
+	/** An observer's own memory: it sees everything, which is no team's to remember */
+	ownMemory = {
+		structures: {},
+		cleared: []
+	};
+	/**
+	* What the player's team remembers of what it saw (`teamMemory`: the structures out of sight as last seen, the camps
+	* seen empty), or an observer's own. Looked up again each time: the player may have moved to another team since
+	*/
+	get memory() {
+		if (this.observer) return this.ownMemory;
+		const all = this.world.state(teamMemory);
+		return all[this.team] ??= {
+			structures: {},
+			cleared: []
+		};
+	}
+	/** What the seat keeps under a key for what tells it things (the effects it was shown, the score last told): made the first time */
+	keep(key, make) {
+		let kept = this.kept.get(key);
+		if (kept === void 0) this.kept.set(key, kept = make());
+		return kept;
+	}
+	/** Takes what the seat was told since the last snapshot */
+	takeEvents() {
+		const events = this.events;
+		this.events = [];
+		return events;
+	}
+};
+/**
+* How an event of the world is told to a player, written beside what emits it: `replicateEvent(healed, 'heal', (heal,
+* view) => view.knows(heal.target) ? { type: 'heal', ... } : undefined)`. Listed by the engine for its own, by a pack in
+* `GamePack.replications`
+*
+* @beta
+*/
+function replicateEvent(event, as, tell) {
+	return {
+		event,
+		as,
+		tell
+	};
+}
+/**
+* A part of the snapshot, typed by its key
+*
+* @internal
+*/
+function snapshotField(key, capture, head) {
+	return {
+		key,
+		capture,
+		...head && { head }
+	};
+}
+/** What the seat was told since its last snapshot (`Snapshot.events`) */
+var eventsPart = snapshotField("events", (view) => view.takeEvents());
+//#endregion
+export { SessionView, eventsPart, replicateEvent, snapshotField };
+
+//# sourceMappingURL=replication.js.map

package/dist/replication.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"replication.js","names":[],"sources":["../src/replication.ts"],"sourcesContent":["/**\n * What a player is told of a world, written with what it tells of (design review E7): an event of the world becomes an\n * event on a player's screen by the rule beside the code that emits it (`replicateEvent`), and a part of the snapshot is\n * captured by the feature it is of (`SnapshotField`). A seat (`LocalSession`) runs what its game has of them\n * (`Registry.replications`, `Registry.snapshotFields`: the engine's, then the packs'), for what its player may know\n * (`SessionView`)\n */\nimport type { Entity, PlayerId } from './entity'\nimport type { EventKey } from './events'\nimport type { SessionEvent, SessionEvents, Snapshot } from './session/protocol'\nimport type { World } from './world'\nimport { type TeamMemory, teamMemory } from './session/memory'\n\n/**\n * A seat's side of a world: whose it is, and what they may know of it now. What the rules that tell a player of the\n * world ask (`replicateEvent`, `SnapshotField`, an event of a game's own's `replicate`), and what a seat keeps for them\n * (`keep`)\n *\n * @beta\n */\nexport class SessionView {\n\t/** Who only watches, and sees everything (`LocalSession.observer`) */\n\treadonly observer: boolean\n\t/** Whether the seat is a computer player's, which is told only what a brain reads (`LocalSession.forComputer`) */\n\treadonly forComputer: boolean\n\t/** How many effects of the rules are kept for their stop to be told (`LocalSession` options' `mostEffects`) */\n\treadonly mostEffects: number\n\t/** What the seat was told since its last snapshot, for the next one */\n\tevents: SessionEvent[] = []\n\tprivate readonly kept = new Map<object, unknown>()\n\n\tconstructor(\n\t\t/** The world the session view is a seat's window onto */\n\t\treadonly world: World,\n\t\t/** The seat's player: from whose side it sees, an observer's too */\n\t\treadonly player: PlayerId,\n\t\toptions: { observer?: boolean; forComputer?: boolean; mostEffects?: number } = {}\n\t) {\n\t\tthis.observer = options.observer ?? false\n\t\tthis.forComputer = options.forComputer ?? false\n\t\tthis.mostEffects = options.mostEffects ?? 1024\n\t}\n\n\t/** The player's team: theirs now, as the rules may move them to another (`setTeam`) */\n\tget team(): number {\n\t\treturn this.world.player(this.player).team\n\t}\n\n\t/** Whether an owner is the player or an ally of theirs: an observer's is everyone */\n\treadonly isAlly = (owner: PlayerId): boolean => this.observer || this.world.areAllies(owner, this.player)\n\n\t/** Whether the player's team sees a spot of the map right now: an observer sees all of it */\n\treadonly sees = (x: number, z: number): boolean => this.observer || this.world.fog.isVisible(this.team, x, z)\n\n\t/** Whether the player's team can see the entity right now: its side's always */\n\treadonly knows = (entity: Entity): boolean => this.isAlly(entity.owner) || (!entity.hidden && this.world.isVisibleTo(entity, this.team))\n\n\t/** An observer's own memory: it sees everything, which is no team's to remember */\n\tprivate readonly ownMemory: TeamMemory = { structures: {}, cleared: [] }\n\n\t/**\n\t * What the player's team remembers of what it saw (`teamMemory`: the structures out of sight as last seen, the camps\n\t * seen empty), or an observer's own. Looked up again each time: the player may have moved to another team since\n\t */\n\tget memory(): TeamMemory {\n\t\tif (this.observer) return this.ownMemory\n\t\tconst all = this.world.state(teamMemory)\n\t\treturn (all[this.team] ??= { structures: {}, cleared: [] })\n\t}\n\n\t/** What the seat keeps under a key for what tells it things (the effects it was shown, the score last told): made the first time */\n\tkeep<S>(key: object, make: () => S): S {\n\t\tlet kept = this.kept.get(key) as S | undefined\n\t\tif (kept === undefined) this.kept.set(key, (kept = make()))\n\t\treturn kept\n\t}\n\n\t/** Takes what the seat was told since the last snapshot */\n\ttakeEvents(): SessionEvent[] {\n\t\tconst events = this.events\n\t\tthis.events = []\n\t\treturn events\n\t}\n}\n\n/**\n * The event on a screen of a kind\n *\n * @beta\n */\nexport type SessionEventOf<K extends keyof SessionEvents> = SessionEvents[K]\n\n/**\n * How an event of the world is told to a player (`replicateEvent`): what the seat hears it as, and what it says of it\n * to the player, if anything\n *\n * @beta\n */\nexport interface ReplicatedEvent {\n\t/** The kind of event on the screen: a computer's seat hears only the kinds a brain reads (`COMPUTER_EVENTS`) */\n\treadonly as: SessionEvent['type']\n\t/** The world's event it tells of: one of the engine's (`engineEvents`) or a game's own (`defineEvent`) */\n\treadonly event: EventKey<unknown>\n\t/** What the player is told of it: nothing for what they may not know */\n\ttell(payload: unknown, view: SessionView): SessionEvent | undefined\n}\n\n/**\n * How an event of the world is told to a player, written beside what emits it: `replicateEvent(healed, 'heal', (heal,\n * view) => view.knows(heal.target) ? { type: 'heal', ... } : undefined)`. Listed by the engine for its own, by a pack in\n * `GamePack.replications`\n *\n * @beta\n */\nexport function replicateEvent<T, A extends keyof SessionEvents>(\n\tevent: EventKey<T>,\n\tas: A,\n\ttell: (payload: T, view: SessionView) => SessionEventOf<A> | undefined\n): ReplicatedEvent {\n\treturn { event: event as EventKey<unknown>, as, tell: tell as ReplicatedEvent['tell'] }\n}\n\n/**\n * A part of the snapshot a player is sent, captured by the feature it is of: the projectiles, the items on the\n * ground, the score. Before the entities (`head`) or after the players; left out of the snapshot where it gives\n * nothing (`undefined`). Listed by the engine for its own, by a pack in `GamePack.snapshotFields` (a key of its own\n * added to `Snapshot` by declaration merging)\n *\n * @beta\n */\nexport interface SnapshotField<K extends keyof Snapshot = keyof Snapshot> {\n\t/** The key of `Snapshot` this field fills */\n\treadonly key: K\n\t/** Before the entities and the players, where the tick's own facts are (the hour, the outcome) */\n\treadonly head?: boolean\n\t/** Reads this part of the snapshot for the seat's view; undefined leaves it out of the snapshot */\n\tcapture(view: SessionView): Snapshot[K] | undefined\n}\n\n/**\n * A part of the snapshot, typed by its key\n *\n * @internal\n */\nexport function snapshotField<K extends keyof Snapshot>(\n\tkey: K,\n\tcapture: (view: SessionView) => Snapshot[K] | undefined,\n\thead?: boolean\n): SnapshotField {\n\treturn { key, capture, ...(head && { head }) } as SnapshotField\n}\n\n/** What the seat was told since its last snapshot (`Snapshot.events`) */\nexport const eventsPart = snapshotField('events', (view) => view.takeEvents())\n"],"mappings":";;;;;;;;;AAoBA,IAAa,cAAb,MAAyB;CAad;CAEA;;CAbV;;CAEA;;CAEA;;CAEA,SAAyB,CAAC;CAC1B,uBAAwB,IAAI,IAAqB;CAEjD,YAEC,OAEA,QACA,UAA+E,CAAC,GAC/E;EAJQ,KAAA,QAAA;EAEA,KAAA,SAAA;EAGT,KAAK,WAAW,QAAQ,YAAY;EACpC,KAAK,cAAc,QAAQ,eAAe;EAC1C,KAAK,cAAc,QAAQ,eAAe;CAC3C;;CAGA,IAAI,OAAe;EAClB,OAAO,KAAK,MAAM,OAAO,KAAK,MAAM,CAAC,CAAC;CACvC;;CAGA,UAAmB,UAA6B,KAAK,YAAY,KAAK,MAAM,UAAU,OAAO,KAAK,MAAM;;CAGxG,QAAiB,GAAW,MAAuB,KAAK,YAAY,KAAK,MAAM,IAAI,UAAU,KAAK,MAAM,GAAG,CAAC;;CAG5G,SAAkB,WAA4B,KAAK,OAAO,OAAO,KAAK,KAAM,CAAC,OAAO,UAAU,KAAK,MAAM,YAAY,QAAQ,KAAK,IAAI;;CAGtI,YAAyC;EAAE,YAAY,CAAC;EAAG,SAAS,CAAC;CAAE;;;;;CAMvE,IAAI,SAAqB;EACxB,IAAI,KAAK,UAAU,OAAO,KAAK;EAC/B,MAAM,MAAM,KAAK,MAAM,MAAM,UAAU;EACvC,OAAQ,IAAI,KAAK,UAAU;GAAE,YAAY,CAAC;GAAG,SAAS,CAAC;EAAE;CAC1D;;CAGA,KAAQ,KAAa,MAAkB;EACtC,IAAI,OAAO,KAAK,KAAK,IAAI,GAAG;EAC5B,IAAI,SAAS,KAAA,GAAW,KAAK,KAAK,IAAI,KAAM,OAAO,KAAK,CAAE;EAC1D,OAAO;CACR;;CAGA,aAA6B;EAC5B,MAAM,SAAS,KAAK;EACpB,KAAK,SAAS,CAAC;EACf,OAAO;CACR;AACD;;;;;;;;AA+BA,SAAgB,eACf,OACA,IACA,MACkB;CAClB,OAAO;EAAS;EAA4B;EAAU;CAAgC;AACvF;;;;;;AAwBA,SAAgB,cACf,KACA,SACA,MACgB;CAChB,OAAO;EAAE;EAAK;EAAS,GAAI,QAAQ,EAAE,KAAK;CAAG;AAC9C;;AAGA,IAAa,aAAa,cAAc,WAAW,SAAS,KAAK,WAAW,CAAC"}

package/dist/rng.d.ts

@@ -10,7 +10,9 @@ export declare class Rng {
     next(): number;
     /** Where it is in its sequence, for a save. `restore` with it carries on with the very same numbers */
     save(): number;
+    /** Sets the generator's state to one taken by `save`, so it goes on with the very same numbers */
     restore(state: number): void;
+    /** A float in [min, max), drawn from the sequence */
     range(min: number, max: number): number;
     /** Integer in [min, max] */
     int(min: number, max: number): number;

package/dist/rng.js

@@ -0,0 +1,40 @@
+//#region src/rng.ts
+/**
+* Small seeded PRNG (mulberry32). The simulation never touches Math.random so runs are reproducible.
+*
+* @beta
+*/
+var Rng = class {
+	state;
+	constructor(seed) {
+		this.state = seed >>> 0;
+	}
+	/** Float in [0, 1) */
+	next() {
+		this.state = this.state + 1831565813 >>> 0;
+		let t = this.state;
+		t = Math.imul(t ^ t >>> 15, t | 1);
+		t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+		return ((t ^ t >>> 14) >>> 0) / 4294967296;
+	}
+	/** Where it is in its sequence, for a save. `restore` with it carries on with the very same numbers */
+	save() {
+		return this.state;
+	}
+	/** Sets the generator's state to one taken by `save`, so it goes on with the very same numbers */
+	restore(state) {
+		this.state = state >>> 0;
+	}
+	/** A float in [min, max), drawn from the sequence */
+	range(min, max) {
+		return min + (max - min) * this.next();
+	}
+	/** Integer in [min, max] */
+	int(min, max) {
+		return Math.floor(this.range(min, max + 1));
+	}
+};
+//#endregion
+export { Rng };
+
+//# sourceMappingURL=rng.js.map

package/dist/rng.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rng.js","names":[],"sources":["../src/rng.ts"],"sourcesContent":["/**\n * Small seeded PRNG (mulberry32). The simulation never touches Math.random so runs are reproducible.\n *\n * @beta\n */\nexport class Rng {\n\tprivate state: number\n\n\tconstructor(seed: number) {\n\t\tthis.state = seed >>> 0\n\t}\n\n\t/** Float in [0, 1) */\n\tnext(): number {\n\t\tthis.state = (this.state + 0x6d2b79f5) >>> 0\n\t\tlet t = this.state\n\t\tt = Math.imul(t ^ (t >>> 15), t | 1)\n\t\tt ^= t + Math.imul(t ^ (t >>> 7), t | 61)\n\t\treturn ((t ^ (t >>> 14)) >>> 0) / 4294967296\n\t}\n\n\t/** Where it is in its sequence, for a save. `restore` with it carries on with the very same numbers */\n\tsave(): number {\n\t\treturn this.state\n\t}\n\n\t/** Sets the generator's state to one taken by `save`, so it goes on with the very same numbers */\n\trestore(state: number): void {\n\t\tthis.state = state >>> 0\n\t}\n\n\t/** A float in [min, max), drawn from the sequence */\n\trange(min: number, max: number): number {\n\t\treturn min + (max - min) * this.next()\n\t}\n\n\t/** Integer in [min, max] */\n\tint(min: number, max: number): number {\n\t\treturn Math.floor(this.range(min, max + 1))\n\t}\n}\n"],"mappings":";;;;;;AAKA,IAAa,MAAb,MAAiB;CAChB;CAEA,YAAY,MAAc;EACzB,KAAK,QAAQ,SAAS;CACvB;;CAGA,OAAe;EACd,KAAK,QAAS,KAAK,QAAQ,eAAgB;EAC3C,IAAI,IAAI,KAAK;EACb,IAAI,KAAK,KAAK,IAAK,MAAM,IAAK,IAAI,CAAC;EACnC,KAAK,IAAI,KAAK,KAAK,IAAK,MAAM,GAAI,IAAI,EAAE;EACxC,SAAS,IAAK,MAAM,QAAS,KAAK;CACnC;;CAGA,OAAe;EACd,OAAO,KAAK;CACb;;CAGA,QAAQ,OAAqB;EAC5B,KAAK,QAAQ,UAAU;CACxB;;CAGA,MAAM,KAAa,KAAqB;EACvC,OAAO,OAAO,MAAM,OAAO,KAAK,KAAK;CACtC;;CAGA,IAAI,KAAa,KAAqB;EACrC,OAAO,KAAK,MAAM,KAAK,MAAM,KAAK,MAAM,CAAC,CAAC;CAC3C;AACD"}