@energy8platform/game-engine 0.15.2 → 0.16.0

package/src/loading/LoadingScene.ts

@@ -3,7 +3,7 @@ import { Scene } from '../core/Scene';
 import { Tween } from '../animation/Tween';
 import { Easing } from '../animation/Easing';
 import type { LoadingScreenConfig } from '../types';
-import { buildLogoSVG, LOADER_BAR_MAX_WIDTH } from './logo';
+import { buildLogoSVG, LOADER_BAR_MAX_WIDTH } from '@energy8platform/platform-core/loading';
 
 /**
  * Build the loading scene variant of the logo SVG.

package/src/loading/index.ts

@@ -1,3 +1,10 @@
+// LoadingScene is pixi-specific and stays in game-engine.
+// CSSPreloader and the Energy8 SVG logo live in platform-core so any
+// renderer (Pixi, Phaser, Three.js) shows the same brand frame.
 export { LoadingScene } from './LoadingScene';
-export { createCSSPreloader, removeCSSPreloader } from './CSSPreloader';
-export { buildLogoSVG, LOADER_BAR_MAX_WIDTH } from './logo';
+export {
+  createCSSPreloader,
+  removeCSSPreloader,
+  buildLogoSVG,
+  LOADER_BAR_MAX_WIDTH,
+} from '@energy8platform/platform-core/loading';

package/src/lua/index.ts

@@ -1,31 +1,3 @@
-export { LuaEngine } from './LuaEngine';
-export { LuaEngineAPI, createSeededRng } from './LuaEngineAPI';
-export { ActionRouter, evaluateCondition } from './ActionRouter';
-export { SessionManager } from './SessionManager';
-export { PersistentState } from './PersistentState';
-export { SimulationRunner, formatSimulationResult } from './SimulationRunner';
-export { ParallelSimulationRunner } from './ParallelSimulationRunner';
-export { NativeSimulationRunner, findNativeBinary, formatNativeResult } from './NativeSimulationRunner';
-export type {
-  NativeSimulationConfig,
-  NativeSimulationResult,
-  StageStats,
-  DistributionBucket,
-} from './NativeSimulationRunner';
-export type {
-  GameDefinition,
-  ActionDefinition,
-  TransitionRule,
-  SessionConfig,
-  LuaEngineConfig,
-  LuaPlayResult,
-  MaxWinConfig,
-  BuyBonusConfig,
-  BuyBonusMode,
-  AnteBetConfig,
-  PersistentStateConfig,
-  BetLevelsConfig,
-  SimulationConfig,
-  SimulationResult,
-  SimulationRawAccumulators,
-} from './types';
+// Re-export from @energy8platform/platform-core to keep the
+// `@energy8platform/game-engine/lua` sub-path import path stable.
+export * from '@energy8platform/platform-core/lua';

package/src/types.ts

@@ -31,48 +31,23 @@ export enum Orientation {
   ANY = 'any',
 }
 
-// ─── Loading Screen Config ─────────────────────────────────
-
-export interface LoadingScreenConfig {
-  /** Background color (hex number or CSS string) */
-  backgroundColor?: number | string;
-  /** Background gradient (CSS string applied to the CSS preloader) */
-  backgroundGradient?: string;
-  /** Logo texture alias (must be in 'preload' bundle) */
-  logoAsset?: string;
-  /** Logo scale (default: 1) */
-  logoScale?: number;
-  /** Show percentage text below the loader bar */
-  showPercentage?: boolean;
-  /** Custom progress text formatter */
-  progressTextFormatter?: (progress: number) => string;
-  /** Show "Tap to start" after loading (needed for mobile audio unlock) */
-  tapToStart?: boolean;
-  /** "Tap to start" label text */
-  tapToStartText?: string;
-  /** Minimum display time in ms (so the user sees the brand, even if loading is fast) */
-  minDisplayTime?: number;
-  /** CSS preloader custom HTML (shown before PixiJS is ready) */
-  cssPreloaderHTML?: string;
-}
-
-// ─── Asset Manifest ────────────────────────────────────────
-
-export interface AssetEntry {
-  alias: string;
-  src: string | string[];
-  /** Optional data to pass to the loader */
-  data?: Record<string, unknown>;
-}
-
-export interface AssetBundle {
-  name: string;
-  assets: AssetEntry[];
-}
+// ─── Loading Screen Config + Asset Manifest ───────────────
+// Both are renderer-agnostic and live in @energy8platform/platform-core.
+// Imported for local use inside GameApplicationConfig and re-exported so
+// existing game-engine consumers keep their imports.
+import type {
+  LoadingScreenConfig,
+  AssetManifest,
+  AssetBundle,
+  AssetEntry,
+} from '@energy8platform/platform-core';
 
-export interface AssetManifest {
-  bundles: AssetBundle[];
-}
+export type {
+  LoadingScreenConfig,
+  AssetManifest,
+  AssetBundle,
+  AssetEntry,
+};
 
 // ─── Audio Config ──────────────────────────────────────────
 

package/src/vite/index.ts

@@ -1,4 +1,9 @@
 import type { UserConfig, Plugin } from 'vite';
+import { devBridgePlugin, luaPlugin } from '@energy8platform/platform-core/vite';
+
+// Re-export so users importing from `@energy8platform/game-engine/vite`
+// can still grab the plugins directly without a separate platform-core import.
+export { devBridgePlugin, luaPlugin } from '@energy8platform/platform-core/vite';
 
 // ─── Types ───────────────────────────────────────────────
 
@@ -16,208 +21,20 @@ export interface GameConfig {
   vite?: UserConfig;
 }
 
-// ─── DevBridge Plugin ────────────────────────────────────
-
-/**
- * Vite plugin that auto-injects the DevBridge script into the
- * HTML during development, so the game can communicate with a
- * mock casino host without manual setup.
- */
-const VIRTUAL_ID = '/@dev-bridge-entry.js';
-
-function devBridgePlugin(configPath: string): Plugin {
-  let entrySrc = '';
-  let viteRoot = '';
-  let resolvedConfigPath = configPath;
-
-  return {
-    name: 'game-engine:dev-bridge',
-    apply: 'serve', // dev only
-    enforce: 'pre',
-
-    configResolved(config) {
-      viteRoot = config.root;
-      // Resolve relative config path against Vite root so the virtual
-      // module can import it with an absolute path.
-      if (configPath.startsWith('.')) {
-        resolvedConfigPath = config.root + '/' + configPath.replace(/^\.\//, '');
-      }
-    },
-
-    resolveId(id) {
-      if (id === VIRTUAL_ID) return id;
-    },
-
-    load(id) {
-      if (id === VIRTUAL_ID) {
-        // This goes through Vite's pipeline so bare imports are resolved
-        return `
-import { DevBridge } from '@energy8platform/game-engine/debug';
-
-try {
-  const mod = await import('${resolvedConfigPath}');
-  const config = mod.default ?? mod.config ?? mod;
-  new DevBridge(config).start();
-} catch (e) {
-  console.warn('[DevBridge] Failed to load config:', e);
-}
-
-await import('${entrySrc}');
-`;
-      }
-    },
-
-    transformIndexHtml(html) {
-      // Find the app's entry module script (skip Vite internal /@... scripts)
-      const scriptRegex = /<script\s+type="module"\s+src="((?!\/@)[^"]+)"\s*>\s*<\/script>/;
-      const match = html.match(scriptRegex);
-
-      if (!match) {
-        console.warn('[DevBridge] Could not find entry module script in index.html');
-        return html;
-      }
-
-      entrySrc = match[1];
-      if (entrySrc.startsWith('.')) {
-        entrySrc = viteRoot + '/' + entrySrc.replace(/^\.\//, '');
-      } else if (entrySrc.startsWith('/')) {
-        entrySrc = viteRoot + entrySrc;
-      }
-      return html.replace(match[0], `<script type="module" src="${VIRTUAL_ID}"></script>`);
-    },
-  };
-}
-
-// ─── Lua Plugin ─────────────────────────────────────────
-
-/**
- * Vite plugin that:
- * 1. Enables importing `.lua` files as raw strings with HMR
- * 2. Runs a LuaEngine on the Vite dev server (Node.js) via `POST /__lua-play`
- *
- * fengari runs server-side only — no browser shims needed.
- */
-function luaPlugin(configPath: string): Plugin {
-  let luaEngine: any = null;
-  let viteServer: any = null;
-
-  async function initEngine() {
-    if (!viteServer) return;
-
-    try {
-      // Invalidate cached modules so HMR picks up changes
-      const root = viteServer.config.root;
-      const fullConfigPath = configPath.startsWith('.')
-        ? root + '/' + configPath.replace(/^\.\//, '')
-        : configPath;
-
-      // Invalidate the config module and its dependencies
-      const configMod = viteServer.moduleGraph.getModuleById(fullConfigPath);
-      if (configMod) viteServer.moduleGraph.invalidateModule(configMod);
-
-      // ssrLoadModule handles TS transpilation and resolves all imports
-      const mod = await viteServer.ssrLoadModule(fullConfigPath);
-      const config = mod.default ?? mod.config ?? mod;
-
-      if (!config.luaScript || !config.gameDefinition) {
-        console.log('[LuaPlugin] No luaScript/gameDefinition in config — Lua server disabled');
-        luaEngine = null;
-        return;
-      }
-
-      // Load LuaEngine via SSR (fengari runs natively in Node.js)
-      const luaMod = await viteServer.ssrLoadModule('@energy8platform/game-engine/lua');
-      const { LuaEngine } = luaMod;
-
-      if (luaEngine) luaEngine.destroy();
-      luaEngine = new LuaEngine({
-        script: config.luaScript,
-        gameDefinition: config.gameDefinition,
-        seed: config.luaSeed,
-      });
-      console.log('[LuaPlugin] LuaEngine initialized (server-side)');
-    } catch (e: any) {
-      console.warn('[LuaPlugin] Failed to initialize LuaEngine:', e.message);
-      luaEngine = null;
-    }
-  }
-
-  return {
-    name: 'game-engine:lua',
-    apply: 'serve',
-
-    async configureServer(server) {
-      viteServer = server;
-      await initEngine();
-
-      // POST /__lua-play — execute Lua on the server
-      server.middlewares.use('/__lua-play', (req: any, res: any) => {
-        if (req.method !== 'POST') {
-          res.statusCode = 405;
-          res.end('Method Not Allowed');
-          return;
-        }
-
-        let body = '';
-        req.on('data', (chunk: string) => { body += chunk; });
-        req.on('end', () => {
-          try {
-            if (!luaEngine) {
-              res.statusCode = 503;
-              res.setHeader('Content-Type', 'application/json');
-              res.end(JSON.stringify({ error: 'LuaEngine not initialized' }));
-              return;
-            }
-
-            const params = JSON.parse(body);
-            const result = luaEngine.execute(params);
-
-            res.statusCode = 200;
-            res.setHeader('Content-Type', 'application/json');
-            res.end(JSON.stringify(result));
-          } catch (e: any) {
-            res.statusCode = 500;
-            res.setHeader('Content-Type', 'application/json');
-            res.end(JSON.stringify({ error: e.message }));
-          }
-        });
-      });
-    },
-
-    transform(code: string, id: string) {
-      if (id.endsWith('.lua')) {
-        return {
-          code: `export default ${JSON.stringify(code)};`,
-          map: null,
-        };
-      }
-    },
-
-    async handleHotUpdate({ file, server }: { file: string; server: any }) {
-      if (file.endsWith('.lua') || file.includes('dev.config')) {
-        console.log('[LuaPlugin] Reloading LuaEngine...');
-
-        // Invalidate all SSR modules so ssrLoadModule picks up fresh code
-        server.moduleGraph.invalidateAll();
-
-        await initEngine();
-        server.ws.send({ type: 'full-reload' });
-        return [];
-      }
-    },
-  };
-}
-
 // ─── defineGameConfig ────────────────────────────────────
 
 /**
- * Define a Vite configuration tailored for Energy8 casino games.
+ * Define a Vite configuration tailored for Energy8 casino games on
+ * @energy8platform/game-engine (PixiJS).
  *
  * Merges sensible defaults for iGaming projects:
  * - Build target: ESNext
  * - Asset inlining threshold: 8KB
- * - Source maps for dev, none for prod
- * - Optional DevBridge auto-injection in dev mode
+ * - PixiJS-specific dedupe / chunk splitting / prebundle hints
+ * - Optional DevBridge auto-injection in dev mode (with Lua engine)
+ *
+ * For Phaser/Three/custom engines, import the bare plugins directly
+ * from `@energy8platform/platform-core/vite` and write your own config.
  *
  * @example
  * ```ts
@@ -242,7 +59,7 @@ export function defineGameConfig(config: GameConfig = {}): UserConfig {
   const userVite = config.vite ?? {};
 
   return {
-    base: config.base ?? '/',
+    base: config.base ?? './',
 
     plugins: [
       ...plugins,

package/bin/simulate.ts

@@ -1,139 +0,0 @@
-#!/usr/bin/env npx tsx
-import { SimulationRunner, formatSimulationResult } from '../src/lua/SimulationRunner';
-import { ParallelSimulationRunner } from '../src/lua/ParallelSimulationRunner';
-import { NativeSimulationRunner, findNativeBinary, formatNativeResult } from '../src/lua/NativeSimulationRunner';
-import { cpus } from 'os';
-import { resolve, dirname } from 'path';
-import { fileURLToPath } from 'url';
-
-// ─── Argument Parsing ───────────────────────────────────
-
-function parseArgs(argv: string[]): Record<string, string> {
-  const args: Record<string, string> = {};
-  for (let i = 2; i < argv.length; i++) {
-    const arg = argv[i];
-    if (arg.startsWith('--')) {
-      const key = arg.slice(2);
-      // Boolean flags (no value)
-      if (key === 'native' || key === 'js') {
-        args[key] = 'true';
-      } else if (i + 1 < argv.length) {
-        args[key] = argv[++i];
-      }
-    }
-  }
-  return args;
-}
-
-async function main() {
-  const args = parseArgs(process.argv);
-
-  const configPath = resolve(process.cwd(), args.config ?? './dev.config.ts');
-  const iterations = parseInt(args.iterations ?? '1000000', 10);
-  const bet = parseFloat(args.bet ?? '1');
-  const seed = args.seed ? parseInt(args.seed, 10) : undefined;
-  const action = args.action ?? 'spin';
-  const params = args.params ? JSON.parse(args.params) : undefined;
-  const workers = args.workers ? parseInt(args.workers, 10) : cpus().length;
-  const useNative = args.native === 'true';
-  const useJs = args.js === 'true';
-
-  // Load dev config
-  let config: any;
-  try {
-    const mod = await import(configPath);
-    config = mod.default ?? mod.config ?? mod;
-  } catch (e: any) {
-    console.error(`Failed to load config from ${configPath}:`);
-    console.error(e.message);
-    process.exit(1);
-  }
-
-  if (!config.luaScript) {
-    console.error('Config must contain `luaScript` (Lua source code string).');
-    console.error('Make sure your dev.config.ts exports luaScript and gameDefinition.');
-    process.exit(1);
-  }
-
-  if (!config.gameDefinition) {
-    console.error('Config must contain `gameDefinition` (GameDefinition object).');
-    process.exit(1);
-  }
-
-  const gameId = config.gameDefinition.id ?? 'unknown';
-
-  // ─── Native binary detection ────────────────────────────
-  // Search in config dir first, then in the game-engine package root
-  const engineRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..');
-  const binaryPath = args.binary ?? (useJs ? null : (findNativeBinary(dirname(configPath)) ?? findNativeBinary(engineRoot)));
-
-  if (useNative && !binaryPath) {
-    console.error('Native simulation binary not found.');
-    console.error('Use --binary <path> or set SIMULATE_BINARY environment variable.');
-    process.exit(1);
-  }
-
-  const onProgress = (completed: number, total: number) => {
-    const pct = Math.round((completed / total) * 100);
-    console.log(`Progress: ${completed.toLocaleString()}/${total.toLocaleString()} (${pct}%)`);
-  };
-
-  // ─── Native binary path ─────────────────────────────────
-  if (binaryPath) {
-    console.log(`Using native binary: ${binaryPath}`);
-    console.log(`Starting simulation for ${gameId} (${iterations.toLocaleString()} iterations, action: ${action})...`);
-
-    const runner = new NativeSimulationRunner({
-      binaryPath,
-      script: config.luaScript,
-      gameDefinition: config.gameDefinition,
-      iterations,
-      bet,
-      action,
-      params,
-    });
-    const result = await runner.run();
-    console.log(formatNativeResult(result));
-    return;
-  }
-
-  // ─── JS simulation path ─────────────────────────────────
-  const useParallel = workers > 1;
-  console.log(`Starting simulation for ${gameId} (${iterations.toLocaleString()} iterations, action: ${action}, workers: ${useParallel ? workers : 1})...`);
-
-  let result;
-
-  if (useParallel) {
-    const runner = new ParallelSimulationRunner({
-      script: config.luaScript,
-      gameDefinition: config.gameDefinition,
-      iterations,
-      bet,
-      seed,
-      action,
-      params,
-      workerCount: workers,
-      onProgress,
-    });
-    result = await runner.run();
-  } else {
-    const runner = new SimulationRunner({
-      script: config.luaScript,
-      gameDefinition: config.gameDefinition,
-      iterations,
-      bet,
-      seed,
-      action,
-      params,
-      onProgress,
-    });
-    result = runner.run();
-  }
-
-  console.log(formatSimulationResult(result));
-}
-
-main().catch((err) => {
-  console.error(err);
-  process.exit(1);
-});

package/scripts/install-simulate.mjs

@@ -1,101 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Postinstall script: downloads the native simulation binary for the current
- * platform from GitHub Releases. Falls back silently — the JS simulation
- * will be used if the binary is unavailable.
- */
-
-import { createWriteStream, chmodSync, existsSync, mkdirSync } from 'fs';
-import { join, dirname } from 'path';
-import { fileURLToPath } from 'url';
-import { get } from 'https';
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const BIN_DIR = join(__dirname, '..', 'bin');
-
-// ─── Config ─────────────────────────────────────────────
-
-const REPO = 'energy8platform/game-engine';
-// Binary version — update this when new Go binaries are built and uploaded to GitHub Releases.
-// The binary is backwards-compatible: it runs any Lua script, so it doesn't need to match
-// the engine version exactly. Only bump when the Go simulate CLI itself changes.
-const BINARY_VERSION = '0.13.0';
-
-const PLATFORM_MAP = {
-  'darwin-arm64': 'simulate-darwin-arm64',
-  'darwin-x64': 'simulate-darwin-amd64',
-  'linux-x64': 'simulate-linux-amd64',
-  'linux-arm64': 'simulate-linux-arm64',
-  'win32-x64': 'simulate-windows-amd64.exe',
-};
-
-// ─── Main ───────────────────────────────────────────────
-
-async function main() {
-  const key = `${process.platform}-${process.arch}`;
-  const binaryName = PLATFORM_MAP[key];
-
-  if (!binaryName) {
-    console.log(`[simulate] No native binary available for ${key}, will use JS simulation.`);
-    return;
-  }
-
-  const dest = join(BIN_DIR, binaryName);
-
-  // Skip if already downloaded
-  if (existsSync(dest)) {
-    return;
-  }
-
-  const tag = `v${BINARY_VERSION}`;
-
-  const url = `https://github.com/${REPO}/releases/download/${tag}/${binaryName}`;
-
-  console.log(`[simulate] Downloading native binary for ${key}...`);
-
-  try {
-    if (!existsSync(BIN_DIR)) {
-      mkdirSync(BIN_DIR, { recursive: true });
-    }
-    await download(url, dest);
-    chmodSync(dest, 0o755);
-    console.log(`[simulate] Installed ${binaryName}`);
-  } catch (err) {
-    // Non-fatal — JS simulation is the fallback
-    console.log(`[simulate] Could not download native binary: ${err.message}`);
-    console.log(`[simulate] Will use JS simulation instead.`);
-  }
-}
-
-// ─── Download with redirect following ───────────────────
-
-function download(url, dest, redirects = 5) {
-  return new Promise((resolve, reject) => {
-    if (redirects <= 0) {
-      return reject(new Error('Too many redirects'));
-    }
-
-    get(url, { headers: { 'User-Agent': 'game-engine-postinstall' } }, (res) => {
-      // Follow redirects (GitHub sends 302 to S3)
-      if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
-        res.resume();
-        return download(res.headers.location, dest, redirects - 1).then(resolve, reject);
-      }
-
-      if (res.statusCode !== 200) {
-        res.resume();
-        return reject(new Error(`HTTP ${res.statusCode} for ${url}`));
-      }
-
-      const file = createWriteStream(dest);
-      res.pipe(file);
-      file.on('finish', () => file.close(resolve));
-      file.on('error', reject);
-    }).on('error', reject);
-  });
-}
-
-main().catch(() => {
-  // Never fail the install
-});