@energy8platform/game-engine 0.10.6 → 0.10.8

package/src/lua/SessionManager.ts

@@ -8,14 +8,21 @@ interface SessionState {
   completed: boolean;
   maxWinReached: boolean;
   bet: number;
+  maxWinCap: number | undefined;
+  spinsVarName: string | undefined;
+  persistentVarNames: string[];
   persistentVars: Record<string, number>;
   persistentData: Record<string, unknown>;
 }
 
+const MAX_SESSION_SPINS = 200;
+
 /**
- * Manages session lifecycle: creation, spin counting, retriggers, and completion.
- * Handles both slot sessions (fixed spin count) and table game sessions (unlimited).
- * Also manages _persist_ data roundtrip between Lua calls.
+ * Manages session lifecycle matching the platform server behavior:
+ * - createSession: initial spin counted (spinsPlayed=1, totalWin=spinWin)
+ * - updateSession: accumulates win, decrements spins, checks max win cap on session level
+ * - completeSession: returns cumulative totalWin, cleans up session vars
+ * - Safety cap: 200 spins max per session
  */
 export class SessionManager {
   private session: SessionState | null = null;
@@ -33,32 +40,54 @@ export class SessionManager {
     return this.session?.totalWin ?? 0;
   }
 
-  /** Create a new session from a transition rule */
+  /** Get the fixed bet amount from the session (server uses session bet, not request bet) */
+  get sessionBet(): number | undefined {
+    return this.session?.bet;
+  }
+
+  /** Get spinsVarName to restore free_spins_remaining into variables */
+  get spinsVarName(): string | undefined {
+    return this.session?.spinsVarName;
+  }
+
+  get spinsRemaining(): number {
+    return this.session?.spinsRemaining ?? 0;
+  }
+
+  /**
+   * Create a new session from a transition rule.
+   * Server behavior: initial spin is already counted (spinsPlayed=1, totalWin includes spinWin).
+   */
   createSession(
     rule: TransitionRule,
     variables: Record<string, number>,
     bet: number,
+    spinWin: number,
+    maxWinCap: number | undefined,
   ): SessionData {
-    let spinsRemaining = -1; // unlimited by default
+    let spinsRemaining = -1;
+    let spinsVarName: string | undefined;
     if (rule.session_config?.total_spins_var) {
-      const varName = rule.session_config.total_spins_var;
-      spinsRemaining = variables[varName] ?? -1;
+      spinsVarName = rule.session_config.total_spins_var;
+      spinsRemaining = variables[spinsVarName] ?? -1;
     }
 
+    const persistentVarNames: string[] = rule.session_config?.persistent_vars ?? [];
     const persistentVars: Record<string, number> = {};
-    if (rule.session_config?.persistent_vars) {
-      for (const varName of rule.session_config.persistent_vars) {
-        persistentVars[varName] = variables[varName] ?? 0;
-      }
+    for (const varName of persistentVarNames) {
+      persistentVars[varName] = variables[varName] ?? 0;
     }
 
     this.session = {
       spinsRemaining,
-      spinsPlayed: 0,
-      totalWin: 0,
+      spinsPlayed: 1, // initial spin counts
+      totalWin: spinWin, // initial spin win included
       completed: false,
       maxWinReached: false,
       bet,
+      maxWinCap,
+      spinsVarName,
+      persistentVarNames,
       persistentVars,
       persistentData: {},
     };
@@ -66,7 +95,11 @@ export class SessionManager {
     return this.toSessionData();
   }
 
-  /** Update session after a spin: decrement counter, accumulate win, handle retrigger */
+  /**
+   * Update session after a bonus spin.
+   * Server behavior: accumulate win, decrement spins, check retrigger, check max win cap,
+   * safety cap at 200 spins.
+   */
   updateSession(
     rule: TransitionRule,
     variables: Record<string, number>,
@@ -74,7 +107,7 @@ export class SessionManager {
   ): SessionData {
     if (!this.session) throw new Error('No active session');
 
-    // Accumulate win
+    // Accumulate win and count spin
     this.session.totalWin += spinWin;
     this.session.spinsPlayed++;
 
@@ -91,33 +124,45 @@ export class SessionManager {
       }
     }
 
-    // Update persistent vars
-    if (this.session.persistentVars) {
-      for (const key of Object.keys(this.session.persistentVars)) {
-        if (key in variables) {
-          this.session.persistentVars[key] = variables[key];
-        }
+    // Safety cap: server limits sessions to 200 spins
+    if (this.session.spinsPlayed >= MAX_SESSION_SPINS) {
+      this.session.spinsRemaining = 0;
+    }
+
+    // Update session persistent vars from current variables
+    for (const varName of this.session.persistentVarNames) {
+      if (varName in variables) {
+        this.session.persistentVars[varName] = variables[varName];
       }
     }
 
-    // Auto-complete if spins exhausted
-    if (this.session.spinsRemaining === 0) {
+    // Check max win cap (on session level, not per spin)
+    if (this.session.maxWinCap !== undefined && this.session.totalWin >= this.session.maxWinCap) {
+      this.session.totalWin = this.session.maxWinCap;
+      this.session.spinsRemaining = 0;
+      this.session.maxWinReached = true;
+    }
+
+    // Auto-complete if spins exhausted or explicit complete
+    if (this.session.spinsRemaining === 0 || rule.complete_session) {
       this.session.completed = true;
     }
 
     return this.toSessionData();
   }
 
-  /** Complete the session, return accumulated totalWin and list of session-scoped vars to clean up */
+  /**
+   * Complete the session explicitly.
+   * Returns cumulative totalWin and list of session-scoped var names to clean up.
+   */
   completeSession(): { totalWin: number; session: SessionData; sessionVarNames: string[] } {
     if (!this.session) throw new Error('No active session to complete');
 
     this.session.completed = true;
     const totalWin = this.session.totalWin;
     const session = this.toSessionData();
-    const sessionVarNames = Object.keys(this.session.persistentVars);
+    const sessionVarNames = [...this.session.persistentVarNames];
 
-    // Clear session state so it doesn't leak into the next round
     this.session = null;
 
     return { totalWin, session, sessionVarNames };
@@ -143,18 +188,18 @@ export class SessionManager {
     }
   }
 
-  /** Get _ps_* params to inject into next execute() call */
+  /** Get persistent params to inject into next execute() call */
   getPersistentParams(): Record<string, unknown> {
     if (!this.session) return {};
 
     const params: Record<string, unknown> = {};
 
-    // Session persistent vars (float64)
+    // Session persistent vars (float64) → state.variables
     for (const [key, value] of Object.entries(this.session.persistentVars)) {
       params[key] = value;
     }
 
-    // _persist_ complex data → _ps_*
+    // _persist_ complex data → _ps_* in state.params
     for (const [key, value] of Object.entries(this.session.persistentData)) {
       params[`_ps_${key}`] = value;
     }

package/src/lua/SimulationRunner.ts

@@ -44,7 +44,8 @@ export class SimulationRunner {
       script,
       gameDefinition,
       seed,
-      logger: () => {}, // suppress Lua logs during simulation
+      logger: () => {},
+      simulationMode: true,
     });
 
     const spinCost = this.calculateSpinCost(startAction, bet, gameDefinition, params);
@@ -65,9 +66,10 @@ export class SimulationRunner {
       for (let i = 0; i < iterations; i++) {
         totalWagered += spinCost;
         let roundWin = 0;
+        let roundBonusWin = 0;
 
         // Execute the starting action
-        const result = engine.execute({
+        let result = engine.execute({
           action: startAction,
           bet,
           params,
@@ -76,33 +78,23 @@ export class SimulationRunner {
         const baseWin = result.totalWin;
         roundWin += baseWin;
 
-        // If a bonus session was created, play through it
+        // If a session was created, play through it using nextActions from the engine
         if (result.session && !result.session.completed) {
           bonusTriggered++;
 
-          // Find the bonus action from nextActions (different from startAction)
-          const bonusAction = result.nextActions.find(a => a !== startAction)
-            ?? result.nextActions[0];
-
-          // Play bonus spins until session completes
-          let bonusSessionWin = 0;
           let safetyLimit = 10_000;
-          let lastResult = result;
-
-          while (lastResult.session && !lastResult.session.completed && safetyLimit-- > 0) {
-            lastResult = engine.execute({
-              action: bonusAction,
-              bet,
-            });
-            bonusSessionWin += lastResult.totalWin;
+          while (result.session && !result.session.completed && safetyLimit-- > 0) {
+            const nextAction = result.nextActions[0];
+            result = engine.execute({ action: nextAction, bet });
+            roundBonusWin += result.totalWin;
             bonusSpinsPlayed++;
           }
 
-          bonusWin += bonusSessionWin;
-          roundWin += bonusSessionWin;
+          roundWin += roundBonusWin;
         }
 
         baseGameWin += baseWin;
+        bonusWin += roundBonusWin;
         totalWon += roundWin;
 
         if (roundWin > 0) hits++;

package/src/lua/types.ts

@@ -80,6 +80,8 @@ export interface LuaEngineConfig {
   seed?: number;
   /** Custom logger function */
   logger?: (level: string, msg: string) => void;
+  /** Skip marshalling data fields (matrix, wins, etc.) for faster simulation */
+  simulationMode?: boolean;
 }
 
 export interface LuaPlayResult {