@zylem/game-lib 0.4.0 → 0.5.0

package/dist/lib/game/game-config.js

@@ -73,7 +73,6 @@ function k(t) {
 }
 export {
   f as GameConfig,
-  B as createDefaultGameConfig,
   k as gameConfig,
   C as resolveGameConfig
 };

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

@@ -1,5 +1,5 @@
 import { proxy as i } from "valtio/vanilla";
-import { stage as e } from "../stage/stage.js";
+import { createStage as e } from "../stage/stage.js";
 const a = () => ({
   id: "zylem",
   globals: {},
@@ -19,6 +19,5 @@ function g() {
   };
 }
 export {
-  t as gameDefaultsState,
   g as getGameDefaultConfig
 };

package/dist/lib/game/game-retro-resolutions.js

@@ -74,7 +74,6 @@ function l(e) {
   return !Number.isFinite(i) || !Number.isFinite(s) ? null : { width: i, height: s };
 }
 export {
-  n as RetroPresets,
   h as getDisplayAspect,
   r as getPresetResolution,
   l as parseResolution

package/dist/lib/game/game.js

@@ -1,10 +1,12 @@
-import { ZylemGame as n } from "./zylem-game.js";
-import { setPaused as o } from "../debug/debug-state.js";
-import { getGlobalState as i, setGlobalState as p } from "./game-state.js";
-import { hasStages as d, convertNodes as l } from "../core/utility/nodes.js";
-import { resolveGameConfig as h } from "./game-config.js";
-import { stage as g } from "../stage/stage.js";
-class m {
+import { ZylemGame as l } from "./zylem-game.js";
+import { setPaused as n } from "../debug/debug-state.js";
+import { getGlobalState as g, setGlobalState as m } from "./game-state.js";
+import { hasStages as h, convertNodes as c } from "../core/utility/nodes.js";
+import { resolveGameConfig as u } from "./game-config.js";
+import { createStage as G } from "../stage/stage.js";
+import { StageManager as i, stageState as s } from "../stage/stage-manager.js";
+import { StageFactory as p } from "../stage/stage-factory.js";
+class w {
   wrappedGame = null;
   pendingGlobalChangeHandlers = [];
   options;
@@ -16,7 +18,7 @@ class m {
   };
   refErrorMessage = "lost reference to game";
   constructor(e) {
-    this.options = e, d(e) || this.options.push(g());
+    this.options = e, h(e) || this.options.push(G());
   }
   async start() {
     const e = await this.load();
@@ -24,7 +26,7 @@ class m {
   }
   async load() {
     console.log("loading game", this.options);
-    const e = await l(this.options), a = h(e), t = new n({
+    const e = await c(this.options), a = u(e), t = new l({
       ...e,
       ...a
     }, this);
@@ -42,10 +44,10 @@ class m {
     }
   }
   async pause() {
-    o(!0);
+    n(!0);
   }
   async resume() {
-    o(!1), this.wrappedGame && (this.wrappedGame.previousTimeStamp = 0, this.wrappedGame.timer.reset());
+    n(!1), this.wrappedGame && (this.wrappedGame.previousTimeStamp = 0, this.wrappedGame.timer.reset());
   }
   async reset() {
     if (!this.wrappedGame) {
@@ -54,26 +56,46 @@ class m {
     }
     await this.wrappedGame.loadStage(this.wrappedGame.stages[0]);
   }
-  async nextStage() {
+  async previousStage() {
     if (!this.wrappedGame) {
       console.error(this.refErrorMessage);
       return;
     }
-    const e = this.wrappedGame.currentStageId, a = this.wrappedGame.stages.findIndex((r) => r.wrappedStage.uuid === e), t = this.wrappedGame.stages[a + 1];
+    const e = this.wrappedGame.currentStageId, a = this.wrappedGame.stages.findIndex((r) => r.wrappedStage.uuid === e), t = this.wrappedGame.stages[a - 1];
     if (!t) {
-      console.error("next stage called on last stage");
+      console.error("previous stage called on first stage");
       return;
     }
     await this.wrappedGame.loadStage(t);
   }
-  async previousStage() {
+  async loadStageFromId(e) {
     if (!this.wrappedGame) {
       console.error(this.refErrorMessage);
       return;
     }
-    const e = this.wrappedGame.currentStageId, a = this.wrappedGame.stages.findIndex((r) => r.wrappedStage.uuid === e), t = this.wrappedGame.stages[a - 1];
+    try {
+      const a = await i.loadStageData(e), t = await p.createFromBlueprint(a);
+      await this.wrappedGame.loadStage(t), s.current = a;
+    } catch (a) {
+      console.error(`Failed to load stage ${e}`, a);
+    }
+  }
+  async nextStage() {
+    if (!this.wrappedGame) {
+      console.error(this.refErrorMessage);
+      return;
+    }
+    if (s.next) {
+      const r = s.next.id;
+      if (await i.transitionForward(r), s.current) {
+        const d = await p.createFromBlueprint(s.current);
+        await this.wrappedGame.loadStage(d);
+        return;
+      }
+    }
+    const e = this.wrappedGame.currentStageId, a = this.wrappedGame.stages.findIndex((r) => r.wrappedStage.uuid === e), t = this.wrappedGame.stages[a + 1];
     if (!t) {
-      console.error("previous stage called on first stage");
+      console.error("next stage called on last stage");
       return;
     }
     await this.wrappedGame.loadStage(t);
@@ -83,14 +105,14 @@ class m {
   async end() {
   }
   getGlobal(e) {
-    return this.wrappedGame ? this.wrappedGame.getGlobal(e) : i(e);
+    return this.wrappedGame ? this.wrappedGame.getGlobal(e) : g(e);
   }
   setGlobal(e, a) {
     if (this.wrappedGame) {
       this.wrappedGame.setGlobal(e, a);
       return;
     }
-    p(e, a);
+    m(e, a);
   }
   onGlobalChange(e, a) {
     if (this.wrappedGame) {
@@ -100,10 +122,10 @@ class m {
     this.pendingGlobalChangeHandlers.push({ key: e, callback: a });
   }
 }
-function b(...s) {
-  return new m(s);
+function M(...o) {
+  return new w(o);
 }
 export {
-  m as Game,
-  b as createGame
+  w as Game,
+  M as createGame
 };

package/dist/lib/game/zylem-game.js

@@ -136,6 +136,5 @@ class n {
   }
 }
 export {
-  n as ZylemGame,
-  n as default
+  n as ZylemGame
 };

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

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

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

@@ -0,0 +1,22 @@
+import { createStage as a } from "./stage.js";
+import { EntityFactory as i } from "../entities/entity-factory.js";
+const s = {
+  async createFromBlueprint(t) {
+    const r = a({
+      // Map blueprint properties to stage options if needed
+      // e.g. name: blueprint.name
+    });
+    if (t.entities)
+      for (const o of t.entities)
+        try {
+          const e = await i.createFromBlueprint(o);
+          r.add(e);
+        } catch (e) {
+          console.error(`Failed to create entity ${o.id} for stage ${t.id}`, e);
+        }
+    return r;
+  }
+};
+export {
+  s as StageFactory
+};

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

@@ -0,0 +1,49 @@
+import { proxy as i } from "valtio/vanilla";
+import { set as n, get as o } from "../../node_modules/.pnpm/idb-keyval@6.2.2/node_modules/idb-keyval/dist/index.js";
+import { pack as s } from "../../node_modules/.pnpm/msgpackr@1.11.5/node_modules/msgpackr/pack.js";
+import { unpack as c } from "../../node_modules/.pnpm/msgpackr@1.11.5/node_modules/msgpackr/unpack.js";
+const t = i({
+  previous: null,
+  current: null,
+  next: null,
+  isLoading: !1
+}), p = {
+  staticRegistry: /* @__PURE__ */ new Map(),
+  registerStaticStage(r, a) {
+    this.staticRegistry.set(r, a);
+  },
+  async loadStageData(r) {
+    try {
+      const a = await o(r);
+      if (a)
+        return c(a);
+    } catch (a) {
+      console.warn(`Failed to load stage ${r} from storage`, a);
+    }
+    if (this.staticRegistry.has(r))
+      return this.staticRegistry.get(r);
+    throw new Error(`Stage ${r} not found in storage and static loading not fully implemented.`);
+  },
+  async transitionForward(r, a) {
+    if (!t.isLoading) {
+      t.isLoading = !0;
+      try {
+        t.current && await n(t.current.id, s(t.current)), t.previous = t.current, t.current = t.next, t.current?.id !== r && (a ? t.current = await a(r) : t.current = await this.loadStageData(r)), t.next = null;
+      } catch (e) {
+        console.error("Failed to transition stage:", e);
+      } finally {
+        t.isLoading = !1;
+      }
+    }
+  },
+  /**
+   * Manually set the next stage to pre-load it.
+   */
+  async preloadNext(r, a) {
+    a ? t.next = await a(r) : t.next = await this.loadStageData(r);
+  }
+};
+export {
+  p as StageManager,
+  t as stageState
+};

package/dist/lib/stage/stage.js

@@ -1,10 +1,11 @@
-import { ZylemStage as i } from "./zylem-stage.js";
-import { CameraWrapper as o } from "../camera/camera.js";
-import { stageState as s, setStageVariable as n, getStageVariable as d } from "./stage-state.js";
-import { getStageOptions as g } from "./stage-default.js";
-class S {
+import { ZylemStage as o } from "./zylem-stage.js";
+import { CameraWrapper as d } from "../camera/camera.js";
+import { stageState as r, setStageVariable as n, getStageVariable as g } from "./stage-state.js";
+import { getStageOptions as S } from "./stage-default.js";
+class h {
   wrappedStage;
   options = [];
+  // TODO: these shouldn't be here maybe more like nextFrame(stageInstance, () => {})
   update = () => {
   };
   setup = () => {
@@ -15,27 +16,33 @@ class S {
     this.options = t, this.wrappedStage = null;
   }
   async load(t, e) {
-    this.wrappedStage = new i(this.options), this.wrappedStage.wrapperRef = this;
-    const a = e instanceof o ? e.cameraRef : e;
-    await this.wrappedStage.load(t, a);
+    r.entities = [], this.wrappedStage = new o(this.options), this.wrappedStage.wrapperRef = this;
+    const a = e instanceof d ? e.cameraRef : e;
+    await this.wrappedStage.load(t, a), this.wrappedStage.onEntityAdded((p) => {
+      const s = this.wrappedStage.buildEntityState(p);
+      r.entities = [...r.entities, s];
+    }, { replayExisting: !0 });
   }
   async addEntities(t) {
     this.options.push(...t), this.wrappedStage && this.wrappedStage.enqueue(...t);
   }
   add(...t) {
-    this.wrappedStage.enqueue(...t);
+    this.addToBlueprints(...t), this.addToStage(...t);
+  }
+  addToBlueprints(...t) {
+    this.wrappedStage || this.options.push(...t);
+  }
+  addToStage(...t) {
+    this.wrappedStage && this.wrappedStage.enqueue(...t);
   }
   start(t) {
-    this.wrappedStage?.nodeSetup(t), this.wrappedStage.onEntityAdded((e) => {
-      const a = this.wrappedStage.buildEntityState(e);
-      s.entities = [...s.entities, a];
-    }, { replayExisting: !0 });
+    this.wrappedStage?.nodeSetup(t);
   }
   onUpdate(...t) {
-    this.wrappedStage.update = (e) => {
+    this.wrappedStage && (this.wrappedStage.update = (e) => {
       const a = { ...e, stage: this };
-      t.forEach((r) => r(a));
-    };
+      t.forEach((p) => p(a));
+    });
   }
   onSetup(t) {
     this.wrappedStage.setup = t;
@@ -47,14 +54,14 @@ class S {
     n(t, e);
   }
   getVariable(t) {
-    return d(t);
+    return g(t);
   }
 }
-function c(...p) {
-  const t = g(p);
-  return new S([...t]);
+function c(...i) {
+  const t = S(i);
+  return new h([...t]);
 }
 export {
-  S as Stage,
-  c as stage
+  h as Stage,
+  c as createStage
 };

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

@@ -264,6 +264,5 @@ class Y extends v {
   }
 }
 export {
-  W as STAGE_TYPE,
   Y as ZylemStage
 };

package/dist/main.js

@@ -1,9 +1,9 @@
 import { createGame as m } from "./lib/game/game.js";
 import { gameConfig as a } from "./lib/game/game-config.js";
-import { stage as f } from "./lib/stage/stage.js";
-import { entitySpawner as s } from "./lib/stage/entity-spawner.js";
+import { createStage as f } from "./lib/stage/stage.js";
+import { entitySpawner as n } from "./lib/stage/entity-spawner.js";
 import { vessel as i } from "./lib/core/vessel.js";
-import { camera as c } from "./lib/camera/camera.js";
+import { camera as b } from "./lib/camera/camera.js";
 import { Perspectives as h } from "./lib/camera/perspective.js";
 import { ZylemBox as v, box as d } from "./lib/entities/box.js";
 import { sphere as R } from "./lib/entities/sphere.js";
@@ -11,9 +11,9 @@ import { sprite as E } from "./lib/entities/sprite.js";
 import { plane as w } from "./lib/entities/plane.js";
 import { zone as D } from "./lib/entities/zone.js";
 import { actor as I } from "./lib/entities/actor.js";
-import { text as T } from "./lib/entities/text.js";
-import { rect as A } from "./lib/entities/rect.js";
-import { makeMoveable as M } from "./lib/actions/capabilities/moveable.js";
+import { text as S } from "./lib/entities/text.js";
+import { rect as z } from "./lib/entities/rect.js";
+import { makeMoveable as G } from "./lib/actions/capabilities/moveable.js";
 import { makeRotatable as Z } from "./lib/actions/capabilities/rotatable.js";
 import { makeTransformable as q } from "./lib/actions/capabilities/transformable.js";
 import { ricochet2DInBounds as J } from "./lib/actions/behaviors/ricochet/ricochet-2d-in-bounds.js";
@@ -33,24 +33,24 @@ export {
   I as actor,
   O as boundary2d,
   d as box,
-  c as camera,
+  b as camera,
   m as createGame,
+  f as createStage,
   U as destroy,
-  s as entitySpawner,
+  n as entitySpawner,
   a as gameConfig,
   Y as globalChange,
   _ as globalChanges,
-  M as makeMoveable,
+  G as makeMoveable,
   Z as makeRotatable,
   q as makeTransformable,
   w as plane,
-  A as rect,
+  z as rect,
   L as ricochet2DCollision,
   J as ricochet2DInBounds,
   R as sphere,
   E as sprite,
-  f as stage,
-  T as text,
+  S as text,
   $ as variableChange,
   oo as variableChanges,
   i as vessel,

package/dist/node_modules/.pnpm/idb-keyval@6.2.2/node_modules/idb-keyval/dist/index.js

@@ -0,0 +1,34 @@
+function i(e) {
+  return new Promise((n, t) => {
+    e.oncomplete = e.onsuccess = () => n(e.result), e.onabort = e.onerror = () => t(e.error);
+  });
+}
+function f(e, n) {
+  let t;
+  const o = () => {
+    if (t)
+      return t;
+    const r = indexedDB.open(e);
+    return r.onupgradeneeded = () => r.result.createObjectStore(n), t = i(r), t.then((u) => {
+      u.onclose = () => t = void 0;
+    }, () => {
+    }), t;
+  };
+  return (r, u) => o().then((d) => u(d.transaction(n, r).objectStore(n)));
+}
+let c;
+function a() {
+  return c || (c = f("keyval-store", "keyval")), c;
+}
+function l(e, n = a()) {
+  return n("readonly", (t) => i(t.get(e)));
+}
+function s(e, n, t = a()) {
+  return t("readwrite", (o) => (o.put(n, e), i(o.transaction)));
+}
+export {
+  f as createStore,
+  l as get,
+  i as promisifyRequest,
+  s as set
+};