@energy8platform/game-engine 0.20.0 → 0.22.0

package/src/slot/features/types.ts

@@ -0,0 +1,136 @@
+// packages/game-engine/src/slot/features/types.ts
+//
+// Uniform interface for special reel feature mechanics. Each feature is a presentation module:
+// given the current board + its config (and optional per-spin data), it plays an animation that
+// visualises the mechanic. `demo()` is the self-contained showcase the reel-lab playground triggers.
+
+import { Container, Graphics, Text } from 'pixi.js';
+import { Tween } from '../../animation';
+import { easingByName } from '../anim/easing-map';
+import type { ReelGrid } from '../grid/ReelGrid';
+import type { SymbolCell, CellData } from '../grid/SymbolCell';
+import type { SymbolResolver } from '../grid/SymbolView';
+import type { FeatureKey, ReelSystemConfig } from '../config/ReelSystemConfig';
+
+export interface FeatureContext {
+  grid: ReelGrid;
+  resolve: SymbolResolver;
+  cfg: ReelSystemConfig;
+  /** Overlay layer above the grid for rings/labels/sprites. */
+  fx: Container;
+  /** Mutable view of the current board (featureN may rewrite it). */
+  board: CellData[][];
+  /** Whether the current spin is a free-spin (gates onlyInFreeSpins features). */
+  freeSpins?: boolean;
+  /** Emit a human-readable note for the playground log. */
+  log?: (msg: string) => void;
+}
+
+export interface ReelFeature {
+  /** Unique id. Built-ins use a `FeatureKey`; custom features may use any string. */
+  readonly key: FeatureKey | string;
+  readonly label: string;
+  /** Whether this feature is active for the given config. Custom features can just return `true`. */
+  enabled(cfg: ReelSystemConfig): boolean;
+  /** Run the feature presentation on the current board. */
+  demo(ctx: FeatureContext): Promise<void>;
+}
+
+// ── shared animation helpers ────────────────────────────────────────────────
+
+/** Center position of a cell, in fx-layer coordinates (fx shares the grid's transform). */
+export function cellCenter(grid: ReelGrid, col: number, row: number): { x: number; y: number } {
+  return grid.cellPosition(col, row);
+}
+
+export function rowStepOf(grid: ReelGrid): number {
+  return grid.cellPosition(0, 1).y - grid.cellPosition(0, 0).y;
+}
+
+/** A glowing ring drawn around a cell. Returns a disposer. */
+export function glowRing(
+  fx: Container,
+  grid: ReelGrid,
+  col: number,
+  row: number,
+  color: number,
+): () => void {
+  if (fx.destroyed) return () => {};
+  const { x, y } = cellCenter(grid, col, row);
+  const s = grid.cellSize;
+  const g = new Graphics()
+    .roundRect(x - s / 2, y - s / 2, s, s, 10)
+    .stroke({ color, width: 3, alpha: 0.9 });
+  fx.addChild(g);
+  return () => g.destroy();
+}
+
+/** Pulse a cell up and back. */
+export async function pulseCell(cell: SymbolCell, scale = 1.15, ms = 220): Promise<void> {
+  if (cell.destroyed) return;
+  await Tween.to(
+    cell,
+    { 'scale.x': scale, 'scale.y': scale },
+    ms * 0.5,
+    easingByName('easeOutBack'),
+  );
+  if (cell.destroyed) return;
+  await Tween.to(cell, { 'scale.x': 1, 'scale.y': 1 }, ms * 0.5, easingByName('easeOutQuad'));
+}
+
+/** Floating label that rises and fades. */
+export async function floatLabel(
+  fx: Container,
+  x: number,
+  y: number,
+  text: string,
+  color = 0xffd24a,
+  ms = 700,
+): Promise<void> {
+  if (fx.destroyed) return;
+  const t = new Text({ text, style: { fontSize: 26, fill: color, fontWeight: '800' } });
+  t.anchor.set(0.5);
+  t.position.set(x, y);
+  t.scale.set(0.5);
+  fx.addChild(t);
+  await Tween.to(t, { 'scale.x': 1, 'scale.y': 1 }, ms * 0.25, easingByName('easeOutBack'));
+  await Tween.to(t, { y: y - 50, alpha: 0 }, ms * 0.75, easingByName('easeOutQuad'));
+  t.destroy();
+}
+
+/** Replace a cell's symbol with a quick morph (shrink → swap → pop). */
+export async function morphSymbol(cell: SymbolCell, data: CellData, ms = 280): Promise<void> {
+  if (cell.destroyed) return;
+  await Tween.to(cell, { 'scale.x': 0.1, 'scale.y': 0.1 }, ms * 0.4, easingByName('easeInBack'));
+  if (cell.destroyed) return;
+  cell.setData(data);
+  cell.scale.set(0.1);
+  await Tween.to(cell, { 'scale.x': 1, 'scale.y': 1 }, ms * 0.6, easingByName('easeOutBack'));
+}
+
+/** Drop a cell in from above its home position. */
+export async function dropCell(
+  grid: ReelGrid,
+  cell: SymbolCell,
+  col: number,
+  row: number,
+  ms = 280,
+): Promise<void> {
+  if (cell.destroyed) return;
+  const home = grid.cellPosition(col, row);
+  cell.position.set(home.x, home.y - rowStepOf(grid) * (row + 2));
+  cell.alpha = 1;
+  cell.scale.set(1);
+  await Tween.to(cell, { 'position.y': home.y }, ms, easingByName('easeOutBounce'));
+}
+
+export function pickFromBoard(
+  board: CellData[][],
+  predicate: (c: CellData, col: number, row: number) => boolean,
+): { col: number; row: number }[] {
+  const out: { col: number; row: number }[] = [];
+  for (let c = 0; c < board.length; c++)
+    for (let r = 0; r < (board[c]?.length ?? 0); r++)
+      if (board[c][r] && predicate(board[c][r], c, r)) out.push({ col: c, row: r });
+  return out;
+}

package/src/slot/features/wilds.ts

@@ -0,0 +1,151 @@
+// packages/game-engine/src/slot/features/wilds.ts
+import { Tween } from '../../animation';
+import { easingByName } from '../anim/easing-map';
+import {
+  type FeatureContext,
+  type ReelFeature,
+  cellCenter,
+  dropCell,
+  floatLabel,
+  glowRing,
+  morphSymbol,
+  pickFromBoard,
+  pulseCell,
+} from './types';
+
+function reelsOf(cfg: number[], cols: number): number[] {
+  return cfg.length
+    ? cfg.filter((r) => r >= 0 && r < cols)
+    : Array.from({ length: cols }, (_, i) => i);
+}
+const randInt = (a: number, b: number, seed: number) =>
+  Math.min(b, a + Math.floor(((Math.sin(seed * 99.13) + 1) / 2) * (b - a + 1)));
+
+/** Expanding wild: a landed wild grows to fill its whole reel. */
+export const ExpandingWild: ReelFeature = {
+  key: 'expandingWild',
+  label: 'Expanding wild',
+  enabled: (c) => c.features.expandingWild.enabled,
+  async demo(ctx: FeatureContext) {
+    const f = ctx.cfg.features.expandingWild;
+    if (f.onlyInFreeSpins && !ctx.freeSpins) {
+      ctx.log?.('Expanding wild: free-spins only');
+      return;
+    }
+    const cols = ctx.grid.cols;
+    const eligible = reelsOf(f.reels, cols);
+    const reel = eligible[randInt(0, eligible.length - 1, cols)];
+    const rows = ctx.grid.rowsOf(reel);
+    ctx.log?.(`Expanding wild on reel ${reel}`);
+    const disposers: (() => void)[] = [];
+    for (let r = 0; r < (f.toFullReel ? rows : Math.min(2, rows)); r++) {
+      const cell = ctx.grid.getCell(reel, r);
+      await morphSymbol(cell, { symbol: f.symbol }, f.ms / Math.max(1, rows));
+      disposers.push(glowRing(ctx.fx, ctx.grid, reel, r, 0xffd700));
+      if (ctx.board[reel]) ctx.board[reel][r] = { symbol: f.symbol };
+    }
+    await Tween.delay(500);
+    disposers.forEach((d) => d());
+  },
+};
+
+/** Sticky symbols: chosen symbols lock in place for N spins. */
+export const StickySymbols: ReelFeature = {
+  key: 'sticky',
+  label: 'Sticky symbols',
+  enabled: (c) => c.features.sticky.enabled,
+  async demo(ctx: FeatureContext) {
+    const f = ctx.cfg.features.sticky;
+    const targets = pickFromBoard(ctx.board, (c) => !!c.symbol).slice(0, 3);
+    const picks = targets.filter((_, i) => i % 2 === 0);
+    ctx.log?.(`Sticky: locking ${picks.length} cell(s) for ${f.durationSpins || 'feature'} spins`);
+    await Promise.all(
+      picks.map(async (p, i) => {
+        const cell = ctx.grid.getCell(p.col, p.row);
+        cell.setData({ symbol: f.symbols[0] ?? 'wild', sticky: { remaining: f.durationSpins } });
+        glowRing(ctx.fx, ctx.grid, p.col, p.row, f.ringColor);
+        await pulseCell(cell, 1.2, 260);
+        const { x, y } = cellCenter(ctx.grid, p.col, p.row);
+        await floatLabel(
+          ctx.fx,
+          x,
+          y - ctx.grid.cellSize / 2,
+          f.durationSpins ? `STICKY ${f.durationSpins}` : 'STICKY',
+          f.ringColor,
+          600 + i * 50,
+        );
+      }),
+    );
+  },
+};
+
+/** Walking wild: a wild shifts one reel each spin until it leaves the grid. */
+export const WalkingWild: ReelFeature = {
+  key: 'walkingWild',
+  label: 'Walking wild',
+  enabled: (c) => c.features.walkingWild.enabled,
+  async demo(ctx: FeatureContext) {
+    const f = ctx.cfg.features.walkingWild;
+    const cols = ctx.grid.cols;
+    const dir = f.direction === 'left' ? -1 : 1;
+    let col = dir === 1 ? 0 : cols - 1;
+    // clamp the row into each reel's own height (Megaways reels differ in length)
+    const rowIn = (c: number) =>
+      Math.min(Math.floor(ctx.grid.rowsOf(col) / 2), ctx.grid.rowsOf(c) - 1);
+    let row = rowIn(col);
+    await morphSymbol(ctx.grid.getCell(col, row), { symbol: f.symbol }, 240);
+    ctx.log?.(`Walking wild marching ${f.direction}`);
+    // walk across the grid
+    for (let step = 0; step < cols; step++) {
+      const next = col + dir * f.stepPerSpin;
+      if (next < 0 || next >= cols) break;
+      const nextRow = rowIn(next);
+      const from = cellCenter(ctx.grid, col, row);
+      const to = cellCenter(ctx.grid, next, nextRow);
+      ctx.grid.getCell(col, row).setData({ symbol: null });
+      const ghost = ctx.grid.getCell(next, nextRow);
+      ghost.setData({ symbol: f.symbol });
+      ghost.position.set(from.x, from.y);
+      const ring = glowRing(ctx.fx, ctx.grid, next, nextRow, 0xff66cc);
+      await Tween.to(
+        ghost,
+        { 'position.x': to.x, 'position.y': to.y },
+        260,
+        easingByName('easeInOutQuad'),
+      );
+      ring();
+      col = next;
+      row = nextRow;
+    }
+  },
+};
+
+/** Random wild injection: a few wilds drop onto random positions. */
+export const RandomWild: ReelFeature = {
+  key: 'randomWild',
+  label: 'Random wild injection',
+  enabled: (c) => c.features.randomWild.enabled,
+  async demo(ctx: FeatureContext) {
+    const f = ctx.cfg.features.randomWild;
+    const n = Array.isArray(f.count) ? randInt(f.count[0], f.count[1], ctx.grid.cols + 7) : f.count;
+    const spots = pickFromBoard(ctx.board, () => true);
+    const chosen: { col: number; row: number }[] = [];
+    for (let i = 0; i < n && spots.length; i++)
+      chosen.push(spots.splice(randInt(0, spots.length - 1, i + 3), 1)[0]);
+    ctx.log?.(
+      `Injecting ${chosen.length} wild(s)${f.sticky ? ' (sticky)' : ''}${f.multiplier > 1 ? ` ×${f.multiplier}` : ''}`,
+    );
+    await Promise.all(
+      chosen.map(async (p) => {
+        const cell = ctx.grid.getCell(p.col, p.row);
+        cell.setData({
+          symbol: 'wild',
+          multiplier: f.multiplier > 1 ? f.multiplier : undefined,
+          sticky: f.sticky ? { remaining: 0 } : undefined,
+        });
+        await dropCell(ctx.grid, cell, p.col, p.row, 300);
+        if (f.sticky) glowRing(ctx.fx, ctx.grid, p.col, p.row, 0xec4899);
+      }),
+    );
+  },
+};

package/src/slot/grid/ReelGrid.ts

@@ -2,88 +2,157 @@ import { Container, Graphics, Sprite, type Texture } from 'pixi.js';
 import { SymbolCell, type CellData, type CellFrameStyle } from './SymbolCell';
 import type { SymbolResolver } from './SymbolView';
 
-export interface DecorationConfig { texture?: Texture; padding?: number; }
+export interface DecorationConfig {
+  texture?: Texture;
+  padding?: number;
+}
 export interface ReelGridConfig {
-  cols: number; rows: number; cellSize: number; gap?: number;
-  resolve: SymbolResolver; frameStyle?: CellFrameStyle;
+  cols: number;
+  /** Uniform row count. Ignored per-reel when `rowsPerReel` is provided. */
+  rows: number;
+  /** Per-reel row counts for Megaways / variable-height reels. Length must equal `cols`. */
+  rowsPerReel?: number[];
+  cellSize: number;
+  gap?: number;
+  resolve: SymbolResolver;
+  frameStyle?: CellFrameStyle;
   decoration?: DecorationConfig;
   mask?: boolean;
 }
 
+/**
+ * A grid of `SymbolCell`s. Supports uniform grids and variable-height reels (Megaways):
+ * when `rowsPerReel` is set each reel is vertically centred inside the tallest reel's envelope.
+ */
 export class ReelGrid extends Container {
   readonly __uiComponent = true as const;
 
   private _cols: number;
-  private _rows: number;
+  private _rowsPerReel: number[];
+  private _maxRows: number;
   private _cellSize: number;
   private _gap: number;
   private _cells: SymbolCell[][] = [];
   private _cellLayer = new Container();
+  private _resolve: SymbolResolver;
+  private _frameStyle?: CellFrameStyle;
+  private _mask: Graphics | null = null;
 
   constructor(config: ReelGridConfig) {
     super();
     this._cols = config.cols;
-    this._rows = config.rows;
+    this._rowsPerReel =
+      config.rowsPerReel && config.rowsPerReel.length === config.cols
+        ? config.rowsPerReel.slice()
+        : Array.from({ length: config.cols }, () => config.rows);
+    this._maxRows = Math.max(1, ...this._rowsPerReel);
     this._cellSize = config.cellSize;
     this._gap = config.gap ?? 0;
+    this._resolve = config.resolve;
+    this._frameStyle = config.frameStyle;
 
     if (config.decoration) {
       const pad = config.decoration.padding ?? 0;
       const w = this._cols * (this._cellSize + this._gap) - this._gap + pad * 2;
-      const h = this._rows * (this._cellSize + this._gap) - this._gap + pad * 2;
+      const h = this._maxRows * (this._cellSize + this._gap) - this._gap + pad * 2;
       if (config.decoration.texture) {
         const deco = new Sprite(config.decoration.texture);
-        deco.width = w; deco.height = h; deco.position.set(-pad - this._cellSize / 2, -pad - this._cellSize / 2);
+        deco.width = w;
+        deco.height = h;
+        deco.position.set(-pad - this._cellSize / 2, -pad - this._cellSize / 2);
         this.addChild(deco);
       }
     }
 
     this.addChild(this._cellLayer);
+    this._buildCells();
+
+    if (config.mask) this._applyMask();
+  }
 
+  private _buildCells(): void {
     for (let c = 0; c < this._cols; c++) {
       this._cells[c] = [];
-      for (let r = 0; r < this._rows; r++) {
-        const cell = new SymbolCell({ size: this._cellSize, resolve: config.resolve, frameStyle: config.frameStyle });
+      for (let r = 0; r < this._rowsPerReel[c]; r++) {
+        const cell = new SymbolCell({
+          size: this._cellSize,
+          resolve: this._resolve,
+          frameStyle: this._frameStyle,
+        });
         const { x, y } = this.cellPosition(c, r);
         cell.position.set(x, y);
         this._cellLayer.addChild(cell);
         this._cells[c][r] = cell;
       }
     }
+  }
 
-    if (config.mask) {
-      const w = this._cols * (this._cellSize + this._gap) - this._gap;
-      const h = this._rows * (this._cellSize + this._gap) - this._gap;
-      const m = new Graphics()
-        .rect(-this._cellSize / 2, -this._cellSize / 2, w, h)
-        .fill(0xffffff);
-      this._cellLayer.mask = m;
-      this.addChild(m);
-    }
+  private _applyMask(): void {
+    const w = this._cols * (this._cellSize + this._gap) - this._gap;
+    const h = this._maxRows * (this._cellSize + this._gap) - this._gap;
+    const m = new Graphics().rect(-this._cellSize / 2, -this._cellSize / 2, w, h).fill(0xffffff);
+    this._cellLayer.mask = m;
+    this.addChild(m);
+    this._mask = m;
   }
 
-  get cols(): number { return this._cols; }
-  get rows(): number { return this._rows; }
+  get cols(): number {
+    return this._cols;
+  }
+  /** Tallest reel's row count (the grid's visual height in rows). */
+  get rows(): number {
+    return this._maxRows;
+  }
+  get cellSize(): number {
+    return this._cellSize;
+  }
+  rowsOf(col: number): number {
+    return this._rowsPerReel[col] ?? 0;
+  }
+  get rowsPerReel(): number[] {
+    return this._rowsPerReel.slice();
+  }
 
+  /** Cell centre position. Variable-height reels are centred in the max-rows envelope. */
   cellPosition(col: number, row: number): { x: number; y: number } {
     const step = this._cellSize + this._gap;
-    return { x: col * step, y: row * step };
+    const reelRows = this._rowsPerReel[col] ?? this._maxRows;
+    const yOffset = ((this._maxRows - reelRows) / 2) * step;
+    return { x: col * step, y: yOffset + row * step };
   }
 
-  getCell(col: number, row: number): SymbolCell { return this._cells[col][row]; }
+  getCell(col: number, row: number): SymbolCell {
+    return this._cells[col][row];
+  }
 
   setGrid(cells: CellData[][]): void {
     for (let c = 0; c < this._cols; c++) {
-      for (let r = 0; r < this._rows; r++) {
+      for (let r = 0; r < this._rowsPerReel[c]; r++) {
         this._cells[c]?.[r]?.setData(cells[c]?.[r] ?? { symbol: null });
       }
     }
   }
 
+  /** Rebuild the grid with new per-reel row counts (Megaways re-roll / dynamic rows). */
+  reshape(rowsPerReel: number[]): void {
+    if (rowsPerReel.length !== this._cols) return;
+    this._cellLayer.removeChildren().forEach((c) => c.destroy());
+    this._cells = [];
+    this._rowsPerReel = rowsPerReel.slice();
+    this._maxRows = Math.max(1, ...this._rowsPerReel);
+    this._buildCells();
+    if (this._mask) {
+      this._mask.destroy();
+      this.removeChild(this._mask);
+      this._mask = null;
+      this._applyMask();
+    }
+  }
+
   resize(cellSize: number): void {
     this._cellSize = cellSize;
     for (let c = 0; c < this._cols; c++) {
-      for (let r = 0; r < this._rows; r++) {
+      for (let r = 0; r < this._rowsPerReel[c]; r++) {
         const { x, y } = this.cellPosition(c, r);
         this._cells[c][r].position.set(x, y);
       }

package/src/slot/grid/SymbolCell.ts

@@ -15,8 +15,16 @@ export interface CellData {
   bonus?: number;
   sticky?: { remaining: number };
 }
-export interface CellState { winning?: boolean; removed?: boolean; fresh?: boolean; }
-export interface SymbolCellConfig { size: number; resolve: SymbolResolver; frameStyle?: CellFrameStyle; }
+export interface CellState {
+  winning?: boolean;
+  removed?: boolean;
+  fresh?: boolean;
+}
+export interface SymbolCellConfig {
+  size: number;
+  resolve: SymbolResolver;
+  frameStyle?: CellFrameStyle;
+}
 
 const DEFAULT_STYLE: Required<CellFrameStyle> = {
   radius: 8,
@@ -51,14 +59,23 @@ export class SymbolCell extends Container {
     this._drawFrame('idle');
   }
 
-  get view(): SymbolView | null { return this._view; }
+  get view(): SymbolView | null {
+    return this._view;
+  }
 
   setData(data: CellData): void {
+    if (this.destroyed) return; // a killed-tween chain may resume after the cell is gone
     // symbol view
     if (data.symbol == null) {
-      if (this._view) { this._view.destroy(); this._view = null; }
+      if (this._view) {
+        this._view.destroy();
+        this._view = null;
+      }
     } else {
-      if (this._view) { this._view.destroy(); this._view = null; }
+      if (this._view) {
+        this._view.destroy();
+        this._view = null;
+      }
       const v = this._resolve(data.symbol);
       if (v) {
         v.resize?.(this._size);
@@ -72,7 +89,14 @@ export class SymbolCell extends Container {
   }
 
   setState(state: CellState): void {
-    const key = state.winning ? 'winning' : state.removed ? 'removed' : state.fresh ? 'fresh' : 'idle';
+    if (this.destroyed) return;
+    const key = state.winning
+      ? 'winning'
+      : state.removed
+        ? 'removed'
+        : state.fresh
+          ? 'fresh'
+          : 'idle';
     this.frameStyleKey = key;
     this._drawFrame(key);
   }
@@ -81,17 +105,21 @@ export class SymbolCell extends Container {
     if (this._view?.playWin) return this._view.playWin();
     // default: scale pop
     const target = this._view ?? this;
-    return Tween.to(target, { 'scale.x': 1.15, 'scale.y': 1.15 }, 160, Easing.easeOutBack)
-      .then(() => Tween.to(target, { 'scale.x': 1, 'scale.y': 1 }, 140, Easing.easeOutQuad));
+    return Tween.to(target, { 'scale.x': 1.15, 'scale.y': 1.15 }, 160, Easing.easeOutBack).then(
+      () => Tween.to(target, { 'scale.x': 1, 'scale.y': 1 }, 140, Easing.easeOutQuad),
+    );
   }
 
-  playIdle(): void { this._view?.playIdle?.(); }
+  playIdle(): void {
+    this._view?.playIdle?.();
+  }
 
   hasBadge(kind: 'multiplier' | 'bonus'): boolean {
     return kind === 'multiplier' ? this._multBadge != null : this._bonusBadge != null;
   }
 
   private _drawFrame(key: 'idle' | 'winning' | 'removed' | 'fresh'): void {
+    if (this.destroyed || this._frame.destroyed) return;
     const s = this._style[key];
     this._frame.clear();
     this._frame
@@ -102,7 +130,10 @@ export class SymbolCell extends Container {
   }
 
   private _setMultiplier(value?: number): void {
-    if (this._multBadge) { this._multBadge.destroy(); this._multBadge = null; }
+    if (this._multBadge) {
+      this._multBadge.destroy();
+      this._multBadge = null;
+    }
     if (!value || value <= 1) return;
     this._multBadge = this._badge(`×${value}`, 0xffd24a);
     this._multBadge.position.set(this._size / 2 - 12, -this._size / 2 + 12);
@@ -110,7 +141,10 @@ export class SymbolCell extends Container {
   }
 
   private _setBonus(value?: number): void {
-    if (this._bonusBadge) { this._bonusBadge.destroy(); this._bonusBadge = null; }
+    if (this._bonusBadge) {
+      this._bonusBadge.destroy();
+      this._bonusBadge = null;
+    }
     if (!value || value <= 0) return;
     this._bonusBadge = this._badge(`+${value}`, 0x7ad7ff);
     this._bonusBadge.position.set(-this._size / 2 + 12, -this._size / 2 + 12);

package/src/slot/index.ts

@@ -9,13 +9,72 @@ export { CascadeController } from './anim/CascadeController';
 export type { CascadeStepData, CascadeTimings, CascadeAnim } from './anim/CascadeController';
 export { ReelSpinController } from './anim/ReelSpinController';
 export type { ReelSpinData, ReelSpinTimings, ReelStopPlan } from './anim/ReelSpinController';
+export { EASING_BY_NAME, easingByName } from './anim/easing-map';
+
+// ── configurable reel system ────────────────────────────────────────────────
+export {
+  DEFAULT_REEL_CONFIG,
+  INTENSITY_SCALE,
+  FEATURE_KEYS,
+  resolveReelConfig,
+  mergeReelConfig,
+  effectiveRowsPerReel,
+  waysCount,
+} from './config/ReelSystemConfig';
+export type {
+  ReelSystemConfig,
+  DeepPartial,
+  EasingName,
+  EvaluationMode,
+  MotionStyle,
+  StopMode,
+  StopOrder,
+  Intensity,
+  GridConfig,
+  MotionConfig,
+  SettleConfig,
+  SquashConfig,
+  BlurConfig,
+  AnticipationConfig,
+  CascadeConfig,
+  WinConfig,
+  FeaturesConfig,
+  FeatureKey,
+  ExpandingWildConfig,
+  StickyConfig,
+  WalkingWildConfig,
+  MultiplierConfig,
+  MysteryConfig,
+  TransformConfig,
+  GiantConfig,
+  SplitConfig,
+  StackedConfig,
+  NudgeConfig,
+  ReelModifierConfig,
+  HoldAndSpinConfig,
+  RandomWildConfig,
+} from './config/ReelSystemConfig';
+export { PRESETS, PRESET_LIST } from './config/presets';
+export type { PresetId, ReelPreset } from './config/presets';
+
+export { SpinEngine } from './motion/SpinEngine';
+export type { SpinData, SpinRunOpts, ReelStopPlan as SpinStopPlan } from './motion/SpinEngine';
+export { AnticipationController } from './motion/AnticipationController';
+export type { AnticipationDecision } from './motion/AnticipationController';
+export { TumbleController } from './cascade/TumbleController';
+export type { TumbleStep } from './cascade/TumbleController';
+
+export { FEATURES, FEATURE_LIST } from './features';
+export type { ReelFeature, FeatureContext } from './features';
+
+export { createReelSystem } from './system/ReelSystem';
+export type { ReelSystem, CreateReelSystemOptions } from './system/ReelSystem';
+
 export { pickTier, tierIndexAtValue } from './overlay/tiers';
 export type { WinTier } from './overlay/tiers';
 export { valueAt, CountUpDisplay } from './overlay/CountUpDisplay';
 export type { CountUpConfig } from './overlay/CountUpDisplay';
 export { BigWinOverlay } from './overlay/BigWinOverlay';
 export type { BigWinOverlayConfig } from './overlay/BigWinOverlay';
-export { FreeSpinsSession } from './freeSpins/FreeSpinsSession';
-export type { FreeSpinsSessionConfig } from './freeSpins/FreeSpinsSession';
 export { MultiplierAccumulator } from './multiplier/MultiplierAccumulator';
 export type { CarryPolicy } from './multiplier/MultiplierAccumulator';