@zylem/game-lib 0.3.14 → 0.3.16

package/dist/lib/graphics/zylem-scene.js

@@ -0,0 +1,89 @@
+import { Scene as r, Color as n, TextureLoader as o, AmbientLight as m, DirectionalLight as d, Vector3 as h, GridHelper as l } from "three";
+import { debugState as c } from "../debug/debug-state.js";
+import { getGlobalState as p } from "../game/game-state.js";
+class y {
+  type = "Scene";
+  _setup;
+  scene;
+  zylemCamera;
+  containerElement = null;
+  constructor(e, t, a) {
+    const i = new r();
+    if (i.background = new n(a.backgroundColor), a.backgroundImage) {
+      const s = new o().load(a.backgroundImage);
+      i.background = s;
+    }
+    this.scene = i, this.zylemCamera = t, this.setupContainer(e), this.setupLighting(i), this.setupCamera(i, t), c.on && this.debugScene();
+  }
+  /**
+   * Setup the container element and append camera's renderer
+   */
+  setupContainer(e) {
+    let t = document.getElementById(e);
+    if (!t) {
+      console.warn(`Could not find element with id: ${e}`);
+      const a = document.createElement("main");
+      a.setAttribute("id", e), document.body.appendChild(a), t = a;
+    }
+    t?.firstChild && t.removeChild(t.firstChild), this.containerElement = t, t?.appendChild(this.zylemCamera.getDomElement());
+  }
+  setup() {
+    this._setup && this._setup({ me: this, camera: this.zylemCamera, globals: p() });
+  }
+  destroy() {
+    if (this.containerElement && this.zylemCamera)
+      try {
+        const e = this.zylemCamera.getDomElement();
+        e && e.parentElement === this.containerElement && this.containerElement.removeChild(e);
+      } catch {
+      }
+    this.zylemCamera && this.zylemCamera.destroy && this.zylemCamera.destroy(), this.scene && this.scene.traverse((e) => {
+      e.geometry && e.geometry.dispose?.(), e.material && (Array.isArray(e.material) ? e.material.forEach((t) => t.dispose?.()) : e.material.dispose?.());
+    });
+  }
+  update({ delta: e }) {
+  }
+  /**
+   * Setup camera with the scene
+   */
+  setupCamera(e, t) {
+    e.add(t.cameraRig), t.setup(e);
+  }
+  /**
+   * Setup scene lighting
+   */
+  setupLighting(e) {
+    const t = new m(16777215, 2);
+    e.add(t);
+    const a = new d(16777215, 2);
+    a.name = "Light", a.position.set(0, 100, 0), a.castShadow = !0, a.shadow.camera.near = 0.1, a.shadow.camera.far = 2e3, a.shadow.camera.left = -100, a.shadow.camera.right = 100, a.shadow.camera.top = 100, a.shadow.camera.bottom = -100, a.shadow.mapSize.width = 2048, a.shadow.mapSize.height = 2048, e.add(a);
+  }
+  /**
+   * Update renderer size - delegates to camera
+   */
+  updateRenderer(e, t) {
+    this.zylemCamera.resize(e, t);
+  }
+  /**
+   * Add object to scene
+   */
+  add(e, t = new h(0, 0, 0)) {
+    e.position.set(t.x, t.y, t.z), this.scene.add(e);
+  }
+  /**
+   * Add game entity to scene
+   */
+  addEntity(e) {
+    e.group ? this.add(e.group, e.options.position) : e.mesh && this.add(e.mesh, e.options.position);
+  }
+  /**
+   * Add debug helpers to scene
+   */
+  debugScene() {
+    const a = new l(1e3, 100);
+    this.scene.add(a);
+  }
+}
+export {
+  y as ZylemScene
+};

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

@@ -0,0 +1,58 @@
+class h {
+  gamepadIndex;
+  connected = !1;
+  buttonStates = {};
+  constructor(t) {
+    this.gamepadIndex = t, window.addEventListener("gamepadconnected", (e) => {
+      e.gamepad.index === this.gamepadIndex && (this.connected = !0);
+    }), window.addEventListener("gamepaddisconnected", (e) => {
+      e.gamepad.index === this.gamepadIndex && (this.connected = !1);
+    });
+  }
+  handleButtonState(t, e, a) {
+    const s = e.buttons[t].pressed;
+    let n = this.buttonStates[t];
+    return n || (n = { pressed: !1, released: !1, held: 0 }, this.buttonStates[t] = n), s ? (n.held === 0 ? n.pressed = !0 : n.pressed = !1, n.held += a, n.released = !1) : (n.held > 0 ? (n.released = !0, n.held = 0) : n.released = !1, n.pressed = !1), n;
+  }
+  handleAnalogState(t, e, a) {
+    return { value: e.axes[t], held: a };
+  }
+  getInput(t) {
+    const e = navigator.getGamepads()[this.gamepadIndex];
+    return e ? {
+      buttons: {
+        A: this.handleButtonState(0, e, t),
+        B: this.handleButtonState(1, e, t),
+        X: this.handleButtonState(2, e, t),
+        Y: this.handleButtonState(3, e, t),
+        Start: this.handleButtonState(9, e, t),
+        Select: this.handleButtonState(8, e, t),
+        L: this.handleButtonState(4, e, t),
+        R: this.handleButtonState(5, e, t)
+      },
+      directions: {
+        Up: this.handleButtonState(12, e, t),
+        Down: this.handleButtonState(13, e, t),
+        Left: this.handleButtonState(14, e, t),
+        Right: this.handleButtonState(15, e, t)
+      },
+      axes: {
+        Horizontal: this.handleAnalogState(0, e, t),
+        Vertical: this.handleAnalogState(1, e, t)
+      },
+      shoulders: {
+        LTrigger: this.handleButtonState(6, e, t),
+        RTrigger: this.handleButtonState(7, e, t)
+      }
+    } : {};
+  }
+  getName() {
+    return `gamepad-${this.gamepadIndex + 1}`;
+  }
+  isConnected() {
+    return this.connected;
+  }
+}
+export {
+  h as GamepadProvider
+};

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-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-state.d.ts

@@ -8,5 +8,9 @@ declare const setStageBackgroundImage: (value: string | null) => void;
 declare const setEntitiesToStage: (entities: Partial<BaseEntityInterface>[]) => void;
 declare const setStageVariable: (key: string, value: any) => void;
 declare const getStageVariable: (key: string) => any;
+/** Replace the entire stage variables object (used on stage load). */
+declare const setStageVariables: (variables: Record<string, any>) => void;
+/** Reset all stage variables (used on stage unload). */
+declare const resetStageVariables: () => void;
 declare const stageStateToString: (state: StageStateInterface) => string;
-export { stageState, setStageState, setStageBackgroundColor, setStageBackgroundImage, setEntitiesToStage, stageStateToString, setStageVariable, getStageVariable, };
+export { stageState, setStageState, setStageBackgroundColor, setStageBackgroundImage, setEntitiesToStage, stageStateToString, setStageVariable, getStageVariable, setStageVariables, resetStageVariables, };

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

@@ -24,7 +24,6 @@ export declare class Stage {
     onDestroy(callback: DestroyFunction<ZylemStage>): void;
     setVariable(key: string, value: any): void;
     getVariable(key: string): any;
-    watchVariable(key: string, callback: (value: any) => void): void;
 }
 /**
  * Create a stage with optional camera

package/dist/lib/stage/stage.js

@@ -0,0 +1,58 @@
+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";
+class f {
+  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 R(...a) {
+  return new f(a);
+}
+export {
+  f as Stage,
+  R as stage
+};

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

@@ -1,7 +1,6 @@
 import { Color, Vector3 } from 'three';
 import { ZylemWorld } from '../collision/world';
 import { ZylemScene } from '../graphics/zylem-scene';
-import { Conditions } from '../interfaces/game';
 import { GameEntityInterface } from '../types/entity-types';
 import { SetupContext, UpdateContext, DestroyContext } from '../core/base-node-life-cycle';
 import { LifeCycleBase } from '../core/lifecycle-base';
@@ -17,7 +16,6 @@ export interface ZylemStageConfig {
     backgroundImage: string | null;
     gravity: Vector3;
     variables: Record<string, any>;
-    conditions?: Conditions<any>[];
     stageRef?: Stage;
 }
 type NodeLike = {
@@ -44,7 +42,6 @@ export declare class ZylemStage extends LifeCycleBase<ZylemStage> {
     gravity: Vector3;
     world: ZylemWorld | null;
     scene: ZylemScene | null;
-    conditions: Conditions<any>[];
     children: Array<BaseNode>;
     _childrenMap: Map<number, BaseNode>;
     _removalMap: Map<number, BaseNode>;
@@ -85,6 +82,7 @@ export declare class ZylemStage extends LifeCycleBase<ZylemStage> {
     private createDefaultCamera;
     protected _setup(params: SetupContext<ZylemStage>): void;
     protected _update(params: UpdateContext<ZylemStage>): void;
+    outOfLoop(): void;
     /** Update debug overlays and helpers if enabled. */
     debugUpdate(): void;
     /** Cleanup owned resources when the stage is destroyed. */