@zylem/game-lib 0.3.15 → 0.3.17

package/dist/lib/input/input-manager.js

@@ -0,0 +1,70 @@
+import { KeyboardProvider as s } from "./keyboard-provider.js";
+import { GamepadProvider as r } from "./gamepad-provider.js";
+class B {
+  inputMap = /* @__PURE__ */ new Map();
+  currentInputs = {};
+  previousInputs = {};
+  constructor(t) {
+    t?.p1?.key ? this.addInputProvider(1, new s(t.p1.key, { includeDefaultBase: !1 })) : this.addInputProvider(1, new s()), this.addInputProvider(1, new r(0)), t?.p2?.key && this.addInputProvider(2, new s(t.p2.key, { includeDefaultBase: !1 })), this.addInputProvider(2, new r(1)), t?.p3?.key && this.addInputProvider(3, new s(t.p3.key, { includeDefaultBase: !1 })), this.addInputProvider(3, new r(2)), t?.p4?.key && this.addInputProvider(4, new s(t.p4.key, { includeDefaultBase: !1 })), this.addInputProvider(4, new r(3)), t?.p5?.key && this.addInputProvider(5, new s(t.p5.key, { includeDefaultBase: !1 })), this.addInputProvider(5, new r(4)), t?.p6?.key && this.addInputProvider(6, new s(t.p6.key, { includeDefaultBase: !1 })), this.addInputProvider(6, new r(5)), t?.p7?.key && this.addInputProvider(7, new s(t.p7.key, { includeDefaultBase: !1 })), this.addInputProvider(7, new r(6)), t?.p8?.key && this.addInputProvider(8, new s(t.p8.key, { includeDefaultBase: !1 })), this.addInputProvider(8, new r(7));
+  }
+  addInputProvider(t, e) {
+    this.inputMap.has(t) || this.inputMap.set(t, []), this.inputMap.get(t)?.push(e);
+  }
+  getInputs(t) {
+    const e = {};
+    return this.inputMap.forEach((i, n) => {
+      const u = `p${n}`, d = i.reduce((a, o) => {
+        const p = o.getInput(t);
+        return this.mergeInputs(a, p);
+      }, {});
+      e[u] = {
+        playerNumber: n,
+        ...d
+      };
+    }), e;
+  }
+  mergeButtonState(t, e) {
+    return {
+      pressed: t?.pressed || e?.pressed || !1,
+      released: t?.released || e?.released || !1,
+      held: (t?.held || 0) + (e?.held || 0)
+    };
+  }
+  mergeAnalogState(t, e) {
+    return {
+      value: (t?.value || 0) + (e?.value || 0),
+      held: (t?.held || 0) + (e?.held || 0)
+    };
+  }
+  mergeInputs(t, e) {
+    return {
+      buttons: {
+        A: this.mergeButtonState(t.buttons?.A, e.buttons?.A),
+        B: this.mergeButtonState(t.buttons?.B, e.buttons?.B),
+        X: this.mergeButtonState(t.buttons?.X, e.buttons?.X),
+        Y: this.mergeButtonState(t.buttons?.Y, e.buttons?.Y),
+        Start: this.mergeButtonState(t.buttons?.Start, e.buttons?.Start),
+        Select: this.mergeButtonState(t.buttons?.Select, e.buttons?.Select),
+        L: this.mergeButtonState(t.buttons?.L, e.buttons?.L),
+        R: this.mergeButtonState(t.buttons?.R, e.buttons?.R)
+      },
+      directions: {
+        Up: this.mergeButtonState(t.directions?.Up, e.directions?.Up),
+        Down: this.mergeButtonState(t.directions?.Down, e.directions?.Down),
+        Left: this.mergeButtonState(t.directions?.Left, e.directions?.Left),
+        Right: this.mergeButtonState(t.directions?.Right, e.directions?.Right)
+      },
+      axes: {
+        Horizontal: this.mergeAnalogState(t.axes?.Horizontal, e.axes?.Horizontal),
+        Vertical: this.mergeAnalogState(t.axes?.Vertical, e.axes?.Vertical)
+      },
+      shoulders: {
+        LTrigger: this.mergeButtonState(t.shoulders?.LTrigger, e.shoulders?.LTrigger),
+        RTrigger: this.mergeButtonState(t.shoulders?.RTrigger, e.shoulders?.RTrigger)
+      }
+    };
+  }
+}
+export {
+  B as InputManager
+};

package/dist/lib/input/keyboard-provider.js

@@ -0,0 +1,120 @@
+class p {
+  keyStates = /* @__PURE__ */ new Map();
+  keyButtonStates = /* @__PURE__ */ new Map();
+  mapping = null;
+  includeDefaultBase = !0;
+  constructor(t, s) {
+    this.mapping = t ?? null, this.includeDefaultBase = s?.includeDefaultBase ?? !0, window.addEventListener("keydown", ({ key: e }) => this.keyStates.set(e, !0)), window.addEventListener("keyup", ({ key: e }) => this.keyStates.set(e, !1));
+  }
+  isKeyPressed(t) {
+    return this.keyStates.get(t) || !1;
+  }
+  handleButtonState(t, s) {
+    let e = this.keyButtonStates.get(t);
+    const o = this.isKeyPressed(t);
+    return e || (e = { pressed: !1, released: !1, held: 0 }, this.keyButtonStates.set(t, e)), o ? (e.held === 0 ? e.pressed = !0 : e.pressed = !1, e.held += s, e.released = !1) : (e.held > 0 ? (e.released = !0, e.held = 0) : e.released = !1, e.pressed = !1), e;
+  }
+  handleAnalogState(t, s, e) {
+    return { value: this.getAxisValue(t, s), held: e };
+  }
+  mergeButtonState(t, s) {
+    return {
+      pressed: t?.pressed || s?.pressed || !1,
+      released: t?.released || s?.released || !1,
+      held: (t?.held || 0) + (s?.held || 0)
+    };
+  }
+  applyCustomMapping(t, s) {
+    if (!this.mapping)
+      return t;
+    for (const [e, o] of Object.entries(this.mapping)) {
+      if (!o || o.length === 0)
+        continue;
+      const a = this.handleButtonState(e, s);
+      for (const c of o) {
+        const [u, l] = (c || "").split(".");
+        if (!u || !l)
+          continue;
+        const i = u.toLowerCase(), h = l.toLowerCase();
+        if (i === "buttons") {
+          const n = {
+            a: "A",
+            b: "B",
+            x: "X",
+            y: "Y",
+            start: "Start",
+            select: "Select",
+            l: "L",
+            r: "R"
+          }[h];
+          if (!n)
+            continue;
+          const r = t.buttons || {};
+          r[n] = this.mergeButtonState(r[n], a), t.buttons = r;
+          continue;
+        }
+        if (i === "directions") {
+          const n = {
+            up: "Up",
+            down: "Down",
+            left: "Left",
+            right: "Right"
+          }[h];
+          if (!n)
+            continue;
+          const r = t.directions || {};
+          r[n] = this.mergeButtonState(r[n], a), t.directions = r;
+          continue;
+        }
+        if (i === "shoulders") {
+          const n = {
+            ltrigger: "LTrigger",
+            rtrigger: "RTrigger"
+          }[h];
+          if (!n)
+            continue;
+          const r = t.shoulders || {};
+          r[n] = this.mergeButtonState(r[n], a), t.shoulders = r;
+          continue;
+        }
+      }
+    }
+    return t;
+  }
+  getInput(t) {
+    const s = {};
+    return this.includeDefaultBase && (s.buttons = {
+      A: this.handleButtonState("z", t),
+      B: this.handleButtonState("x", t),
+      X: this.handleButtonState("a", t),
+      Y: this.handleButtonState("s", t),
+      Start: this.handleButtonState(" ", t),
+      Select: this.handleButtonState("Enter", t),
+      L: this.handleButtonState("q", t),
+      R: this.handleButtonState("e", t)
+    }, s.directions = {
+      Up: this.handleButtonState("ArrowUp", t),
+      Down: this.handleButtonState("ArrowDown", t),
+      Left: this.handleButtonState("ArrowLeft", t),
+      Right: this.handleButtonState("ArrowRight", t)
+    }, s.axes = {
+      Horizontal: this.handleAnalogState("ArrowLeft", "ArrowRight", t),
+      Vertical: this.handleAnalogState("ArrowUp", "ArrowDown", t)
+    }, s.shoulders = {
+      LTrigger: this.handleButtonState("Q", t),
+      RTrigger: this.handleButtonState("E", t)
+    }), this.applyCustomMapping(s, t);
+  }
+  getName() {
+    return "keyboard";
+  }
+  getAxisValue(t, s) {
+    return (this.isKeyPressed(s) ? 1 : 0) - (this.isKeyPressed(t) ? 1 : 0);
+  }
+  isConnected() {
+    return !0;
+  }
+}
+export {
+  p as KeyboardProvider
+};

package/dist/lib/stage/debug-entity-cursor.js

@@ -0,0 +1,53 @@
+import { Color as r, Box3 as h, Vector3 as s, BoxGeometry as n, Mesh as a, MeshBasicMaterial as l, EdgesGeometry as o, LineSegments as c, LineBasicMaterial as d, Group as m } from "three";
+class u {
+  scene;
+  container;
+  fillMesh;
+  edgeLines;
+  currentColor = new r(65280);
+  bbox = new h();
+  size = new s();
+  center = new s();
+  constructor(e) {
+    this.scene = e;
+    const i = new n(1, 1, 1);
+    this.fillMesh = new a(i, new l({
+      color: this.currentColor,
+      transparent: !0,
+      opacity: 0.12,
+      depthWrite: !1
+    }));
+    const t = new o(i);
+    this.edgeLines = new c(t, new d({ color: this.currentColor, linewidth: 1 })), this.container = new m(), this.container.name = "DebugEntityCursor", this.container.add(this.fillMesh), this.container.add(this.edgeLines), this.container.visible = !1, this.scene.add(this.container);
+  }
+  setColor(e) {
+    this.currentColor.set(e), this.fillMesh.material.color.set(this.currentColor), this.edgeLines.material.color.set(this.currentColor);
+  }
+  /**
+   * Update the cursor to enclose the provided Object3D using a world-space AABB.
+   */
+  updateFromObject(e) {
+    if (!e) {
+      this.hide();
+      return;
+    }
+    if (this.bbox.setFromObject(e), !isFinite(this.bbox.min.x) || !isFinite(this.bbox.max.x)) {
+      this.hide();
+      return;
+    }
+    this.bbox.getSize(this.size), this.bbox.getCenter(this.center);
+    const i = new n(Math.max(this.size.x, 1e-6), Math.max(this.size.y, 1e-6), Math.max(this.size.z, 1e-6));
+    this.fillMesh.geometry.dispose(), this.fillMesh.geometry = i;
+    const t = new o(i);
+    this.edgeLines.geometry.dispose(), this.edgeLines.geometry = t, this.container.position.copy(this.center), this.container.visible = !0;
+  }
+  hide() {
+    this.container.visible = !1;
+  }
+  dispose() {
+    this.scene.remove(this.container), this.fillMesh.geometry.dispose(), this.fillMesh.material.dispose(), this.edgeLines.geometry.dispose(), this.edgeLines.material.dispose();
+  }
+}
+export {
+  u as DebugEntityCursor
+};

package/dist/lib/stage/entity-spawner.js

@@ -0,0 +1,27 @@
+import { Vector2 as l, Quaternion as m, Euler as p } from "three";
+function b(s) {
+  return {
+    spawn: async (n, r, t) => {
+      const e = await Promise.resolve(s(r, t));
+      return n.add(e), e;
+    },
+    spawnRelative: async (n, r, t = new l(0, 1)) => {
+      if (!n.body) {
+        console.warn("body missing for entity during spawnRelative");
+        return;
+      }
+      const { x: e, y: c, z: u } = n.body.translation();
+      let a = n._rotation2DAngle ?? 0;
+      try {
+        const o = n.body.rotation(), d = new m(o.x, o.y, o.z, o.w);
+        a = new p().setFromQuaternion(d, "XYZ").z;
+      } catch {
+      }
+      const w = Math.sin(-a) * (t.x ?? 0), y = Math.cos(-a) * (t.y ?? 0), i = await Promise.resolve(s(e + w, c + y));
+      return r.add(i), i;
+    }
+  };
+}
+export {
+  b as entitySpawner
+};

package/dist/lib/stage/stage-blueprint.d.ts

@@ -0,0 +1,44 @@
+import type { Stage } from './stage';
+import type { StageOptions, ZylemStageConfig } from './zylem-stage';
+/**
+ * A lightweight, serializable blueprint representing the initial configuration
+ * of a `ZylemStage`. It is intentionally minimal and should not include
+ * entities, functions, or runtime references. Use blueprints only to build
+ * stages.
+ */
+export interface StageBlueprint {
+    id: string;
+    name?: string;
+    config: Partial<ZylemStageConfig>;
+}
+export declare const stageBlueprintsState: {
+    byId: Record<string, StageBlueprint>;
+    order: string[];
+    currentId: string | null;
+};
+/** Reset the blueprints store back to its initial empty state. */
+export declare function resetStageBlueprints(): void;
+/** Create and register a new `StageBlueprint`. */
+export declare function createStageBlueprint(config: Partial<ZylemStageConfig>, options?: {
+    id?: string;
+    name?: string;
+    setCurrent?: boolean;
+}): StageBlueprint;
+/** Upsert a blueprint into the store. */
+export declare function upsertStageBlueprint(blueprint: StageBlueprint): void;
+/** Remove a blueprint by id. */
+export declare function removeStageBlueprint(id: string): void;
+/** Get a blueprint by id. */
+export declare function getStageBlueprint(id: string): StageBlueprint | undefined;
+/** List all blueprints in insertion order. */
+export declare function listStageBlueprints(): StageBlueprint[];
+/** Set the current blueprint id (or clear by passing null). */
+export declare function setCurrentStageBlueprint(id: string | null): void;
+/** Get the current blueprint object, if any. */
+export declare function getCurrentStageBlueprint(): StageBlueprint | null;
+/**
+ * Build a `Stage` instance from a blueprint and optional extra `StageOptions`
+ * (e.g., entities or a camera wrapper). This does not load the stage; callers
+ * should pass the returned `Stage` to the game and call `load` as usual.
+ */
+export declare function buildStageFromBlueprint(input: string | StageBlueprint, ...extras: StageOptions): Stage;

package/dist/lib/stage/stage-blueprint.js

@@ -0,0 +1,56 @@
+import { proxy as d } from "valtio/vanilla";
+import { deepClone as i } from "valtio/utils";
+import { nanoid as c } from "nanoid";
+import { stage as l } from "./stage.js";
+const u = {
+  byId: {},
+  order: [],
+  currentId: null
+}, e = d(i(u));
+function m() {
+  const r = i(u);
+  Object.keys(r).forEach((t) => {
+    e[t] = r[t];
+  });
+}
+function I(r, t) {
+  const n = t?.id ?? c(), o = { id: n, name: t?.name, config: { ...r } };
+  return e.byId[n] = o, e.order.includes(n) || (e.order = [...e.order, n]), t?.setCurrent && (e.currentId = n), o;
+}
+function S(r) {
+  e.byId[r.id] = { ...r, config: { ...r.config } }, e.order.includes(r.id) || (e.order = [...e.order, r.id]);
+}
+function B(r) {
+  delete e.byId[r], e.order = e.order.filter((t) => t !== r), e.currentId === r && (e.currentId = null);
+}
+function f(r) {
+  return e.byId[r];
+}
+function b() {
+  return e.order.map((r) => e.byId[r]).filter((r) => !!r);
+}
+function y(r) {
+  e.currentId = r;
+}
+function C() {
+  const r = e.currentId;
+  return r ? e.byId[r] ?? null : null;
+}
+function h(r, ...t) {
+  const n = typeof r == "string" ? f(r) : r;
+  if (!n)
+    throw new Error("Stage blueprint not found");
+  return l(n.config, ...t);
+}
+export {
+  h as buildStageFromBlueprint,
+  I as createStageBlueprint,
+  C as getCurrentStageBlueprint,
+  f as getStageBlueprint,
+  b as listStageBlueprints,
+  B as removeStageBlueprint,
+  m as resetStageBlueprints,
+  y as setCurrentStageBlueprint,
+  e as stageBlueprintsState,
+  S as upsertStageBlueprint
+};

package/dist/lib/stage/stage-debug-delegate.js

@@ -0,0 +1,100 @@
+import { Ray as b } from "@dimforge/rapier3d-compat";
+import { Vector2 as E, Raycaster as f, LineSegments as L, BufferGeometry as p, LineBasicMaterial as w, BufferAttribute as m } from "three";
+import { debugState as C, getDebugTool as y, setHoveredEntity as D, resetHoveredEntity as v, getHoveredEntity as R, DebugTools as d, setSelectedEntity as T } from "../debug/debug-state.js";
+import { DebugEntityCursor as O } from "./debug-entity-cursor.js";
+const F = 2293538, x = 16724787;
+class A {
+  stage;
+  options;
+  mouseNdc = new E(-2, -2);
+  raycaster = new f();
+  isMouseDown = !1;
+  disposeFns = [];
+  debugCursor = null;
+  debugLines = null;
+  constructor(e, s) {
+    this.stage = e, this.options = {
+      maxRayDistance: s?.maxRayDistance ?? 5e3,
+      addEntityFactory: s?.addEntityFactory ?? null
+    }, this.stage.scene && (this.debugLines = new L(new p(), new w({ vertexColors: !0 })), this.stage.scene.scene.add(this.debugLines), this.debugLines.visible = !0, this.debugCursor = new O(this.stage.scene.scene)), this.attachDomListeners();
+  }
+  update() {
+    if (!C.on || !this.stage.scene || !this.stage.world || !this.stage.cameraRef)
+      return;
+    const { world: e, cameraRef: s } = this.stage;
+    if (this.debugLines) {
+      const { vertices: l, colors: c } = e.world.debugRender();
+      this.debugLines.geometry.setAttribute("position", new m(l, 3)), this.debugLines.geometry.setAttribute("color", new m(c, 4));
+    }
+    const i = y(), n = i === d.SELECT || i === d.DELETE;
+    this.raycaster.setFromCamera(this.mouseNdc, s.camera);
+    const t = this.raycaster.ray.origin.clone(), o = this.raycaster.ray.direction.clone().normalize(), r = new b({ x: t.x, y: t.y, z: t.z }, { x: o.x, y: o.y, z: o.z }), a = e.world.castRay(r, this.options.maxRayDistance, !0);
+    if (a && n) {
+      const c = a.collider?._parent?.userData?.uuid;
+      c ? D(c) : v(), this.isMouseDown && this.handleActionOnHit(c ?? null, t, o, a.toi);
+    }
+    this.isMouseDown = !1;
+    const u = R();
+    if (!u) {
+      this.debugCursor?.hide();
+      return;
+    }
+    const h = this.stage._debugMap.get(`${u}`), g = h?.group ?? h?.mesh ?? null;
+    if (!g) {
+      this.debugCursor?.hide();
+      return;
+    }
+    switch (i) {
+      case d.SELECT:
+        this.debugCursor?.setColor(F);
+        break;
+      case d.DELETE:
+        this.debugCursor?.setColor(x);
+        break;
+      default:
+        this.debugCursor?.setColor(16777215);
+        break;
+    }
+    this.debugCursor?.updateFromObject(g);
+  }
+  dispose() {
+    this.disposeFns.forEach((e) => e()), this.disposeFns = [], this.debugCursor?.dispose(), this.debugLines && this.stage.scene && (this.stage.scene.scene.remove(this.debugLines), this.debugLines.geometry.dispose(), this.debugLines.material.dispose(), this.debugLines = null);
+  }
+  handleActionOnHit(e, s, i, n) {
+    switch (y()) {
+      case "SELECT": {
+        e && T(e);
+        break;
+      }
+      case "DELETE": {
+        e && this.stage.removeEntityByUuid(e);
+        break;
+      }
+      case "ADD": {
+        if (!this.options.addEntityFactory)
+          break;
+        const o = s.clone().add(i.clone().multiplyScalar(n)), r = this.options.addEntityFactory({ position: o });
+        r && Promise.resolve(r).then((a) => {
+          a && this.stage.spawnEntity(a);
+        }).catch(() => {
+        });
+        break;
+      }
+    }
+  }
+  attachDomListeners() {
+    const e = this.stage.cameraRef?.renderer.domElement ?? this.stage.scene?.zylemCamera.renderer.domElement;
+    if (!e)
+      return;
+    const s = (n) => {
+      const t = e.getBoundingClientRect(), o = (n.clientX - t.left) / t.width * 2 - 1, r = -((n.clientY - t.top) / t.height * 2 - 1);
+      this.mouseNdc.set(o, r);
+    }, i = (n) => {
+      this.isMouseDown = !0;
+    };
+    e.addEventListener("mousemove", s), e.addEventListener("mousedown", i), this.disposeFns.push(() => e.removeEventListener("mousemove", s)), this.disposeFns.push(() => e.removeEventListener("mousedown", i));
+  }
+}
+export {
+  A as StageDebugDelegate
+};

package/dist/lib/stage/stage-default.d.ts

@@ -0,0 +1,9 @@
+import type { StageOptions, ZylemStageConfig } from './zylem-stage';
+export declare const stageDefaultsState: Partial<ZylemStageConfig>;
+/** Replace multiple defaults at once (shallow merge). */
+export declare function setStageDefaults(partial: Partial<ZylemStageConfig>): void;
+/** Reset defaults back to library defaults. */
+export declare function resetStageDefaults(): void;
+export declare function getStageOptions(options: StageOptions): StageOptions;
+/** Get a plain object copy of the current defaults. */
+export declare function getStageDefaultConfig(): Partial<ZylemStageConfig>;

package/dist/lib/stage/stage-default.js

@@ -0,0 +1,42 @@
+import { proxy as i } from "valtio/vanilla";
+import { Vector3 as r } from "three";
+import { ZylemBlueColor as g } from "../core/utility/vector.js";
+const o = {
+  backgroundColor: g,
+  backgroundImage: null,
+  inputs: {
+    p1: ["gamepad-1", "keyboard"],
+    p2: ["gamepad-2", "keyboard"]
+  },
+  gravity: new r(0, 0, 0),
+  variables: {}
+}, t = i({
+  ...o
+});
+function b(a) {
+  Object.assign(t, a);
+}
+function d() {
+  Object.assign(t, o);
+}
+function m(a) {
+  const n = u();
+  let e = {};
+  return typeof a[0] == "object" && (e = a.shift() ?? {}), [{ ...n, ...e }, ...a];
+}
+function u() {
+  return {
+    backgroundColor: t.backgroundColor,
+    backgroundImage: t.backgroundImage ?? null,
+    inputs: t.inputs ? { ...t.inputs } : void 0,
+    gravity: t.gravity,
+    variables: t.variables ? { ...t.variables } : void 0
+  };
+}
+export {
+  u as getStageDefaultConfig,
+  m as getStageOptions,
+  d as resetStageDefaults,
+  b as setStageDefaults,
+  t as stageDefaultsState
+};

package/dist/lib/stage/stage-state.js

@@ -0,0 +1,36 @@
+import { Vector3 as t, Color as r } from "three";
+import { proxy as s } from "valtio/vanilla";
+const e = s({
+  backgroundColor: new r(r.NAMES.cornflowerblue),
+  backgroundImage: null,
+  inputs: {
+    p1: ["gamepad-1", "keyboard-1"],
+    p2: ["gamepad-2", "keyboard-2"]
+  },
+  variables: {},
+  gravity: new t(0, 0, 0),
+  entities: []
+}), l = (a) => {
+  e.backgroundColor = a;
+}, b = (a) => {
+  e.backgroundImage = a;
+}, i = (a, o) => {
+  e.variables[a] = o;
+}, c = (a) => {
+  if (e.variables.hasOwnProperty(a))
+    return e.variables[a];
+  console.warn(`Stage variable ${a} not found`);
+}, d = (a) => {
+  e.variables = { ...a };
+}, u = () => {
+  e.variables = {};
+};
+export {
+  c as getStageVariable,
+  u as resetStageVariables,
+  l as setStageBackgroundColor,
+  b as setStageBackgroundImage,
+  i as setStageVariable,
+  d as setStageVariables,
+  e as stageState
+};

package/dist/lib/stage/stage.d.ts

@@ -1,6 +1,6 @@
 import { BaseNode } from '../core/base-node';
 import { DestroyFunction, SetupContext, SetupFunction, UpdateFunction } from '../core/base-node-life-cycle';
-import { StageOptions, ZylemStage } from './zylem-stage';
+import { StageOptionItem, StageOptions, ZylemStage } from './zylem-stage';
 import { ZylemCamera } from '../camera/zylem-camera';
 import { CameraWrapper } from '../camera/camera';
 type NodeLike = {
@@ -10,7 +10,7 @@ type AnyNode = NodeLike | Promise<NodeLike>;
 type EntityInput = AnyNode | (() => AnyNode) | (() => Promise<any>);
 export declare class Stage {
     stageRef: ZylemStage;
-    options: StageOptions;
+    options: StageOptionItem[];
     update: UpdateFunction<ZylemStage>;
     setup: SetupFunction<ZylemStage>;
     destroy: DestroyFunction<ZylemStage>;

package/dist/lib/stage/stage.js

@@ -0,0 +1,60 @@
+import { ZylemStage as n } from "./zylem-stage.js";
+import { CameraWrapper as r } from "../camera/camera.js";
+import { stageState as i, setStageVariable as g, getStageVariable as p } from "./stage-state.js";
+import { getStageOptions as f } from "./stage-default.js";
+class d {
+  stageRef;
+  options = [];
+  update = () => {
+  };
+  setup = () => {
+  };
+  destroy = () => {
+  };
+  constructor(t) {
+    this.options = t, this.stageRef = new n(this.options);
+  }
+  async load(t, e) {
+    this.stageRef.wrapperRef = this;
+    const s = e instanceof r ? e.cameraRef : e;
+    await this.stageRef.load(t, s);
+  }
+  async addEntities(t) {
+    this.options.push(...t), this.stageRef.enqueue(...t);
+  }
+  add(...t) {
+    this.stageRef.enqueue(...t);
+  }
+  start(t) {
+    this.stageRef?.nodeSetup(t), this.stageRef.onEntityAdded((e) => {
+      const s = this.stageRef.buildEntityState(e);
+      i.entities = [...i.entities, s];
+    }, { replayExisting: !0 });
+  }
+  onUpdate(...t) {
+    this.stageRef.update = (e) => {
+      const s = { ...e, stage: this };
+      t.forEach((o) => o(s));
+    };
+  }
+  onSetup(t) {
+    this.stageRef.setup = t;
+  }
+  onDestroy(t) {
+    this.stageRef.destroy = t;
+  }
+  setVariable(t, e) {
+    g(t, e);
+  }
+  getVariable(t) {
+    return p(t);
+  }
+}
+function l(...a) {
+  const t = f(a);
+  return new d([...t]);
+}
+export {
+  d as Stage,
+  l as stage
+};

package/dist/lib/stage/zylem-stage.d.ts

@@ -12,7 +12,7 @@ import { StageDebugDelegate } from './stage-debug-delegate';
 import { BaseEntityInterface } from '../types/entity-types';
 export interface ZylemStageConfig {
     inputs: Record<string, string[]>;
-    backgroundColor: Color;
+    backgroundColor: Color | string;
     backgroundImage: string | null;
     gravity: Vector3;
     variables: Record<string, any>;
@@ -21,8 +21,9 @@ export interface ZylemStageConfig {
 type NodeLike = {
     create: Function;
 };
-type StageEntityInput = NodeLike | Promise<any> | (() => NodeLike | Promise<any>);
-export type StageOptions = Array<Partial<ZylemStageConfig> | CameraWrapper | StageEntityInput>;
+export type StageEntityInput = NodeLike | Promise<any> | (() => NodeLike | Promise<any>);
+export type StageOptionItem = Partial<ZylemStageConfig> | CameraWrapper | StageEntityInput;
+export type StageOptions = [] | [Partial<ZylemStageConfig>, ...StageOptionItem[]];
 export type StageState = ZylemStageConfig & {
     entities: GameEntityInterface[];
 };