@energy8platform/game-engine 0.7.1 → 0.9.0

package/dist/index.esm.js

@@ -363,14 +363,17 @@ class Tween {
  * ```
  */
 class SceneManager extends EventEmitter {
+    static MAX_TRANSITION_DEPTH = 10;
     /** Root container that scenes are added to */
     root;
     registry = new Map();
     stack = [];
-    _transitioning = false;
+    _transitionDepth = 0;
     /** Current viewport dimensions — set by ViewportManager */
     _width = 0;
     _height = 0;
+    /** @internal GameApplication reference — passed to scenes */
+    _app;
     constructor(root) {
         super();
         if (root)
@@ -380,6 +383,10 @@ class SceneManager extends EventEmitter {
     setRoot(root) {
         this.root = root;
     }
+    /** @internal Set the app reference (called by GameApplication) */
+    setApp(app) {
+        this._app = app;
+    }
     /** Register a scene class by key */
     register(key, ctor) {
         this.registry.set(key, ctor);
@@ -395,12 +402,15 @@ class SceneManager extends EventEmitter {
     }
     /** Whether a scene transition is in progress */
     get isTransitioning() {
-        return this._transitioning;
+        return this._transitionDepth > 0;
     }
     /**
      * Navigate to a scene, replacing the entire stack.
      */
     async goto(key, data, transition) {
+        if (this._transitionDepth >= SceneManager.MAX_TRANSITION_DEPTH) {
+            throw new Error('[SceneManager] Max transition depth exceeded — possible infinite loop');
+        }
         const prevKey = this.currentKey;
         // Exit all current scenes
         while (this.stack.length > 0) {
@@ -415,6 +425,9 @@ class SceneManager extends EventEmitter {
      * Useful for overlays, modals, pause screens.
      */
     async push(key, data, transition) {
+        if (this._transitionDepth >= SceneManager.MAX_TRANSITION_DEPTH) {
+            throw new Error('[SceneManager] Max transition depth exceeded — possible infinite loop');
+        }
         const prevKey = this.currentKey;
         await this.pushInternal(key, data, transition);
         this.emit('change', { from: prevKey, to: key });
@@ -427,6 +440,9 @@ class SceneManager extends EventEmitter {
             console.warn('[SceneManager] Cannot pop the last scene');
             return;
         }
+        if (this._transitionDepth >= SceneManager.MAX_TRANSITION_DEPTH) {
+            throw new Error('[SceneManager] Max transition depth exceeded — possible infinite loop');
+        }
         const prevKey = this.currentKey;
         await this.popInternal(true, transition);
         this.emit('change', { from: prevKey, to: this.currentKey });
@@ -435,6 +451,9 @@ class SceneManager extends EventEmitter {
      * Replace the top scene with a new one.
      */
     async replace(key, data, transition) {
+        if (this._transitionDepth >= SceneManager.MAX_TRANSITION_DEPTH) {
+            throw new Error('[SceneManager] Max transition depth exceeded — possible infinite loop');
+        }
         const prevKey = this.currentKey;
         await this.popInternal(false);
         await this.pushInternal(key, data, transition);
@@ -476,10 +495,14 @@ class SceneManager extends EventEmitter {
         if (!Ctor) {
             throw new Error(`[SceneManager] Scene "${key}" is not registered`);
         }
-        return new Ctor();
+        const scene = new Ctor();
+        if (this._app) {
+            scene.__engineApp = this._app;
+        }
+        return scene;
     }
     async pushInternal(key, data, transition) {
-        this._transitioning = true;
+        this._transitionDepth++;
         const scene = this.createScene(key);
         this.root.addChild(scene.container);
         // Set initial size
@@ -491,20 +514,20 @@ class SceneManager extends EventEmitter {
         // Push to stack BEFORE onEnter so currentKey is correct during initialization
         this.stack.push({ scene, key });
         await scene.onEnter?.(data);
-        this._transitioning = false;
+        this._transitionDepth--;
     }
     async popInternal(showTransition, transition) {
         const entry = this.stack.pop();
         if (!entry)
             return;
-        this._transitioning = true;
+        this._transitionDepth++;
         await entry.scene.onExit?.();
         if (showTransition) {
             await this.transitionOut(entry.scene.container, transition);
         }
         entry.scene.onDestroy?.();
         entry.scene.container.destroy({ children: true });
-        this._transitioning = false;
+        this._transitionDepth--;
     }
     async transitionIn(container, config) {
         const type = config?.type ?? TransitionType.NONE;
@@ -2237,6 +2260,7 @@ class GameApplication extends EventEmitter {
         });
         // Wire SceneManager to the PixiJS stage
         this.scenes.setRoot(this.app.stage);
+        this.scenes.setApp(this);
         // Wire viewport resize → scene manager + input manager
         this.viewport.on('resize', ({ width, height, scale }) => {
             this.scenes.resize(width, height);
@@ -2322,10 +2346,11 @@ class GameApplication extends EventEmitter {
  * ```
  */
 class StateMachine extends EventEmitter {
+    static MAX_TRANSITION_DEPTH = 10;
     _states = new Map();
     _guards = new Map();
     _current = null;
-    _transitioning = false;
+    _transitionDepth = 0;
     _context;
     constructor(context) {
         super();
@@ -2337,7 +2362,7 @@ class StateMachine extends EventEmitter {
     }
     /** Whether a transition is in progress */
     get isTransitioning() {
-        return this._transitioning;
+        return this._transitionDepth > 0;
     }
     /** State machine context (shared data) */
     get context() {
@@ -2385,9 +2410,8 @@ class StateMachine extends EventEmitter {
      * @returns true if the transition succeeded, false if blocked by a guard
      */
     async transition(to, data) {
-        if (this._transitioning) {
-            console.warn('[StateMachine] Transition already in progress');
-            return false;
+        if (this._transitionDepth >= StateMachine.MAX_TRANSITION_DEPTH) {
+            throw new Error('[StateMachine] Max transition depth exceeded — possible infinite loop');
         }
         const from = this._current;
         // Check guard
@@ -2402,7 +2426,7 @@ class StateMachine extends EventEmitter {
         if (!toState) {
             throw new Error(`[StateMachine] State "${to}" not registered.`);
         }
-        this._transitioning = true;
+        this._transitionDepth++;
         try {
             // Exit current state
             if (from !== null) {
@@ -2419,7 +2443,7 @@ class StateMachine extends EventEmitter {
             throw err;
         }
         finally {
-            this._transitioning = false;
+            this._transitionDepth--;
         }
         return true;
     }
@@ -2460,7 +2484,7 @@ class StateMachine extends EventEmitter {
             await state?.exit?.(this._context);
         }
         this._current = null;
-        this._transitioning = false;
+        this._transitionDepth = 0;
     }
     /**
      * Destroy the state machine.