@zylem/game-lib 0.3.15 → 0.3.17

package/dist/lib/entities/text.js

@@ -0,0 +1,111 @@
+import { Vector2 as u, Group as H, CanvasTexture as w, LinearFilter as l, SpriteMaterial as k, Sprite as M, ClampToEdgeWrapping as C, Color as v } from "three";
+import { GameEntity as R } from "./entity.js";
+import { EntityBuilder as W } from "./builder.js";
+import { createEntity as E } from "./create.js";
+import { DebugDelegate as D } from "./delegates/debug.js";
+const x = {
+  position: void 0,
+  text: "",
+  fontFamily: 'Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace',
+  fontSize: 18,
+  fontColor: "#FFFFFF",
+  backgroundColor: null,
+  padding: 4,
+  stickToViewport: !0,
+  screenPosition: new u(24, 24),
+  zDistance: 1
+};
+class P extends W {
+  createEntity(t) {
+    return new o(t);
+  }
+}
+const z = Symbol("Text");
+class o extends R {
+  static type = z;
+  _sprite = null;
+  _texture = null;
+  _canvas = null;
+  _ctx = null;
+  _cameraRef = null;
+  _lastCanvasW = 0;
+  _lastCanvasH = 0;
+  constructor(t) {
+    super(), this.options = { ...x, ...t }, this.group = new H(), this.createSprite(), this.lifeCycleDelegate = {
+      setup: [this.textSetup.bind(this)],
+      update: [this.textUpdate.bind(this)]
+    };
+  }
+  createSprite() {
+    this._canvas = document.createElement("canvas"), this._ctx = this._canvas.getContext("2d"), this._texture = new w(this._canvas), this._texture.minFilter = l, this._texture.magFilter = l;
+    const t = new k({
+      map: this._texture,
+      transparent: !0,
+      depthTest: !1,
+      depthWrite: !1,
+      alphaTest: 0.5
+    });
+    this._sprite = new M(t), this.group?.add(this._sprite), this.redrawText(this.options.text ?? "");
+  }
+  redrawText(t) {
+    if (!this._canvas || !this._ctx)
+      return;
+    const e = this.options.fontSize ?? 18, r = this.options.fontFamily ?? x.fontFamily, a = this.options.padding ?? 4;
+    this._ctx.font = `${e}px ${r}`;
+    const p = this._ctx.measureText(t), _ = Math.ceil(p.width), h = Math.ceil(e * 1.4), n = Math.max(2, _ + a * 2), s = Math.max(2, h + a * 2), f = n !== this._lastCanvasW || s !== this._lastCanvasH;
+    this._canvas.width = n, this._canvas.height = s, this._lastCanvasW = n, this._lastCanvasH = s, this._ctx.font = `${e}px ${r}`, this._ctx.textBaseline = "top", this._ctx.clearRect(0, 0, this._canvas.width, this._canvas.height), this.options.backgroundColor && (this._ctx.fillStyle = this.toCssColor(this.options.backgroundColor), this._ctx.fillRect(0, 0, this._canvas.width, this._canvas.height)), this._ctx.fillStyle = this.toCssColor(this.options.fontColor ?? "#FFFFFF"), this._ctx.fillText(t, a, a), this._texture && (f && (this._texture.dispose(), this._texture = new w(this._canvas), this._texture.minFilter = l, this._texture.magFilter = l, this._texture.wrapS = C, this._texture.wrapT = C), this._texture.image = this._canvas, this._texture.needsUpdate = !0, this._sprite && this._sprite.material && (this._sprite.material.map = this._texture, this._sprite.material.needsUpdate = !0));
+  }
+  toCssColor(t) {
+    return typeof t == "string" ? t : `#${(t instanceof v ? t : new v(t)).getHexString()}`;
+  }
+  textSetup(t) {
+    this._cameraRef = t.camera, this.options.stickToViewport && this._cameraRef && this._cameraRef.camera.add(this.group);
+  }
+  textUpdate(t) {
+    this._sprite && this.options.stickToViewport && this._cameraRef && this.updateStickyTransform();
+  }
+  updateStickyTransform() {
+    if (!this._sprite || !this._cameraRef)
+      return;
+    const t = this._cameraRef.camera, e = this._cameraRef.renderer.domElement, r = e.clientWidth, a = e.clientHeight, p = (this.options.screenPosition ?? new u(24, 24)).x, _ = (this.options.screenPosition ?? new u(24, 24)).y, h = Math.max(1e-3, this.options.zDistance ?? 1);
+    let n = 1, s = 1;
+    if (t.isPerspectiveCamera) {
+      const i = t, c = Math.tan(i.fov * Math.PI / 180 / 2) * h;
+      n = c * i.aspect, s = c;
+    } else if (t.isOrthographicCamera) {
+      const i = t;
+      n = (i.right - i.left) / 2, s = (i.top - i.bottom) / 2;
+    }
+    const f = p / r * 2 - 1, y = 1 - _ / a * 2, T = f * n, F = y * s;
+    if (this.group?.position.set(T, F, -h), this._canvas) {
+      const c = s * 2 / a, m = this._canvas.height, g = Math.max(1e-4, m * c), S = this._canvas.width / this._canvas.height, b = g * S;
+      this._sprite.scale.set(b, g, 1);
+    }
+  }
+  updateText(t) {
+    this.options.text = t, this.redrawText(t), this.options.stickToViewport && this._cameraRef && this.updateStickyTransform();
+  }
+  buildInfo() {
+    return {
+      ...new D(this).buildDebugInfo(),
+      type: String(o.type),
+      text: this.options.text ?? "",
+      sticky: this.options.stickToViewport
+    };
+  }
+}
+async function X(...d) {
+  return E({
+    args: d,
+    defaultConfig: { ...x },
+    EntityClass: o,
+    BuilderClass: P,
+    entityType: o.type
+  });
+}
+export {
+  z as TEXT_TYPE,
+  P as TextBuilder,
+  o as ZylemText,
+  X as text
+};

package/dist/lib/entities/zone.js

@@ -0,0 +1,103 @@
+import { ColliderDesc as a, ActiveCollisionTypes as h } from "@dimforge/rapier3d-compat";
+import { Vector3 as l } from "three";
+import { GameEntity as u } from "./entity.js";
+import { EntityCollisionBuilder as c, EntityBuilder as p } from "./builder.js";
+import { createEntity as E } from "./create.js";
+import { state as o } from "../game/game-state.js";
+const d = {
+  size: new l(1, 1, 1),
+  position: new l(0, 0, 0),
+  collision: {
+    static: !0
+  },
+  material: {
+    shader: "standard"
+  }
+};
+class f extends c {
+  collider(e) {
+    const t = e.size || new l(1, 1, 1), i = { x: t.x / 2, y: t.y / 2, z: t.z / 2 };
+    let s = a.cuboid(i.x, i.y, i.z);
+    return s.setSensor(!0), s.activeCollisionTypes = h.KINEMATIC_FIXED, s;
+  }
+}
+class x extends p {
+  createEntity(e) {
+    return new r(e);
+  }
+}
+const Z = Symbol("Zone");
+class r extends u {
+  static type = Z;
+  _enteredZone = /* @__PURE__ */ new Map();
+  _exitedZone = /* @__PURE__ */ new Map();
+  _zoneEntities = /* @__PURE__ */ new Map();
+  constructor(e) {
+    super(), this.options = { ...d, ...e };
+  }
+  handlePostCollision({ delta: e }) {
+    return this._enteredZone.forEach((t, i) => {
+      this.exited(e, i);
+    }), this._enteredZone.size > 0;
+  }
+  handleIntersectionEvent({ other: e, delta: t }) {
+    this._enteredZone.get(e.uuid) ? this.held(t, e) : (this.entered(e), this._zoneEntities.set(e.uuid, e));
+  }
+  onEnter(e) {
+    return this.options.onEnter = e, this;
+  }
+  onHeld(e) {
+    return this.options.onHeld = e, this;
+  }
+  onExit(e) {
+    return this.options.onExit = e, this;
+  }
+  entered(e) {
+    this._enteredZone.set(e.uuid, 1), this.options.onEnter && this.options.onEnter({
+      self: this,
+      visitor: e,
+      globals: o.globals
+    });
+  }
+  exited(e, t) {
+    const i = this._exitedZone.get(t);
+    if (i && i > 1 + e) {
+      this._exitedZone.delete(t), this._enteredZone.delete(t);
+      const s = this._zoneEntities.get(t);
+      this.options.onExit && this.options.onExit({
+        self: this,
+        visitor: s,
+        globals: o.globals
+      });
+      return;
+    }
+    this._exitedZone.set(t, 1 + e);
+  }
+  held(e, t) {
+    const i = this._enteredZone.get(t.uuid) ?? 0;
+    this._enteredZone.set(t.uuid, i + e), this._exitedZone.set(t.uuid, 1), this.options.onHeld && this.options.onHeld({
+      delta: e,
+      self: this,
+      visitor: t,
+      globals: o.globals,
+      heldTime: i
+    });
+  }
+}
+async function b(...n) {
+  return E({
+    args: n,
+    defaultConfig: d,
+    EntityClass: r,
+    BuilderClass: x,
+    CollisionBuilderClass: f,
+    entityType: r.type
+  });
+}
+export {
+  Z as ZONE_TYPE,
+  x as ZoneBuilder,
+  f as ZoneCollisionBuilder,
+  r as ZylemZone,
+  b as zone
+};

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

@@ -0,0 +1,44 @@
+import type { Stage } from '../stage/stage';
+import type { BasicTypes, GlobalVariablesType, ZylemGameConfig } from './game-interfaces';
+import type { GameOptions } from '../core/utility/nodes';
+/**
+ * A lightweight, serializable blueprint representing the initial configuration
+ * of a `Game`. It should not include runtime references. Use blueprints only to
+ * build games.
+ */
+export interface GameBlueprint<TGlobals extends Record<string, BasicTypes> = GlobalVariablesType> {
+    id: string;
+    name?: string;
+    config: Partial<ZylemGameConfig<Stage, any, TGlobals>>;
+}
+export declare const gameBlueprintsState: {
+    byId: Record<string, GameBlueprint>;
+    order: string[];
+    currentId: string | null;
+};
+/** Reset the blueprints store back to its initial empty state. */
+export declare function resetGameBlueprints(): void;
+/** Create and register a new `GameBlueprint`. */
+export declare function createGameBlueprint<TGlobals extends Record<string, BasicTypes> = GlobalVariablesType>(config: Partial<ZylemGameConfig<Stage, any, TGlobals>>, options?: {
+    id?: string;
+    name?: string;
+    setCurrent?: boolean;
+}): GameBlueprint<TGlobals>;
+/** Upsert a blueprint into the store. */
+export declare function upsertGameBlueprint<TGlobals extends Record<string, BasicTypes> = GlobalVariablesType>(blueprint: GameBlueprint<TGlobals>): void;
+/** Remove a blueprint by id. */
+export declare function removeGameBlueprint(id: string): void;
+/** Get a blueprint by id. */
+export declare function getGameBlueprint(id: string): GameBlueprint | undefined;
+/** List all blueprints in insertion order. */
+export declare function listGameBlueprints(): GameBlueprint[];
+/** Set the current blueprint id (or clear by passing null). */
+export declare function setCurrentGameBlueprint(id: string | null): void;
+/** Get the current blueprint object, if any. */
+export declare function getCurrentGameBlueprint(): GameBlueprint | null;
+/**
+ * Build a `Game` instance from a blueprint and optional extra `GameOptions`
+ * (e.g., additional stages or nodes). This returns a `Game` wrapper instance;
+ * call `.start()` to run it.
+ */
+export declare function buildGameFromBlueprint<TGlobals extends Record<string, BasicTypes> = GlobalVariablesType>(input: string | GameBlueprint<TGlobals>, ...extras: GameOptions<TGlobals>): import("./game").Game<TGlobals>;

package/dist/lib/game/game-canvas.d.ts

@@ -0,0 +1,34 @@
+import { AspectRatioValue } from '../device/aspect-ratio';
+export interface GameCanvasOptions {
+    id: string;
+    container?: HTMLElement;
+    containerId?: string;
+    canvas?: HTMLCanvasElement;
+    bodyBackground?: string;
+    fullscreen?: boolean;
+    aspectRatio: AspectRatioValue | number;
+}
+/**
+ * GameCanvas is a DOM delegate that owns:
+ * - container lookup/creation and styling (including fullscreen centering)
+ * - body background application
+ * - canvas mounting into container
+ * - aspect ratio sizing via AspectRatioDelegate
+ */
+export declare class GameCanvas {
+    id: string;
+    container: HTMLElement;
+    canvas: HTMLCanvasElement;
+    bodyBackground?: string;
+    fullscreen: boolean;
+    aspectRatio: number;
+    private ratioDelegate;
+    constructor(options: GameCanvasOptions);
+    applyBodyBackground(): void;
+    mountCanvas(): void;
+    mountRenderer(rendererDom: HTMLCanvasElement, onResize: (width: number, height: number) => void): void;
+    centerIfFullscreen(): void;
+    attachAspectRatio(onResize: (width: number, height: number) => void): void;
+    destroy(): void;
+    private ensureContainer;
+}

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

@@ -0,0 +1,57 @@
+import { AspectRatioDelegate as s } from "../device/aspect-ratio.js";
+class o {
+  id;
+  container;
+  canvas;
+  bodyBackground;
+  fullscreen;
+  aspectRatio;
+  ratioDelegate = null;
+  constructor(t) {
+    this.id = t.id, this.container = this.ensureContainer(t.containerId ?? t.id, t.container), this.canvas = t.canvas ?? document.createElement("canvas"), this.bodyBackground = t.bodyBackground, this.fullscreen = !!t.fullscreen, this.aspectRatio = (typeof t.aspectRatio == "number", t.aspectRatio);
+  }
+  applyBodyBackground() {
+    this.bodyBackground && (document.body.style.background = this.bodyBackground);
+  }
+  mountCanvas() {
+    for (; this.container.firstChild; )
+      this.container.removeChild(this.container.firstChild);
+    this.container.appendChild(this.canvas);
+  }
+  mountRenderer(t, i) {
+    for (; this.container.firstChild; )
+      this.container.removeChild(this.container.firstChild);
+    this.container.appendChild(t), this.canvas = t, this.attachAspectRatio(i);
+  }
+  centerIfFullscreen() {
+    if (!this.fullscreen)
+      return;
+    const t = this.container.style;
+    t.display = "flex", t.alignItems = "center", t.justifyContent = "center", t.position = "fixed", t.inset = "0";
+  }
+  attachAspectRatio(t) {
+    this.ratioDelegate ? this.ratioDelegate.apply() : (this.ratioDelegate = new s({
+      container: this.container,
+      canvas: this.canvas,
+      aspectRatio: this.aspectRatio,
+      onResize: t
+    }), this.ratioDelegate.attach());
+  }
+  destroy() {
+    this.ratioDelegate?.detach(), this.ratioDelegate = null;
+  }
+  ensureContainer(t, i) {
+    if (i)
+      return i;
+    if (t) {
+      const a = document.getElementById(t);
+      if (a)
+        return a;
+    }
+    const n = t || this.id || "zylem-root", e = document.createElement("main");
+    return e.setAttribute("id", n), e.style.position = "relative", e.style.width = "100%", e.style.height = "100%", document.body.appendChild(e), e;
+  }
+}
+export {
+  o as GameCanvas
+};

package/dist/lib/game/game-config.d.ts

@@ -0,0 +1,47 @@
+import { StageInterface } from "../types";
+import { GameInputConfig } from "./game-interfaces";
+import { AspectRatio, AspectRatioValue } from "../device/aspect-ratio";
+export type GameConfigLike = Partial<{
+    id: string;
+    globals: Record<string, any>;
+    stages: StageInterface[];
+    debug: boolean;
+    time: number;
+    input: GameInputConfig;
+    /** numeric value or key in AspectRatio */
+    aspectRatio: AspectRatioValue | keyof typeof AspectRatio;
+    fullscreen: boolean;
+    /** CSS background value for document body */
+    bodyBackground: string;
+    /** existing container by reference */
+    container: HTMLElement;
+    /** create/find container by id */
+    containerId: string;
+    /** optional canvas if caller wants to manage it */
+    canvas: HTMLCanvasElement;
+}>;
+export declare class GameConfig {
+    id: string;
+    globals: Record<string, any>;
+    stages: StageInterface[];
+    debug: boolean;
+    time: number;
+    input: GameInputConfig | undefined;
+    aspectRatio: number;
+    fullscreen: boolean;
+    bodyBackground: string | undefined;
+    container: HTMLElement;
+    containerId?: string | undefined;
+    canvas?: HTMLCanvasElement | undefined;
+    constructor(id: string, globals: Record<string, any>, stages: StageInterface[], debug: boolean, time: number, input: GameInputConfig | undefined, aspectRatio: number, fullscreen: boolean, bodyBackground: string | undefined, container: HTMLElement, containerId?: string | undefined, canvas?: HTMLCanvasElement | undefined);
+}
+export declare function createDefaultGameConfig(base?: Partial<Pick<GameConfig, 'id' | 'debug' | 'time' | 'input'>> & {
+    stages?: StageInterface[];
+    globals?: Record<string, any>;
+}): GameConfig;
+export declare function resolveGameConfig(user?: GameConfigLike): GameConfig;
+/**
+ * Factory for authoring configuration objects in user code.
+ * Returns a plain object that can be passed to `game(...)`.
+ */
+export declare function gameConfig(config: GameConfigLike): GameConfigLike;

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

@@ -0,0 +1,53 @@
+import { AspectRatio as d } from "../device/aspect-ratio.js";
+class g {
+  id;
+  globals;
+  stages;
+  debug;
+  time;
+  input;
+  aspectRatio;
+  fullscreen;
+  bodyBackground;
+  container;
+  containerId;
+  canvas;
+  constructor(n, o, e, i, a, c, s, l, u, m, f, p) {
+    this.id = n, this.globals = o, this.stages = e, this.debug = i, this.time = a, this.input = c, this.aspectRatio = s, this.fullscreen = l, this.bodyBackground = u, this.container = m, this.containerId = f, this.canvas = p;
+  }
+}
+function r(t, n) {
+  if (n)
+    return n;
+  if (t) {
+    const i = document.getElementById(t);
+    if (i)
+      return i;
+  }
+  const o = t || "zylem-root", e = document.createElement("main");
+  return e.setAttribute("id", o), e.style.position = "relative", e.style.width = "100%", e.style.height = "100%", document.body.appendChild(e), e;
+}
+function b(t) {
+  const n = t?.id ?? "zylem", o = r(n);
+  return new g(n, t?.globals ?? {}, t?.stages ?? [], !!t?.debug, t?.time ?? 0, t?.input, d.SixteenByNine, !0, "#000000", o, n, void 0);
+}
+function y(t) {
+  const n = b({
+    id: t?.id ?? "zylem",
+    debug: !!t?.debug,
+    time: t?.time ?? 0,
+    input: t?.input,
+    stages: t?.stages ?? [],
+    globals: t?.globals ?? {}
+  }), o = t?.containerId ?? n.containerId, e = r(o, t?.container ?? null), i = t?.aspectRatio ?? n.aspectRatio, a = typeof i == "number" ? i : d[i] ?? d.SixteenByNine, c = t?.fullscreen ?? n.fullscreen, s = t?.bodyBackground ?? n.bodyBackground, l = t?.canvas ?? void 0;
+  return new g(t?.id ?? n.id, t?.globals ?? n.globals, t?.stages ?? n.stages, !!(t?.debug ?? n.debug), t?.time ?? n.time, t?.input ?? n.input, a, c, s, e, o, l);
+}
+function B(t) {
+  return { ...t };
+}
+export {
+  g as GameConfig,
+  b as createDefaultGameConfig,
+  B as gameConfig,
+  y as resolveGameConfig
+};

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

@@ -0,0 +1,18 @@
+import { Stage } from '../stage/stage';
+import type { BasicTypes, GlobalVariablesType, ZylemGameConfig, GameInputConfig } from './game-interfaces';
+export declare const gameDefaultsState: Partial<ZylemGameConfig<Stage, any, GlobalVariablesType>>;
+/** Replace multiple defaults at once (shallow merge). */
+export declare function setGameDefaults(partial: Partial<ZylemGameConfig<Stage, any, GlobalVariablesType>>): void;
+/** Reset defaults back to library defaults. */
+export declare function resetGameDefaults(): void;
+/**
+ * Get a plain object copy of the current defaults.
+ */
+export declare function getGameDefaultConfig<TGlobals extends Record<string, BasicTypes> = GlobalVariablesType>(): {
+    id: string;
+    globals: TGlobals;
+    stages: Stage[];
+    debug?: boolean;
+    time?: number;
+    input?: GameInputConfig;
+};

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

@@ -0,0 +1,24 @@
+import { proxy as i } from "valtio/vanilla";
+import { stage as e } from "../stage/stage.js";
+const a = () => ({
+  id: "zylem",
+  globals: {},
+  stages: [e()],
+  debug: !1,
+  time: 0,
+  input: void 0
+}), t = i({ ...a() });
+function g() {
+  return {
+    id: t.id ?? "zylem",
+    globals: t.globals ?? {},
+    stages: t.stages ?? [e()],
+    debug: t.debug,
+    time: t.time,
+    input: t.input
+  };
+}
+export {
+  t as gameDefaultsState,
+  g as getGameDefaultConfig
+};

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

@@ -0,0 +1,17 @@
+import { proxy as a } from "valtio/vanilla";
+const o = a({
+  id: "",
+  globals: {},
+  time: 0
+});
+function r(t, l) {
+  o.globals[t] = l;
+}
+function i(t) {
+  return t !== void 0 ? o.globals[t] : o.globals;
+}
+export {
+  i as getGlobalState,
+  r as setGlobalState,
+  o as state
+};

package/dist/lib/game/game.d.ts

@@ -1,9 +1,8 @@
-import { BaseNode } from '../core/base-node';
 import { ZylemGame } from './zylem-game';
 import { Stage } from '../stage/stage';
 import { DestroyFunction, IGame, SetupFunction, UpdateFunction } from '../core/base-node-life-cycle';
-import { GameEntityLifeCycle } from '../entities/entity';
-import { BasicTypes, GlobalVariablesType, ZylemGameConfig } from './game-interfaces';
+import { BasicTypes, GlobalVariablesType } from './game-interfaces';
+import { GameOptions } from '../core/utility/nodes';
 export declare class Game<TGlobals extends Record<string, BasicTypes> = GlobalVariablesType> implements IGame<TGlobals> {
     gameRef: ZylemGame<TGlobals> | null;
     options: GameOptions<TGlobals>;
@@ -28,7 +27,6 @@ export declare class Game<TGlobals extends Record<string, BasicTypes> = GlobalVa
     setGlobal<K extends keyof TGlobals>(key: K, value: TGlobals[K]): void;
     onGlobalChange<K extends keyof TGlobals>(key: K, callback: (value: TGlobals[K]) => void): void;
 }
-type GameOptions<TGlobals extends Record<string, BasicTypes> = GlobalVariablesType> = Array<ZylemGameConfig<Stage, Game<TGlobals>, TGlobals> | Stage | GameEntityLifeCycle | BaseNode>;
 /**
  * create a new game
  * @param options GameOptions - Array of IGameOptions, Stage, GameEntity, or BaseNode objects
@@ -38,4 +36,3 @@ type GameOptions<TGlobals extends Record<string, BasicTypes> = GlobalVariablesTy
  * @returns Game
  */
 export declare function game<TGlobals extends Record<string, BasicTypes> = GlobalVariablesType>(...options: GameOptions<TGlobals>): Game<TGlobals>;
-export {};

package/dist/lib/game/game.js

@@ -0,0 +1,133 @@
+import { ZylemGame as n } from "./zylem-game.js";
+import { Stage as o } from "../stage/stage.js";
+import { setPaused as r } from "../debug/debug-state.js";
+import { getGlobalState as g, setGlobalState as f } from "./game-state.js";
+import { convertNodes as h } from "../core/utility/nodes.js";
+import { resolveGameConfig as l } from "./game-config.js";
+class u {
+  gameRef = null;
+  options;
+  pendingGlobalChangeHandlers = [];
+  update = () => {
+  };
+  setup = () => {
+  };
+  destroy = () => {
+  };
+  refErrorMessage = "lost reference to game";
+  constructor(t) {
+    this.options = t;
+  }
+  async start() {
+    const t = await this.load();
+    return this.gameRef = t, this.setOverrides(), t.start(), this;
+  }
+  async load() {
+    console.log("loading game", this.options);
+    const t = await h(this.options), s = l(t), e = new n({
+      ...t,
+      ...s
+    }, this);
+    return await e.loadStage(t.stages[0]), e;
+  }
+  setOverrides() {
+    if (!this.gameRef) {
+      console.error(this.refErrorMessage);
+      return;
+    }
+    if (this.gameRef.customSetup = this.setup, this.gameRef.customUpdate = this.update, this.gameRef.customDestroy = this.destroy, this.pendingGlobalChangeHandlers.length) {
+      for (const { key: t, callback: s } of this.pendingGlobalChangeHandlers)
+        this.gameRef.onGlobalChange(t, s);
+      this.pendingGlobalChangeHandlers = [];
+    }
+  }
+  async pause() {
+    r(!0);
+  }
+  async resume() {
+    r(!1), this.gameRef && (this.gameRef.previousTimeStamp = 0, this.gameRef.timer.reset());
+  }
+  async reset() {
+    if (!this.gameRef) {
+      console.error(this.refErrorMessage);
+      return;
+    }
+    await this.gameRef.loadStage(this.gameRef.stages[0]);
+  }
+  async nextStage() {
+    if (!this.gameRef) {
+      console.error(this.refErrorMessage);
+      return;
+    }
+    const t = this.gameRef.currentStageId, s = this.gameRef.stages.findIndex((a) => a.stageRef.uuid === t), e = this.gameRef.stages[s + 1];
+    if (!e) {
+      console.error("next stage called on last stage");
+      return;
+    }
+    await this.gameRef.loadStage(e);
+  }
+  async previousStage() {
+    if (!this.gameRef) {
+      console.error(this.refErrorMessage);
+      return;
+    }
+    const t = this.gameRef.currentStageId, s = this.gameRef.stages.findIndex((a) => a.stageRef.uuid === t), e = this.gameRef.stages[s - 1];
+    if (!e) {
+      console.error("previous stage called on first stage");
+      return;
+    }
+    await this.gameRef.loadStage(e);
+  }
+  async goToStage() {
+  }
+  async end() {
+  }
+  add(...t) {
+    for (const s of t)
+      if (s) {
+        if (s instanceof o) {
+          this.gameRef ? (this.gameRef.stages.push(s), this.gameRef.stageMap.set(s.stageRef.uuid, s)) : this.options.push(s);
+          continue;
+        }
+        if (typeof s == "function") {
+          try {
+            const e = s();
+            e instanceof o ? this.gameRef ? (this.gameRef.stages.push(e), this.gameRef.stageMap.set(e.stageRef.uuid, e)) : this.options.push(e) : e && typeof e.then == "function" && e.then((a) => {
+              a instanceof o && (this.gameRef ? (this.gameRef.stages.push(a), this.gameRef.stageMap.set(a.stageRef.uuid, a)) : this.options.push(a));
+            }).catch((a) => console.error("Failed to add async stage", a));
+          } catch (e) {
+            console.error("Error executing stage factory", e);
+          }
+          continue;
+        }
+        s && typeof s.then == "function" && s.then((e) => {
+          e instanceof o && (this.gameRef ? (this.gameRef.stages.push(e), this.gameRef.stageMap.set(e.stageRef.uuid, e)) : this.options.push(e));
+        }).catch((e) => console.error("Failed to add async stage", e));
+      }
+    return this;
+  }
+  getGlobal(t) {
+    return this.gameRef ? this.gameRef.getGlobal(t) : g(t);
+  }
+  setGlobal(t, s) {
+    if (this.gameRef) {
+      this.gameRef.setGlobal(t, s);
+      return;
+    }
+    f(t, s);
+  }
+  onGlobalChange(t, s) {
+    if (this.gameRef) {
+      this.gameRef.onGlobalChange(t, s);
+      return;
+    }
+    this.pendingGlobalChangeHandlers.push({ key: t, callback: s });
+  }
+}
+function S(...i) {
+  return new u(i);
+}
+export {
+  u as Game,
+  S as game
+};