@energy8platform/game-engine 0.17.0 → 0.19.0

package/src/slot/overlay/CountUpDisplay.ts

@@ -0,0 +1,56 @@
+import { Container, Text, type TextStyle } from 'pixi.js';
+import { Tween, Easing } from '../../animation';
+
+export interface CountUpConfig { format: (v: number) => string; style?: Partial<TextStyle>; }
+
+/** PURE eased interpolation 0→target over duration (ms). Clamped to [0, target]. */
+export function valueAt(elapsed: number, target: number, duration: number): number {
+  if (duration <= 0 || elapsed >= duration) return target;
+  if (elapsed <= 0) return 0;
+  const p = elapsed / duration;
+  const eased = 1 - Math.pow(1 - p, 3); // easeOutCubic
+  return target * eased;
+}
+
+export class CountUpDisplay extends Container {
+  readonly __uiComponent = true as const;
+  private _text: Text;
+  private _format: (v: number) => string;
+  private _value = 0;
+
+  constructor(config: CountUpConfig) {
+    super();
+    this._format = config.format;
+    this._text = new Text({
+      text: this._format(0),
+      style: { fontFamily: 'sans-serif', fontSize: 48, fill: 0xffffff, fontWeight: '800', ...config.style },
+    });
+    this._text.anchor.set(0.5);
+    this.addChild(this._text);
+  }
+
+  get text(): string { return this._text.text; }
+
+  setValue(v: number): void {
+    this._value = v;
+    this._text.text = this._format(v);
+  }
+
+  /** Swap the value formatter and immediately re-render the current value. */
+  setFormat(format: (v: number) => string): void {
+    this._format = format;
+    this._text.text = this._format(this._value);
+  }
+
+  /** Animate the value to target over duration; fires onTier on each tier-index increase. */
+  async countTo(target: number, duration: number, onTier?: (idx: number) => void): Promise<void> {
+    const holder = { v: 0 };
+    void onTier; // tier tracking is external — onTier is a forward-compat hook
+    await Tween.to(holder, { v: target }, duration, Easing.easeOutCubic, () => {
+      this.setValue(holder.v);
+    });
+    this.setValue(target);
+  }
+
+  skip(): void { Tween.killTweensOf(this); }
+}

package/src/slot/overlay/tiers.ts

@@ -0,0 +1,29 @@
+import type { Texture } from 'pixi.js';
+
+export interface WinTier {
+  id: string;
+  minMultiplier: number;
+  title: string;
+  accentColor: number;
+  bannerTexture?: Texture;
+}
+
+/** Highest tier whose minMultiplier <= win/bet, or null if below the lowest. */
+export function pickTier(tiers: WinTier[], win: number, bet: number): WinTier | null {
+  if (bet <= 0) return null;
+  const mult = win / bet;
+  let chosen: WinTier | null = null;
+  for (const t of tiers) {
+    if (mult >= t.minMultiplier && (!chosen || t.minMultiplier >= chosen.minMultiplier)) chosen = t;
+  }
+  return chosen;
+}
+
+/** Index into `tiers` for the running value (or -1 below the lowest tier). */
+export function tierIndexAtValue(tiers: WinTier[], runningValue: number, bet: number): number {
+  if (bet <= 0) return -1;
+  const mult = runningValue / bet;
+  let idx = -1;
+  for (let i = 0; i < tiers.length; i++) if (mult >= tiers[i].minMultiplier) idx = i;
+  return idx;
+}

package/src/types.ts

@@ -111,6 +111,9 @@ export interface GameApplicationConfig {
 
   /** Enable debug overlay (FPS, draw calls) */
   debug?: boolean;
+
+  /** When set, GameApplication mounts the branded game shell after the SDK handshake. */
+  shell?: import('@energy8platform/platform-core/shell').ShellConfig | false;
 }
 
 // ─── Scene Types ───────────────────────────────────────────

package/src/viewport/ViewportManager.ts

@@ -1,4 +1,4 @@
-import type { Application } from 'pixi.js';
+import type { Application, Container } from 'pixi.js';
 import { EventEmitter } from '../core/EventEmitter';
 import { ScaleMode, Orientation } from '../types';
 
@@ -45,6 +45,7 @@ export class ViewportManager extends EventEmitter<ViewportEvents> {
   private _app: Application;
   private _container: HTMLElement;
   private _config: ViewportConfig;
+  private _target: Container;
   private _resizeObserver: ResizeObserver | null = null;
   private _currentOrientation: Orientation = Orientation.LANDSCAPE;
   private _currentWidth = 0;
@@ -53,11 +54,20 @@ export class ViewportManager extends EventEmitter<ViewportEvents> {
   private _destroyed = false;
   private _resizeTimeout: number | null = null;
 
-  constructor(app: Application, container: HTMLElement, config: ViewportConfig) {
+  constructor(
+    app: Application,
+    container: HTMLElement,
+    config: ViewportConfig,
+    target?: Container,
+  ) {
     super();
     this._app = app;
     this._container = container;
     this._config = config;
+    // The container this manager scales/offsets. Defaults to app.stage for backward
+    // compatibility; the engine passes a dedicated scaled world root so app.stage stays
+    // identity (screen space) for unscaled UI layers.
+    this._target = target ?? app.stage;
 
     this.setupObserver();
   }
@@ -164,18 +174,18 @@ export class ViewportManager extends EventEmitter<ViewportEvents> {
       ? Math.min(containerWidth / designWidth, containerHeight / designHeight)
       : scale;
 
-    this._app.stage.scale.set(stageScale);
+    this._target.scale.set(stageScale);
 
     // Center the stage for FIT mode
     if (scaleMode === ScaleMode.FIT) {
-      this._app.stage.x = Math.round((containerWidth - designWidth * stageScale) / 2);
-      this._app.stage.y = Math.round((containerHeight - designHeight * stageScale) / 2);
+      this._target.x = Math.round((containerWidth - designWidth * stageScale) / 2);
+      this._target.y = Math.round((containerHeight - designHeight * stageScale) / 2);
     } else if (scaleMode === ScaleMode.FILL) {
-      this._app.stage.x = Math.round((containerWidth - gameWidth * stageScale) / 2);
-      this._app.stage.y = Math.round((containerHeight - gameHeight * stageScale) / 2);
+      this._target.x = Math.round((containerWidth - gameWidth * stageScale) / 2);
+      this._target.y = Math.round((containerHeight - gameHeight * stageScale) / 2);
     } else {
-      this._app.stage.x = 0;
-      this._app.stage.y = 0;
+      this._target.x = 0;
+      this._target.y = 0;
     }
 
     this._currentWidth = gameWidth;