@zylem/game-lib 0.3.16 → 0.3.17

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

@@ -1,10 +1,12 @@
-import { state as i, getGlobalState as r, setGlobalState as n } from "./game-state.js";
-import { setDebugFlag as u, isPaused as h } from "../debug/debug-state.js";
-import { InputManager as g } from "../input/input-manager.js";
-import { Timer as c } from "../core/three-addons/Timer.js";
-import { subscribe as m } from "valtio/vanilla";
-import f from "stats.js";
-class l {
+import { state as o, getGlobalState as n, setGlobalState as l } from "./game-state.js";
+import { setDebugFlag as u, isPaused as m } from "../debug/debug-state.js";
+import { InputManager as c } from "../input/input-manager.js";
+import { Timer as h } from "../core/three-addons/Timer.js";
+import { resolveGameConfig as d } from "./game-config.js";
+import { GameCanvas as g } from "./game-canvas.js";
+import { subscribe as f } from "valtio/vanilla";
+import p from "stats.js";
+class r {
   id;
   initialGlobals = {};
   customSetup = null;
@@ -20,16 +22,40 @@ class l {
   wrapperRef;
   statsRef = null;
   defaultCamera = null;
+  container = null;
+  canvas = null;
+  aspectRatioDelegate = null;
+  resolvedConfig = null;
+  gameCanvas = null;
   static FRAME_LIMIT = 120;
-  static FRAME_DURATION = 1e3 / l.FRAME_LIMIT;
+  static FRAME_DURATION = 1e3 / r.FRAME_LIMIT;
   static MAX_DELTA_SECONDS = 1 / 30;
   constructor(t, e) {
-    this.wrapperRef = e, this.inputManager = new g(t.input), this.timer = new c(), this.timer.connect(document), this.id = t.id, this.stages = t.stages || [], this.setGlobals(t), t.debug && (this.statsRef = new f(), this.statsRef.showPanel(0), this.statsRef.dom.style.position = "absolute", this.statsRef.dom.style.bottom = "0", this.statsRef.dom.style.right = "0", this.statsRef.dom.style.top = "auto", this.statsRef.dom.style.left = "auto", document.body.appendChild(this.statsRef.dom));
+    this.wrapperRef = e, this.inputManager = new c(t.input), this.timer = new h(), this.timer.connect(document);
+    const a = d(t);
+    this.id = a.id, this.stages = a.stages || [], this.container = a.container, this.canvas = a.canvas ?? null, this.resolvedConfig = a, this.loadGameCanvas(a), this.loadDebugOptions(t), this.setGlobals(t);
+  }
+  loadGameCanvas(t) {
+    this.gameCanvas = new g({
+      id: t.id,
+      container: t.container,
+      containerId: t.containerId,
+      canvas: this.canvas ?? void 0,
+      bodyBackground: t.bodyBackground,
+      fullscreen: t.fullscreen,
+      aspectRatio: t.aspectRatio
+    }), this.gameCanvas.applyBodyBackground(), this.gameCanvas.mountCanvas(), this.gameCanvas.centerIfFullscreen();
+  }
+  loadDebugOptions(t) {
+    u(!!t.debug), t.debug && (this.statsRef = new p(), this.statsRef.showPanel(0), this.statsRef.dom.style.position = "absolute", this.statsRef.dom.style.bottom = "0", this.statsRef.dom.style.right = "0", this.statsRef.dom.style.top = "auto", this.statsRef.dom.style.left = "auto", document.body.appendChild(this.statsRef.dom));
   }
   async loadStage(t) {
     this.unloadCurrentStage();
     const e = t.options[0];
-    await t.load(this.id, e?.camera), this.stageMap.set(t.stageRef.uuid, t), this.currentStageId = t.stageRef.uuid, this.defaultCamera = t.stageRef.cameraRef;
+    if (await t.load(this.id, e?.camera), this.stageMap.set(t.stageRef.uuid, t), this.currentStageId = t.stageRef.uuid, this.defaultCamera = t.stageRef.cameraRef, this.container && this.defaultCamera) {
+      const a = this.defaultCamera.getDomElement();
+      this.gameCanvas?.mountRenderer(a, (s, i) => this.defaultCamera?.resize(s, i));
+    }
   }
   unloadCurrentStage() {
     if (!this.currentStageId)
@@ -40,7 +66,7 @@ class l {
         try {
           t.stageRef.nodeDestroy({
             me: t.stageRef,
-            globals: i.globals
+            globals: o.globals
           });
         } catch (e) {
           console.error("Failed to destroy previous stage", e);
@@ -49,20 +75,20 @@ class l {
     }
   }
   setGlobals(t) {
-    u(t.debug), this.initialGlobals = { ...t.globals };
+    this.initialGlobals = { ...t.globals };
     for (const e in this.initialGlobals) {
-      const s = this.initialGlobals[e];
-      s === void 0 && console.error(`global ${e} is undefined`), this.setGlobal(e, s);
+      const a = this.initialGlobals[e];
+      a === void 0 && console.error(`global ${e} is undefined`), this.setGlobal(e, a);
     }
   }
   params() {
-    const t = this.currentStage(), e = this.timer.getDelta(), s = this.inputManager.getInputs(e), a = t?.stageRef?.cameraRef || this.defaultCamera;
+    const t = this.currentStage(), e = this.timer.getDelta(), a = this.inputManager.getInputs(e), s = t?.stageRef?.cameraRef || this.defaultCamera;
     return {
       delta: e,
-      inputs: s,
-      globals: i.globals,
+      inputs: a,
+      globals: o.globals,
       me: this,
-      camera: a
+      camera: s
     };
   }
   start() {
@@ -70,10 +96,10 @@ class l {
     t.start({ ...e, me: t.stageRef }), this.customSetup && this.customSetup(e), this.loop(0);
   }
   loop(t) {
-    if (this.statsRef && this.statsRef.begin(), !h()) {
+    if (this.statsRef && this.statsRef.begin(), !m()) {
       this.timer.update(t);
-      const e = this.currentStage(), s = this.params(), a = Math.min(s.delta, l.MAX_DELTA_SECONDS), o = { ...s, delta: a };
-      this.customUpdate && this.customUpdate(o), e && e.stageRef.nodeUpdate({ ...o, me: e.stageRef }), this.totalTime += o.delta, i.time = this.totalTime, this.previousTimeStamp = t;
+      const e = this.currentStage(), a = this.params(), s = Math.min(a.delta, r.MAX_DELTA_SECONDS), i = { ...a, delta: s };
+      this.customUpdate && this.customUpdate(i), e && e.stageRef.nodeUpdate({ ...i, me: e.stageRef }), this.totalTime += i.delta, o.time = this.totalTime, this.previousTimeStamp = t;
     }
     this.statsRef && this.statsRef.end(), this.outOfLoop(), requestAnimationFrame(this.loop.bind(this));
   }
@@ -88,20 +114,20 @@ class l {
     return this.getStage(this.currentStageId);
   }
   getGlobal(t) {
-    return r(t);
+    return n(t);
   }
   setGlobal(t, e) {
-    n(t, e);
+    l(t, e);
   }
   onGlobalChange(t, e) {
-    let s = r(t);
-    m(i, () => {
-      const a = r(t);
-      a !== s && (s = a, e(a));
+    let a = n(t);
+    f(o, () => {
+      const s = n(t);
+      s !== a && (a = s, e(s));
     });
   }
 }
 export {
-  l as ZylemGame,
-  l as default
+  r as ZylemGame,
+  r as default
 };

package/dist/lib/graphics/material.d.ts

@@ -1,5 +1,5 @@
 import { Color, Material, Vector2 } from 'three';
-import { shortHash } from '../core/utility';
+import { shortHash } from '../core/utility/strings';
 import { ZylemShaderType } from '../core/preset-shader';
 export interface MaterialOptions {
     path?: string;

package/dist/lib/graphics/material.js

@@ -1,5 +1,5 @@
 import { Color as n, Vector2 as m, TextureLoader as c, RepeatWrapping as o, MeshPhongMaterial as p, MeshStandardMaterial as u, ShaderMaterial as f, Vector3 as d } from "three";
-import { shortHash as M, sortedStringify as w } from "../core/utility.js";
+import { shortHash as M, sortedStringify as w } from "../core/utility/strings.js";
 import h from "../core/preset-shader.js";
 class i {
   static batchMaterialMap = /* @__PURE__ */ new Map();

package/dist/lib/graphics/zylem-scene.d.ts

@@ -1,10 +1,10 @@
 import { Scene, Color, Object3D, Vector3 } from 'three';
-import { Entity } from '../interfaces/entity';
+import { Entity, LifecycleFunction } from '../interfaces/entity';
 import { GameEntity } from '../entities/entity';
 import { ZylemCamera } from '../camera/zylem-camera';
 import { SetupFunction } from '../core/base-node-life-cycle';
 interface SceneState {
-    backgroundColor: Color;
+    backgroundColor: Color | string;
     backgroundImage: string | null;
 }
 export declare class ZylemScene implements Entity<ZylemScene> {
@@ -13,14 +13,14 @@ export declare class ZylemScene implements Entity<ZylemScene> {
     scene: Scene;
     zylemCamera: ZylemCamera;
     containerElement: HTMLElement | null;
+    update: LifecycleFunction<ZylemScene>;
+    _collision?: ((entity: any, other: any, globals?: any) => void) | undefined;
+    _destroy?: ((globals?: any) => void) | undefined;
+    name?: string | undefined;
+    tag?: Set<string> | undefined;
     constructor(id: string, camera: ZylemCamera, state: SceneState);
-    /**
-     * Setup the container element and append camera's renderer
-     */
-    private setupContainer;
     setup(): void;
     destroy(): void;
-    update({ delta }: Partial<any>): void;
     /**
      * Setup camera with the scene
      */

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

@@ -1,74 +1,60 @@
-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 { Scene as d, Color as i, TextureLoader as n, AmbientLight as m, DirectionalLight as c, Vector3 as h, GridHelper as l } from "three";
+import { debugState as g } from "../debug/debug-state.js";
 import { getGlobalState as p } from "../game/game-state.js";
-class y {
+class b {
   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;
+  update = () => {
+  };
+  _collision;
+  _destroy;
+  name;
+  tag;
+  constructor(e, s, a) {
+    const o = new d(), t = a.backgroundColor instanceof i ? a.backgroundColor : new i(a.backgroundColor);
+    if (o.background = t, a.backgroundImage) {
+      const r = new n().load(a.backgroundImage);
+      o.background = r;
     }
-    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());
+    this.scene = o, this.zylemCamera = s, this.setupLighting(o), this.setupCamera(o, s), g.on && this.debugScene();
   }
   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?.());
+      e.geometry && e.geometry.dispose?.(), e.material && (Array.isArray(e.material) ? e.material.forEach((s) => s.dispose?.()) : e.material.dispose?.());
     });
   }
-  update({ delta: e }) {
-  }
   /**
    * Setup camera with the scene
    */
-  setupCamera(e, t) {
-    e.add(t.cameraRig), t.setup(e);
+  setupCamera(e, s) {
+    e.add(s.cameraRig), s.setup(e);
   }
   /**
    * Setup scene lighting
    */
   setupLighting(e) {
-    const t = new m(16777215, 2);
-    e.add(t);
-    const a = new d(16777215, 2);
+    const s = new m(16777215, 2);
+    e.add(s);
+    const a = new c(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);
+  updateRenderer(e, s) {
+    this.zylemCamera.resize(e, s);
   }
   /**
    * 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(e, s = new h(0, 0, 0)) {
+    e.position.set(s.x, s.y, s.z), this.scene.add(e);
   }
   /**
    * Add game entity to scene
@@ -85,5 +71,5 @@ class y {
   }
 }
 export {
-  y as ZylemScene
+  b as ZylemScene
 };

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-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.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

@@ -1,7 +1,8 @@
 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 {
+import { getStageOptions as f } from "./stage-default.js";
+class d {
   stageRef;
   options = [];
   update = () => {
@@ -49,10 +50,11 @@ class f {
     return p(t);
   }
 }
-function R(...a) {
-  return new f(a);
+function l(...a) {
+  const t = f(a);
+  return new d([...t]);
 }
 export {
-  f as Stage,
-  R as stage
+  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[];
 };