@energy8platform/platform-core 0.16.1 → 0.16.2

package/src/lua/LuaEngine.ts

@@ -1,5 +1,5 @@
 import type { PlayParams, SessionData } from '@energy8platform/game-sdk';
-import type { LuaEngineConfig, LuaPlayResult, GameDefinition } from './types';
+import type { LuaEngineConfig, LuaPlayResult, GameDefinition, ActionDefinition } from './types';
 import { LuaEngineAPI, createSeededRng, luaToJS, pushJSValue, cachedToLuastring } from './LuaEngineAPI';
 import { ActionRouter } from './ActionRouter';
 import { SessionManager } from './SessionManager';
@@ -193,6 +193,12 @@ export class LuaEngine {
       }
     }
 
+    // Apply MapState parity — server's state_mapper.go injects these
+    // variable-derived keys into the client data so scripts don't have to
+    // surface them manually. Lua-provided values take precedence (server
+    // also overwrites variable-derived keys with state.Data on merge).
+    this.applyMapStateInjection(stateVars, data);
+
     // 7. Handle _persist_* and _persist_game_* keys
     this.sessionManager.storePersistData(data);
     this.persistentState.storeGameData(data);
@@ -214,7 +220,8 @@ export class LuaEngine {
     }
 
     // 8. Evaluate transitions (server uses state.Variables which is stateVars)
-    const { rule, nextActions } = this.actionRouter.evaluateTransitions(action, stateVars);
+    const { rule } = this.actionRouter.evaluateTransitions(action, stateVars);
+    let nextActions = rule.next_actions;
 
     // 9. Determine credit behavior (server: creditNow logic)
     let creditDeferred = action.credit === 'defer' || rule.credit_override === 'defer';
@@ -227,9 +234,15 @@ export class LuaEngine {
     // Calculate max win cap for session
     const maxWinCap = this.calculateMaxWinCap(bet);
 
+    // Snapshot the round data for history (matches server's MapStateForHistory:
+    // strip _persist_* keys, but those are already removed below before
+    // returning — at this point in the flow they may still be in `data`,
+    // so we filter inline).
+    const roundData = stripPersistKeys(data);
+
     if (rule.creates_session && !this.sessionManager.isActive) {
       // CREATE SESSION — initial spin counted (server: createSession includes spinWin)
-      session = this.sessionManager.createSession(rule, stateVars, bet, spinWin, maxWinCap);
+      session = this.sessionManager.createSession(rule, stateVars, bet, spinWin, maxWinCap, roundData);
       creditDeferred = true;
       resultTotalWin = spinWin;
 
@@ -239,16 +252,23 @@ export class LuaEngine {
       }
     } else if (this.sessionManager.isActive) {
       // UPDATE SESSION — accumulate win, check completion
-      session = this.sessionManager.updateSession(rule, stateVars, spinWin);
+      session = this.sessionManager.updateSession(rule, stateVars, spinWin, roundData);
 
       if (session?.completed) {
-        // SESSION COMPLETED — server returns session.TotalWin as result.TotalWin
+        // SESSION COMPLETED — server returns session.TotalWin as result.TotalWin,
+        // and pulls next_actions from the explicit completion transition
+        // (findCompletionNextActions) rather than the matched 'continue' rule.
         const completed = this.sessionManager.completeSession();
         session = completed.session;
         resultTotalWin = completed.totalWin;
         sessionCompleted = true;
         creditDeferred = false;
 
+        const completionNext = findCompletionNextActions(action);
+        if (completionNext) {
+          nextActions = completionNext;
+        }
+
         // Clean up session-scoped variables
         for (const varName of completed.sessionVarNames) {
           delete this.variables[varName];
@@ -386,6 +406,35 @@ export class LuaEngine {
     return result as Record<string, unknown>;
   }
 
+  /**
+   * Mirror server's state_mapper.go MapState — surface variable-derived
+   * fields so scripts that don't manually echo them in the result table
+   * still produce a server-shaped data map. Lua keys win on conflict.
+   */
+  private applyMapStateInjection(
+    vars: Record<string, number>,
+    data: Record<string, unknown>,
+  ): void {
+    const m = vars.multiplier;
+    if (typeof m === 'number' && m > 1 && data.multiplier === undefined) {
+      data.multiplier = m;
+    }
+
+    const gm = vars.global_multiplier;
+    if (typeof gm === 'number' && gm > 1 && data.global_multiplier === undefined) {
+      data.global_multiplier = gm;
+    }
+
+    const fs = vars.free_spins_remaining;
+    if (typeof fs === 'number' && fs > 0 && data.free_spins_total === undefined) {
+      data.free_spins_total = Math.trunc(fs);
+    }
+
+    if (vars.max_win_reached === 1 && data.max_win_reached === undefined) {
+      data.max_win_reached = true;
+    }
+  }
+
   private calculateMaxWinCap(bet: number): number | undefined {
     const mw = this.gameDefinition.max_win;
     if (!mw) return undefined;
@@ -410,3 +459,37 @@ export class LuaEngine {
     return parseInt(entries[entries.length - 1][0], 10);
   }
 }
+
+// ─── Module helpers ─────────────────────────────────────
+
+/**
+ * Strip _persist_* and _persist_game_* keys from a data map — matches
+ * server's MapStateForHistory used when recording session round history.
+ */
+function stripPersistKeys(data: Record<string, unknown>): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  for (const k of Object.keys(data)) {
+    if (k.startsWith('_persist_') || k.startsWith('_persist_game_')) continue;
+    out[k] = data[k];
+  }
+  return out;
+}
+
+/**
+ * Mirror server's findCompletionNextActions: when a session naturally
+ * completes, the matched 'continue' rule's next_actions are NOT what
+ * the client should see — the explicit complete_session transition wins,
+ * with a fallback to the 'always' transition.
+ */
+function findCompletionNextActions(action: ActionDefinition): string[] | null {
+  let alwaysFallback: string[] | null = null;
+  for (const t of action.transitions) {
+    if (t.complete_session && t.next_actions && t.next_actions.length > 0) {
+      return t.next_actions;
+    }
+    if (t.condition.trim() === 'always' && t.next_actions && t.next_actions.length > 0 && alwaysFallback === null) {
+      alwaysFallback = t.next_actions;
+    }
+  }
+  return alwaysFallback;
+}

package/src/lua/SessionManager.ts

@@ -1,6 +1,13 @@
 import type { SessionData } from '@energy8platform/game-sdk';
 import type { TransitionRule } from './types';
 
+/** Per-round history entry — wire shape mirrors server SessionInfo.History. */
+export interface SessionRound {
+  spinIndex: number;
+  win: number;
+  data: Record<string, unknown>;
+}
+
 interface SessionState {
   spinsRemaining: number;
   spinsPlayed: number;
@@ -13,6 +20,7 @@ interface SessionState {
   persistentVarNames: string[];
   persistentVars: Record<string, number>;
   persistentData: Record<string, unknown>;
+  history: SessionRound[];
 }
 
 const MAX_SESSION_SPINS = 200;
@@ -56,7 +64,8 @@ export class SessionManager {
 
   /**
    * Create a new session from a transition rule.
-   * Server behavior: initial spin is already counted (spinsPlayed=1, totalWin includes spinWin).
+   * Server behavior: initial spin is already counted (spinsPlayed=1, totalWin includes spinWin),
+   * and history[0] holds the trigger spin's data.
    */
   createSession(
     rule: TransitionRule,
@@ -64,6 +73,7 @@ export class SessionManager {
     bet: number,
     spinWin: number,
     maxWinCap: number | undefined,
+    triggerData: Record<string, unknown>,
   ): SessionData {
     let spinsRemaining = -1;
     let spinsVarName: string | undefined;
@@ -90,6 +100,7 @@ export class SessionManager {
       persistentVarNames,
       persistentVars,
       persistentData: {},
+      history: [{ spinIndex: 0, win: spinWin, data: triggerData }],
     };
 
     return this.toSessionData();
@@ -104,9 +115,18 @@ export class SessionManager {
     rule: TransitionRule,
     variables: Record<string, number>,
     spinWin: number,
+    roundData: Record<string, unknown>,
   ): SessionData {
     if (!this.session) throw new Error('No active session');
 
+    // Append history with PRE-increment spin index (matches server's
+    // updateSession: append round, THEN increment SpinsPlayed).
+    this.session.history.push({
+      spinIndex: this.session.spinsPlayed,
+      win: spinWin,
+      data: roundData,
+    });
+
     // Accumulate win and count spin
     this.session.totalWin += spinWin;
     this.session.spinsPlayed++;
@@ -222,6 +242,8 @@ export class SessionManager {
       completed: this.session.completed,
       maxWinReached: this.session.maxWinReached,
       betAmount: this.session.bet,
+      // Snapshot the array so downstream mutation can't corrupt internal state.
+      history: [...this.session.history],
     };
   }
 }

package/src/lua/types.ts

@@ -11,6 +11,12 @@ export interface GameDefinition {
   buy_bonus?: BuyBonusConfig;
   ante_bet?: AnteBetConfig;
   persistent_state?: PersistentStateConfig;
+  /**
+   * Session expiry duration as a Go-style duration string ("24h", "2h", "5ms").
+   * Mirrors the platform's GameDefinition.SessionTTL — defaults to 24h on
+   * the server when absent. Used by DevBridge to surface SESSION_EXPIRED.
+   */
+  session_ttl?: string;
 }
 
 export interface BetLevelsConfig {