incanto 0.7.0 → 0.8.0

package/dist/index.js

@@ -1,13 +1,128 @@
 import { _ as registerBehavior, a as SCENE_FORMAT, c as SceneTree, d as resolveConstants, f as Node, g as getBehavior, h as clearBehaviors, i as serializeNode, l as CONST_REF_KEY, m as Behavior, n as loadScene, o as computeViewport, p as parseNodePath, r as Scene, s as resolveViewport, u as isConstRef, v as registeredBehaviors, y as Signal } from "./loader-B4OEXDZ8.js";
-import { a as ORDER_GROUP_BASE, c as LogManager, d as isAudioContextAvailable, f as MusicManager, g as AudioBuses, h as fadeGain, i as applyParticlePreset, l as InputMap, m as crossfadeGains, n as PARTICLE_PRESETS, o as effectiveOrder, p as WebAudioMusicBackend, r as PARTICLE_PRESET_NAMES, s as Engine, t as ParticleSim, u as SfxEngine } from "./particle-sim-CrTE7c02.js";
+import { C as crossfadeGains, S as WebAudioMusicBackend, T as AudioBuses, _ as spatialPan, a as HudLayer, b as synthSfx, c as UiText, d as LogManager, f as InputMap, g as spatialGain, h as ROLLOFF_MODELS, i as UiDialogue, l as AudioPlayer, m as isAudioContextAvailable, n as Timer, o as UiBanner, p as SfxEngine, r as UiButton, s as UiBar, t as registerCoreNodes, u as Engine, v as SFX_PRESETS, w as fadeGain, x as MusicManager, y as SFX_PRESET_NAMES } from "./register-DRPIjrKG.js";
 import { t as IncantoError } from "./errors-BpWbnbb_.js";
 import { t as Rng } from "./rng-DP-SR7eg.js";
-import { a as UiBar, c as ROLLOFF_MODELS, d as SFX_PRESETS, f as SFX_PRESET_NAMES, i as UiBanner, l as spatialGain, n as Timer, o as UiText, p as synthSfx, r as HudLayer, s as AudioPlayer, t as registerCoreNodes, u as spatialPan } from "./register-Dl_ixIJe.js";
+import { t as auditScene } from "./audit-C6rMyict.js";
 import { n as jsonEquals, r as jsonKind, t as jsonClone } from "./json-BLk7H2Qa.js";
 import { a as getNodeSignals, c as mergeStaticSignals, i as getNodeSchema, l as registerNode, n as clearRegistry, o as getNodeType, r as createNode, u as registeredTypes } from "./registry-BVJ2HbCn.js";
 import { t as createNoise2D } from "./noise-CGUMx44x.js";
+import { a as ORDER_GROUP_BASE, i as applyParticlePreset, n as PARTICLE_PRESETS, o as effectiveOrder, r as PARTICLE_PRESET_NAMES, t as ParticleSim } from "./particle-sim-CyUU7HVU.js";
 import { i as resolveRendering, n as attachTouchControls, r as joystickVector, t as TouchControls } from "./touch-031PxtCR.js";
 import { t as duplicateNode } from "./duplicate-BEvGBtb_.js";
+//#region src/core/pathfinding.ts
+/**
+* A* from `from` to `to` (inclusive cell coords). Returns the cell path
+* INCLUDING both endpoints, or null when unreachable. Straight steps cost
+* 1, diagonals √2; the heuristic is octile (admissible for both modes).
+*/
+function findPath(grid, from, to, opts) {
+	const [sx, sy] = from;
+	const [tx, ty] = to;
+	const { width, height } = grid;
+	const inBounds = (x, y) => x >= 0 && y >= 0 && x < width && y < height;
+	if (!inBounds(sx, sy) || !inBounds(tx, ty)) return null;
+	if (grid.solid(sx, sy) || grid.solid(tx, ty)) return null;
+	if (sx === tx && sy === ty) return [[sx, sy]];
+	const diagonal = opts?.diagonal ?? true;
+	const maxExpansions = opts?.maxExpansions ?? 2e4;
+	const idx = (x, y) => y * width + x;
+	const gScore = new Float64Array(width * height).fill(Number.POSITIVE_INFINITY);
+	const cameFrom = new Int32Array(width * height).fill(-1);
+	const closed = new Uint8Array(width * height);
+	const heap = [];
+	const fScore = new Float64Array(width * height).fill(Number.POSITIVE_INFINITY);
+	const push = (n) => {
+		heap.push(n);
+		let i = heap.length - 1;
+		while (i > 0) {
+			const p = i - 1 >> 1;
+			if (fScore[heap[p]] <= fScore[heap[i]]) break;
+			const t = heap[p];
+			heap[p] = heap[i];
+			heap[i] = t;
+			i = p;
+		}
+	};
+	const pop = () => {
+		const top = heap[0];
+		const last = heap.pop();
+		if (heap.length > 0) {
+			heap[0] = last;
+			let i = 0;
+			for (;;) {
+				const l = i * 2 + 1;
+				const r = l + 1;
+				let m = i;
+				if (l < heap.length && fScore[heap[l]] < fScore[heap[m]]) m = l;
+				if (r < heap.length && fScore[heap[r]] < fScore[heap[m]]) m = r;
+				if (m === i) break;
+				const t = heap[m];
+				heap[m] = heap[i];
+				heap[i] = t;
+				i = m;
+			}
+		}
+		return top;
+	};
+	const SQRT2 = Math.SQRT2;
+	const octile = (x, y) => {
+		const dx = Math.abs(x - tx);
+		const dy = Math.abs(y - ty);
+		return dx > dy ? dx - dy + SQRT2 * dy : dy - dx + SQRT2 * dx;
+	};
+	const start = idx(sx, sy);
+	gScore[start] = 0;
+	fScore[start] = octile(sx, sy);
+	push(start);
+	let expansions = 0;
+	while (heap.length > 0) {
+		if (++expansions > maxExpansions) return null;
+		const current = pop();
+		if (closed[current]) continue;
+		closed[current] = 1;
+		const cx = current % width;
+		const cy = current / width | 0;
+		if (cx === tx && cy === ty) {
+			const path = [];
+			let n = current;
+			while (n !== -1) {
+				path.push([n % width, n / width | 0]);
+				n = cameFrom[n];
+			}
+			path.reverse();
+			return path;
+		}
+		for (let dy = -1; dy <= 1; dy++) for (let dx = -1; dx <= 1; dx++) {
+			if (dx === 0 && dy === 0) continue;
+			const isDiag = dx !== 0 && dy !== 0;
+			if (isDiag && !diagonal) continue;
+			const nx = cx + dx;
+			const ny = cy + dy;
+			if (!inBounds(nx, ny) || grid.solid(nx, ny)) continue;
+			if (isDiag && (grid.solid(cx + dx, cy) || grid.solid(cx, cy + dy))) continue;
+			const n = idx(nx, ny);
+			if (closed[n]) continue;
+			const tentative = gScore[current] + (isDiag ? SQRT2 : 1);
+			if (tentative < gScore[n]) {
+				gScore[n] = tentative;
+				fScore[n] = tentative + octile(nx, ny);
+				cameFrom[n] = current;
+				push(n);
+			}
+		}
+	}
+	return null;
+}
+/** Build a PathGrid from row-strings ('#' = solid) — tests and tile games. */
+function gridFromRows(rows) {
+	const height = rows.length;
+	return {
+		width: rows[0]?.length ?? 0,
+		height,
+		solid: (x, y) => (rows[y]?.[x] ?? "#") === "#"
+	};
+}
+//#endregion
 //#region src/core/preload.ts
 /**
 * Warm the HTTP cache for a list of asset urls with a progress callback —
@@ -40,6 +155,76 @@ function assetUrls(assets) {
 	return Object.values(assets ?? {}).map((a) => a.url).filter((u) => typeof u === "string" && !u.startsWith("data:"));
 }
 //#endregion
+//#region src/core/replay.ts
+const RECORDED_METHODS = [
+	"handleKey",
+	"handleMouseButton",
+	"handlePointerMove",
+	"handleWheel",
+	"pressAction",
+	"releaseAction"
+];
+/**
+* Tap the engine's input entry points and tick clock. Recording starts at
+* the CURRENT moment — start it before the first tick for full-run replays.
+*/
+function startRecording(engine) {
+	const ticks = [];
+	const events = [];
+	const input = engine.input;
+	const originals = /* @__PURE__ */ new Map();
+	for (const name of RECORDED_METHODS) {
+		const original = input[name];
+		originals.set(name, original);
+		input[name] = (...args) => {
+			events.push([
+				ticks.length,
+				name,
+				...args
+			]);
+			return original.apply(engine.input, args);
+		};
+	}
+	const originalTick = engine.tick.bind(engine);
+	const engineAny = engine;
+	engineAny.tick = (nowMs) => {
+		ticks.push(nowMs);
+		originalTick(nowMs);
+	};
+	let stopped = false;
+	return { stop() {
+		if (!stopped) {
+			stopped = true;
+			for (const [name, fn] of originals) input[name] = fn;
+			engineAny.tick = originalTick;
+		}
+		return {
+			replay: 1,
+			ticks,
+			events
+		};
+	} };
+}
+/**
+* Drive a fresh engine through a recording: for each recorded tick, feed
+* that tick's input events first, then tick with the recorded timestamp.
+* `onTick(index)` lets tests assert mid-run state.
+*/
+function replay(engine, recording, opts) {
+	const input = engine.input;
+	let cursor = 0;
+	for (let i = 0; i < recording.ticks.length; i++) {
+		while (cursor < recording.events.length && recording.events[cursor][0] === i) {
+			const [, method, ...args] = recording.events[cursor];
+			const fn = input[method];
+			if (typeof fn === "function") fn.apply(engine.input, args);
+			cursor += 1;
+		}
+		engine.tick(recording.ticks[i]);
+		opts?.onTick?.(i);
+	}
+}
+//#endregion
 //#region src/core/save.ts
 const memoryStores = /* @__PURE__ */ new Map();
 function createSaveStore(namespace) {
@@ -110,6 +295,6 @@ function newUid() {
 //#endregion
 //#region src/index.ts
 /** Engine version. Kept in sync with package.json by the release pipeline. */
-const VERSION = "0.7.0";
+const VERSION = "0.8.0";
 //#endregion
-export { AudioBuses, AudioPlayer, Behavior, CONST_REF_KEY, Engine, HudLayer, IncantoError, InputMap, LogManager, MusicManager, Node, ORDER_GROUP_BASE, PARTICLE_PRESETS, PARTICLE_PRESET_NAMES, ParticleSim, ROLLOFF_MODELS, Rng, SCENE_FORMAT, SFX_PRESETS, SFX_PRESET_NAMES, Scene, SceneTree, SfxEngine, Signal, Timer, TouchControls, UiBanner, UiBar, UiText, VERSION, WebAudioMusicBackend, applyParticlePreset, assetUrls, attachTouchControls, clearBehaviors, clearRegistry, computeViewport, createNode, createNoise2D, createSaveStore, crossfadeGains, duplicateNode, effectiveOrder, fadeGain, getBehavior, getNodeSchema, getNodeSignals, getNodeType, isAudioContextAvailable, isConstRef, joystickVector, jsonClone, jsonEquals, jsonKind, loadScene, mergeStaticSignals, newUid, parseNodePath, preloadUrls, registerBehavior, registerCoreNodes, registerNode, registeredBehaviors, registeredTypes, resolveConstants, resolveRendering, resolveViewport, serializeNode, spatialGain, spatialPan, synthSfx };
+export { AudioBuses, AudioPlayer, Behavior, CONST_REF_KEY, Engine, HudLayer, IncantoError, InputMap, LogManager, MusicManager, Node, ORDER_GROUP_BASE, PARTICLE_PRESETS, PARTICLE_PRESET_NAMES, ParticleSim, ROLLOFF_MODELS, Rng, SCENE_FORMAT, SFX_PRESETS, SFX_PRESET_NAMES, Scene, SceneTree, SfxEngine, Signal, Timer, TouchControls, UiBanner, UiBar, UiButton, UiDialogue, UiText, VERSION, WebAudioMusicBackend, applyParticlePreset, assetUrls, attachTouchControls, auditScene, clearBehaviors, clearRegistry, computeViewport, createNode, createNoise2D, createSaveStore, crossfadeGains, duplicateNode, effectiveOrder, fadeGain, findPath, getBehavior, getNodeSchema, getNodeSignals, getNodeType, gridFromRows, isAudioContextAvailable, isConstRef, joystickVector, jsonClone, jsonEquals, jsonKind, loadScene, mergeStaticSignals, newUid, parseNodePath, preloadUrls, registerBehavior, registerCoreNodes, registerNode, registeredBehaviors, registeredTypes, replay, resolveConstants, resolveRendering, resolveViewport, serializeNode, spatialGain, spatialPan, startRecording, synthSfx };

package/dist/{loader-y_X4zYO0.d.ts → loader-BcUDfNHn.d.ts}

@@ -1,5 +1,5 @@
 import { i as SceneJson } from "./schema-CcoWb32N.js";
-import { v as Engine, w as Scene } from "./behavior-e3kAmPGC.js";
+import { v as Engine, w as Scene } from "./behavior-Bod1AyJS.js";
 
 //#region src/core/scene/loader.d.ts
 interface LoadSceneOptions {

package/dist/net.d.ts

@@ -1,5 +1,5 @@
 import { c as JsonValue, i as SceneJson, s as JsonObject } from "./schema-CcoWb32N.js";
-import { T as Node, et as Signal, l as PropSchema, v as Engine } from "./behavior-e3kAmPGC.js";
+import { $ as Node, l as PropSchema, tt as Signal, v as Engine } from "./behavior-Bod1AyJS.js";
 
 //#region src/net/types.d.ts
 type Unsubscribe = () => void;
@@ -424,4 +424,48 @@ declare class NetworkSpawner extends Node {
 */
 declare function registerNodesNet(): void;
 //#endregion
-export { type CollectionOptions, LocalGameServer, type LocalGameServerOptions, LocalGameServerTransport, LoopbackHub, LoopbackTransport, NetworkManager, type NetworkManagerOptions, NetworkSpawner, type NetworkTransport, type ServerClass, type Unsubscribe, applySyncPatch, createAgent8Server, createLocalGameServer, registerNodesNet };
+//#region src/net/split-screen.d.ts
+interface SplitScreenPlayer {
+  account: string;
+  engine: Engine;
+  manager: NetworkManager;
+}
+interface SplitScreenOptions extends LocalGameServerOptions {
+  /** The shared scene JSON every panel loads. */
+  scene: SceneJson;
+  /** Player accounts, one panel each (default ['p1', 'p2']). */
+  accounts?: string[];
+  /** Called per player to finish wiring (renderer, input, HUD). */
+  setup: (player: SplitScreenPlayer, index: number) => void | Promise<void>;
+  /** name → scene JSON registered on every panel's NetworkManager. */
+  scenes?: Record<string, SceneJson>;
+  /** Engine seed base (each panel gets seed + index). */
+  seed?: number;
+}
+/**
+* N local clients on ONE page sharing ONE in-memory game server — the
+* split-screen preview harness three examples were hand-wiring (~40 lines
+* each). Wires: LocalGameServer + per-player Engine/scene/NetworkManager +
+* the server tick driven from the first panel's clock.
+*
+*   const { players, server } = await createSplitScreen({
+*     scene: gameJson,
+*     server: MyServerClass,
+*     scenes: { 'remote-player': remoteJson },
+*     setup: ({ engine }, i) => {
+*       new Renderer2D({ canvas: canvases[i], engine });
+*       engine.input.attachKeyboard(window);
+*       engine.start();
+*     },
+*   });
+*
+* Going live stays the one-line story: replace the transport with
+* `createAgent8Server()` and boot ONE client per browser.
+*/
+declare function createSplitScreen(opts: SplitScreenOptions): Promise<{
+  server: ReturnType<typeof createLocalGameServer>;
+  players: SplitScreenPlayer[];
+  dispose(): void;
+}>;
+//#endregion
+export { type CollectionOptions, LocalGameServer, type LocalGameServerOptions, LocalGameServerTransport, LoopbackHub, LoopbackTransport, NetworkManager, type NetworkManagerOptions, NetworkSpawner, type NetworkTransport, type ServerClass, type SplitScreenOptions, type SplitScreenPlayer, type Unsubscribe, applySyncPatch, createAgent8Server, createLocalGameServer, createSplitScreen, registerNodesNet };

package/dist/net.js

@@ -1,7 +1,9 @@
+import { n as loadScene } from "./loader-B4OEXDZ8.js";
+import { u as Engine } from "./register-DRPIjrKG.js";
 import { t as IncantoError } from "./errors-BpWbnbb_.js";
 import { t as jsonClone } from "./json-BLk7H2Qa.js";
 import { n as createAgent8Server } from "./agent8-CvsfVskX.js";
-import { i as applySyncPatch, n as NetworkSpawner, r as NetworkManager, t as registerNodesNet } from "./register-C35HDZpm.js";
+import { i as applySyncPatch, n as NetworkSpawner, r as NetworkManager, t as registerNodesNet } from "./register-CxmuI9FL.js";
 //#region src/net/loopback.ts
 /**
 * In-memory multiplayer hub implementing the SAME kernel contract as
@@ -769,4 +771,54 @@ var LocalGameServerTransport = class {
 	}
 };
 //#endregion
-export { LocalGameServer, LocalGameServerTransport, LoopbackHub, LoopbackTransport, NetworkManager, NetworkSpawner, applySyncPatch, createAgent8Server, createLocalGameServer, registerNodesNet };
+//#region src/net/split-screen.ts
+/**
+* N local clients on ONE page sharing ONE in-memory game server — the
+* split-screen preview harness three examples were hand-wiring (~40 lines
+* each). Wires: LocalGameServer + per-player Engine/scene/NetworkManager +
+* the server tick driven from the first panel's clock.
+*
+*   const { players, server } = await createSplitScreen({
+*     scene: gameJson,
+*     server: MyServerClass,
+*     scenes: { 'remote-player': remoteJson },
+*     setup: ({ engine }, i) => {
+*       new Renderer2D({ canvas: canvases[i], engine });
+*       engine.input.attachKeyboard(window);
+*       engine.start();
+*     },
+*   });
+*
+* Going live stays the one-line story: replace the transport with
+* `createAgent8Server()` and boot ONE client per browser.
+*/
+async function createSplitScreen(opts) {
+	const server = createLocalGameServer(opts);
+	const accounts = opts.accounts ?? ["p1", "p2"];
+	const players = [];
+	for (let i = 0; i < accounts.length; i++) {
+		const account = accounts[i];
+		const engine = new Engine(opts.seed !== void 0 ? { seed: opts.seed + i } : {});
+		engine.setScene(loadScene(jsonClone(opts.scene)));
+		const manager = await NetworkManager.create(engine, { transport: server.createClient(account) });
+		for (const [name, json] of Object.entries(opts.scenes ?? {})) manager.registerScene(name, json);
+		const player = {
+			account,
+			engine,
+			manager
+		};
+		players.push(player);
+		await opts.setup(player, i);
+	}
+	const disconnect = (players[0]?.engine)?.updated.connect((dt) => void server.tick(Math.min(dt, .05) * 1e3));
+	return {
+		server,
+		players,
+		dispose() {
+			disconnect?.();
+			for (const p of players) p.engine.dispose?.();
+		}
+	};
+}
+//#endregion
+export { LocalGameServer, LocalGameServerTransport, LoopbackHub, LoopbackTransport, NetworkManager, NetworkSpawner, applySyncPatch, createAgent8Server, createLocalGameServer, createSplitScreen, registerNodesNet };

package/dist/particle-sim-CyUU7HVU.js

@@ -0,0 +1,281 @@
+import { n as jsonEquals } from "./json-BLk7H2Qa.js";
+//#region src/core/order-groups.ts
+const ORDER_GROUP_BASE = {
+	background: -2e3,
+	terrain: -1e3,
+	default: 0,
+	characters: 1e3,
+	effects: 2e3,
+	overlay: 3e3
+};
+/** base + fine offset (unknown group names fall back to `default`). */
+function effectiveOrder(group, renderOrder) {
+	return (ORDER_GROUP_BASE[group] ?? 0) + renderOrder;
+}
+//#endregion
+//#region src/core/particle-presets.ts
+const PARTICLE_PRESETS = {
+	fire: {
+		rate: 60,
+		lifetime: [.4, .9],
+		speed: [30, 70],
+		directionDeg: -90,
+		spreadDeg: 35,
+		gravity: [0, -30],
+		sizeStart: 14,
+		sizeEnd: 3,
+		colorStart: "#ffcf5a",
+		colorEnd: "#e8401f",
+		alphaStart: .9,
+		alphaEnd: 0,
+		blend: "add"
+	},
+	smoke: {
+		rate: 20,
+		lifetime: [1.5, 2.5],
+		speed: [10, 25],
+		directionDeg: -90,
+		spreadDeg: 40,
+		gravity: [0, -12],
+		sizeStart: 10,
+		sizeEnd: 26,
+		colorStart: "#8a8a8a",
+		colorEnd: "#3a3a3a",
+		alphaStart: .35,
+		alphaEnd: 0,
+		blend: "normal"
+	},
+	sparks: {
+		rate: 80,
+		lifetime: [.3, .7],
+		speed: [120, 260],
+		spreadDeg: 360,
+		gravity: [0, 240],
+		drag: 1,
+		sizeStart: 4,
+		sizeEnd: 1,
+		colorStart: "#fff3b0",
+		colorEnd: "#ff9d2e",
+		blend: "add"
+	},
+	fireworks: {
+		rate: 0,
+		burst: 120,
+		lifetime: [.8, 1.6],
+		speed: [80, 240],
+		spreadDeg: 360,
+		gravity: [0, 90],
+		drag: .6,
+		sizeStart: 5,
+		sizeEnd: 1,
+		colorStart: "#9ad8ff",
+		colorEnd: "#ff5ad8",
+		blend: "add"
+	},
+	explosion: {
+		rate: 0,
+		burst: 60,
+		lifetime: [.25, .6],
+		speed: [150, 420],
+		spreadDeg: 360,
+		drag: 3,
+		sizeStart: 16,
+		sizeEnd: 2,
+		colorStart: "#ffe08a",
+		colorEnd: "#ff3b1f",
+		blend: "add"
+	},
+	flash: {
+		rate: 0,
+		burst: 8,
+		lifetime: [.08, .16],
+		speed: [0, 30],
+		spreadDeg: 360,
+		sizeStart: 64,
+		sizeEnd: 96,
+		colorStart: "#ffffff",
+		colorEnd: "#ffffff",
+		alphaStart: 1,
+		alphaEnd: 0,
+		blend: "add"
+	},
+	lightning: {
+		rate: 90,
+		lifetime: [.05, .12],
+		speed: [400, 900],
+		directionDeg: -90,
+		spreadDeg: 14,
+		sizeStart: 6,
+		sizeEnd: 2,
+		colorStart: "#eaf2ff",
+		colorEnd: "#7fb4ff",
+		blend: "add"
+	},
+	rain: {
+		rate: 160,
+		lifetime: [.8, 1.2],
+		speed: [300, 420],
+		directionDeg: 90,
+		spreadDeg: 6,
+		sizeStart: 3,
+		sizeEnd: 3,
+		colorStart: "#9ec8ff",
+		colorEnd: "#9ec8ff",
+		alphaStart: .5,
+		alphaEnd: .2,
+		blend: "normal"
+	},
+	snow: {
+		rate: 40,
+		lifetime: [3, 5],
+		speed: [20, 50],
+		directionDeg: 90,
+		spreadDeg: 30,
+		drag: .2,
+		sizeStart: 5,
+		sizeEnd: 4,
+		colorStart: "#ffffff",
+		colorEnd: "#ffffff",
+		alphaStart: .9,
+		alphaEnd: .6,
+		blend: "normal"
+	},
+	magic: {
+		rate: 50,
+		lifetime: [.6, 1.4],
+		speed: [20, 80],
+		spreadDeg: 360,
+		gravity: [0, -20],
+		sizeStart: 7,
+		sizeEnd: 1,
+		colorStart: "#9dffe8",
+		colorEnd: "#7a5cff",
+		blend: "add"
+	}
+};
+const PARTICLE_PRESET_NAMES = Object.keys(PARTICLE_PRESETS);
+/**
+* Apply the delta rule across three layers: schema default < preset < the
+* scene's explicit props. A prop still equal to its SCHEMA default is
+* considered "unset" and takes the preset value.
+*/
+function applyParticlePreset(target, presetName, schema) {
+	if (presetName === "custom") return;
+	const preset = PARTICLE_PRESETS[presetName];
+	if (!preset) return;
+	for (const [key, presetValue] of Object.entries(preset)) {
+		const def = schema[key]?.default;
+		const current = target[key];
+		if (def !== void 0 && jsonEquals(current, def)) target[key] = Array.isArray(presetValue) ? [...presetValue] : presetValue;
+	}
+}
+//#endregion
+//#region src/core/particle-sim.ts
+const FIELDS = 9;
+var ParticleSim = class {
+	config;
+	rng;
+	data;
+	alive = 0;
+	spawnAccumulator = 0;
+	everSpawned = false;
+	constructor(config, rng) {
+		this.config = config;
+		this.rng = rng;
+		this.data = new Float64Array(Math.max(1, config.maxParticles) * FIELDS);
+	}
+	/** Change the emission rate LIVE (particles/sec; 0 pauses emission) — lets an
+	* emitter toggle on/off at runtime (drift smoke, throttle flames). */
+	setRate(rate) {
+		this.config.rate = rate;
+		if (rate <= 0) this.spawnAccumulator = 0;
+	}
+	get count() {
+		return this.alive;
+	}
+	/** True when nothing is alive and at least one particle has ever spawned. */
+	get done() {
+		return this.everSpawned && this.alive === 0;
+	}
+	/** Spawn n particles immediately (fireworks, explosions, flashes). */
+	burst(n) {
+		for (let i = 0; i < n; i++) this.spawn();
+	}
+	update(dt) {
+		if (this.config.rate > 0) {
+			this.spawnAccumulator += this.config.rate * dt;
+			while (this.spawnAccumulator >= 1) {
+				this.spawnAccumulator -= 1;
+				this.spawn();
+			}
+		}
+		const d = this.data;
+		const [gx, gy, gz] = this.config.gravity;
+		const damp = this.config.drag > 0 ? Math.exp(-this.config.drag * dt) : 1;
+		let i = 0;
+		while (i < this.alive) {
+			const base = i * FIELDS;
+			const age = d[base + 6] + dt;
+			if (age >= d[base + 7]) {
+				this.kill(i);
+				continue;
+			}
+			d[base + 6] = age;
+			d[base + 3] = (d[base + 3] + gx * dt) * damp;
+			d[base + 4] = (d[base + 4] + gy * dt) * damp;
+			d[base + 5] = (d[base + 5] + gz * dt) * damp;
+			d[base + 0] = d[base + 0] + d[base + 3] * dt;
+			d[base + 1] = d[base + 1] + d[base + 4] * dt;
+			d[base + 2] = d[base + 2] + d[base + 5] * dt;
+			i += 1;
+		}
+	}
+	forEach(fn) {
+		const d = this.data;
+		for (let i = 0; i < this.alive; i++) {
+			const base = i * FIELDS;
+			const age = d[base + 6];
+			const life = d[base + 7];
+			fn({
+				x: d[base + 0],
+				y: d[base + 1],
+				z: d[base + 2],
+				vx: d[base + 3],
+				vy: d[base + 4],
+				vz: d[base + 5],
+				age,
+				life,
+				t: life > 0 ? age / life : 1,
+				seed: d[base + 8]
+			});
+		}
+	}
+	spawn() {
+		if (this.alive >= this.config.maxParticles) return;
+		const base = this.alive * FIELDS;
+		const d = this.data;
+		const c = this.config;
+		const angle = (c.directionDeg + (this.rng.next() - .5) * c.spreadDeg) * Math.PI / 180;
+		const speed = c.speed[0] + this.rng.next() * (c.speed[1] - c.speed[0]);
+		const zTilt = c.spreadZ ? (this.rng.next() - .5) * (c.spreadDeg * Math.PI / 180) : 0;
+		const planar = Math.cos(zTilt);
+		d[base + 0] = 0;
+		d[base + 1] = 0;
+		d[base + 2] = 0;
+		d[base + 3] = Math.cos(angle) * speed * planar;
+		d[base + 4] = Math.sin(angle) * speed * planar;
+		d[base + 5] = Math.sin(zTilt) * speed;
+		d[base + 6] = 0;
+		d[base + 7] = c.lifetime[0] + this.rng.next() * (c.lifetime[1] - c.lifetime[0]);
+		d[base + 8] = this.rng.next();
+		this.alive += 1;
+		this.everSpawned = true;
+	}
+	kill(index) {
+		const last = this.alive - 1;
+		if (index !== last) this.data.copyWithin(index * FIELDS, last * FIELDS, last * FIELDS + FIELDS);
+		this.alive = last;
+	}
+};
+//#endregion
+export { ORDER_GROUP_BASE as a, applyParticlePreset as i, PARTICLE_PRESETS as n, effectiveOrder as o, PARTICLE_PRESET_NAMES as r, ParticleSim as t };