@energy8platform/game-engine 0.10.1 → 0.10.3

package/dist/index.d.ts

@@ -1904,7 +1904,7 @@ interface DevBridgeConfig {
     networkDelay?: number;
     /** Enable debug logging */
     debug?: boolean;
-    /** Lua script source code. When set, overrides onPlay with LuaEngine. */
+    /** Lua script source code. When set, play requests are routed to the Vite dev server's LuaEngine. */
     luaScript?: string;
     /** Game definition for Lua engine (actions, transitions, etc.) */
     gameDefinition?: GameDefinition;
@@ -1918,11 +1918,11 @@ interface DevBridgeConfig {
  * `CasinoGameSDK` via a shared in-memory `MemoryChannel`, removing
  * the need for postMessage and iframes.
  *
- * This allows games to be developed and tested without a real backend.
+ * When `luaScript` is set, play requests are sent to the Vite dev server
+ * which runs LuaEngine in Node.js — no fengari in the browser.
  *
  * @example
  * ```ts
- * // In your dev entry point or vite plugin
  * import { DevBridge } from '@energy8platform/game-engine/debug';
  *
  * const devBridge = new DevBridge({
@@ -1931,10 +1931,7 @@ interface DevBridgeConfig {
  *   gameConfig: { id: 'my-slot', type: 'slot', betLevels: [0.2, 0.5, 1, 2] },
  *   onPlay: ({ action, bet }) => ({
  *     totalWin: Math.random() > 0.5 ? bet * (Math.random() * 20) : 0,
- *     data: {
- *       matrix: generateRandomMatrix(5, 3, 10),
- *       win_lines: [],
- *     },
+ *     data: { matrix: [[1,2,3],[4,5,6],[7,8,9]] },
  *   }),
  * });
  * devBridge.start();
@@ -1945,7 +1942,7 @@ declare class DevBridge {
     private _balance;
     private _roundCounter;
     private _bridge;
-    private _luaEngine;
+    private _useLuaServer;
     constructor(config?: DevBridgeConfig);
     /** Current mock balance */
     get balance(): number;
@@ -1957,9 +1954,10 @@ declare class DevBridge {
     setBalance(balance: number): void;
     /** Destroy the dev bridge */
     destroy(): void;
-    private initLuaEngine;
     private handleGameReady;
     private handlePlayRequest;
+    private executeLuaOnServer;
+    private buildFallbackResult;
     private handlePlayAck;
     private handleGetBalance;
     private handleGetState;
@@ -1967,160 +1965,5 @@ declare class DevBridge {
     private delayedSend;
 }
 
-/**
- * Runs Lua game scripts locally, replicating the platform's server-side execution.
- *
- * Implements the full lifecycle: action routing → state assembly → Lua execute() →
- * result extraction → transition evaluation → session management.
- *
- * @example
- * ```ts
- * const engine = new LuaEngine({
- *   script: luaSource,
- *   gameDefinition: { id: 'my-slot', type: 'SLOT', actions: { ... } },
- * });
- *
- * const result = engine.execute({ action: 'spin', bet: 1.0 });
- * // result.data.matrix, result.totalWin, result.nextActions, etc.
- * ```
- */
-declare class LuaEngine {
-    private L;
-    private api;
-    private actionRouter;
-    private sessionManager;
-    private persistentState;
-    private gameDefinition;
-    private variables;
-    constructor(config: LuaEngineConfig);
-    /** Current session data (if any) */
-    get session(): SessionData | null;
-    /** Current persistent state values */
-    get persistentVars(): Record<string, number>;
-    /**
-     * Execute a play action — the main entry point.
-     * This is what DevBridge calls on each PLAY_REQUEST.
-     */
-    execute(params: PlayParams): LuaPlayResult;
-    /** Reset all state (sessions, persistent vars, variables) */
-    reset(): void;
-    /** Destroy the Lua VM */
-    destroy(): void;
-    private loadScript;
-    private callLuaExecute;
-    private calculateMaxWinCap;
-    private pickFromDistribution;
-}
-
-type RngFunction = () => number;
-/**
- * Seeded xoshiro128** PRNG for deterministic simulation/replay.
- * Period: 2^128 - 1
- */
-declare function createSeededRng(seed: number): RngFunction;
-/**
- * Implements and registers all platform `engine.*` functions into a Lua state.
- */
-declare class LuaEngineAPI {
-    private rng;
-    private logger;
-    private gameDefinition;
-    constructor(gameDefinition: GameDefinition, rng?: RngFunction, logger?: (level: string, msg: string) => void);
-    /** Register `engine` global table on the Lua state */
-    register(L: any): void;
-    random(min: number, max: number): number;
-    randomFloat(): number;
-    randomWeighted(weights: number[]): number;
-    shuffle<T>(arr: T[]): T[];
-    getConfig(): Record<string, unknown>;
-    private registerFunction;
-}
-
-interface TransitionMatch {
-    rule: TransitionRule;
-    nextActions: string[];
-}
-/**
- * Replicates the platform's action dispatch and transition evaluation.
- * Routes play requests to the correct action, evaluates transition conditions
- * against current variables to determine next actions and session operations.
- */
-declare class ActionRouter {
-    private actions;
-    constructor(gameDefinition: GameDefinition);
-    /** Look up action by name and validate prerequisites */
-    resolveAction(actionName: string, hasSession: boolean): ActionDefinition;
-    /** Evaluate transitions in order, return the first matching rule */
-    evaluateTransitions(action: ActionDefinition, variables: Record<string, number>): TransitionMatch;
-}
-/**
- * Evaluates a transition condition expression against variables.
- *
- * Supports:
- * - "always" → true
- * - Simple comparisons: "var > 0", "var == 1", "var >= 10", "var != 0", "var < 5", "var <= 3"
- * - Logical connectives: "expr && expr", "expr || expr"
- *
- * This covers all patterns used by the platform's govaluate conditions.
- */
-declare function evaluateCondition(condition: string, variables: Record<string, number>): boolean;
-
-/**
- * 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.
- */
-declare class SessionManager {
-    private session;
-    get isActive(): boolean;
-    get current(): SessionData | null;
-    get sessionTotalWin(): number;
-    /** Create a new session from a transition rule */
-    createSession(rule: TransitionRule, variables: Record<string, number>, bet: number): SessionData;
-    /** Update session after a spin: decrement counter, accumulate win, handle retrigger */
-    updateSession(rule: TransitionRule, variables: Record<string, number>, spinWin: number): SessionData;
-    /** Complete the session, return accumulated totalWin */
-    completeSession(): {
-        totalWin: number;
-        session: SessionData;
-    };
-    /** Mark max win reached — stops the session */
-    markMaxWinReached(): void;
-    /** Store _persist_* data extracted from Lua result */
-    storePersistData(data: Record<string, unknown>): void;
-    /** Get _ps_* params to inject into next execute() call */
-    getPersistentParams(): Record<string, unknown>;
-    /** Reset all session state */
-    reset(): void;
-    private toSessionData;
-}
-
-/**
- * Manages cross-spin persistent state — variables that survive between base game spins.
- * Separate from session-scoped persistence (handled by SessionManager).
- *
- * Handles two mechanisms:
- * 1. Numeric vars declared in `persistent_state.vars` — stored in state.variables
- * 2. Complex data with `_persist_game_*` prefix — stored separately, injected as `_ps_*`
- */
-declare class PersistentState {
-    private config;
-    private vars;
-    private gameData;
-    constructor(config?: PersistentStateConfig);
-    /** Load persistent vars into variables map before execute() */
-    loadIntoVariables(variables: Record<string, number>): void;
-    /** Save persistent vars from variables map after execute() */
-    saveFromVariables(variables: Record<string, number>): void;
-    /** Extract _persist_game_* keys from Lua return data, store them */
-    storeGameData(data: Record<string, unknown>): void;
-    /** Get _ps_* params for next execute() call */
-    getGameDataParams(): Record<string, unknown>;
-    /** Get exposed vars for client data.persistent_state */
-    getExposedVars(): Record<string, number> | undefined;
-    /** Reset all state */
-    reset(): void;
-}
-
-export { ActionRouter, AssetManager, AudioManager, BalanceDisplay, Button, DevBridge, Easing, EventEmitter, FPSOverlay, GameApplication, InputManager, Label, Layout, LoadingScene, LuaEngine, LuaEngineAPI, Modal, Orientation, Panel, PersistentState, ProgressBar, ScaleMode, Scene, SceneManager, ScrollContainer, SessionManager, SpineHelper, SpriteAnimation, StateMachine, Timeline, Toast, TransitionType, Tween, ViewportManager, WinDisplay, createSeededRng, evaluateCondition };
+export { AssetManager, AudioManager, BalanceDisplay, Button, DevBridge, Easing, EventEmitter, FPSOverlay, GameApplication, InputManager, Label, Layout, LoadingScene, Modal, Orientation, Panel, ProgressBar, ScaleMode, Scene, SceneManager, ScrollContainer, SpineHelper, SpriteAnimation, StateMachine, Timeline, Toast, TransitionType, Tween, ViewportManager, WinDisplay };
 export type { ActionDefinition, AssetBundle, AssetEntry, AssetManifest, AudioConfig, BalanceDisplayConfig, ButtonConfig, ButtonState, DevBridgeConfig, EasingFunction, GameApplicationConfig, GameDefinition, GameEngineEvents, IScene, LabelConfig, LayoutAlignment, LayoutAnchor, LayoutConfig, LayoutDirection, LoadingScreenConfig, LuaEngineConfig, LuaPlayResult, ModalConfig, PanelConfig, ProgressBarConfig, SceneConstructor, ScrollContainerConfig, ScrollDirection, SpriteAnimationConfig, ToastConfig, ToastType, TransitionConfig, TransitionRule, TweenOptions, WinDisplayConfig };