@energy8platform/game-engine 0.20.0 → 0.22.0

package/src/slot/config/presets.ts

@@ -0,0 +1,222 @@
+// packages/game-engine/src/slot/config/presets.ts
+//
+// Reel presets distilled from our shipped games (see docs/reels-analysis-and-design.md §2).
+// Each is a DeepPartial override on DEFAULT_REEL_CONFIG.
+
+import type { DeepPartial, ReelSystemConfig } from './ReelSystemConfig';
+
+export type PresetId =
+  | 'classic'
+  | 'kitsune-wrath'
+  | 'moon-spice'
+  | 'stone-rush'
+  | 'hot-ross'
+  | 'magnus'
+  | 'megaways';
+
+export interface ReelPreset {
+  id: PresetId;
+  name: string;
+  note: string;
+  config: DeepPartial<ReelSystemConfig>;
+}
+
+export const PRESETS: Record<PresetId, ReelPreset> = {
+  classic: {
+    id: 'classic',
+    name: 'Classic 5×3 lines',
+    note: 'Plain spinning reels, sequential stops, settle bounce.',
+    config: {
+      grid: { cols: 5, rows: 3, evaluation: 'lines', cellSize: 96, gap: 6 },
+      motion: {
+        style: 'strip',
+        spinUp: 600,
+        stopStagger: 140,
+        blur: { enabled: true, alpha: 0.85, strength: 6, streaks: false },
+      },
+    },
+  },
+  'kitsune-wrath': {
+    id: 'kitsune-wrath',
+    name: 'Kitsune Wrath 7×7 cluster',
+    note: 'Tumble grid, sticky wilds, position multipliers, scatter anticipation.',
+    config: {
+      grid: { cols: 7, rows: 7, evaluation: 'cluster', cellSize: 66, gap: 0 },
+      motion: {
+        style: 'cascade-drop',
+        spinUp: 400,
+        squash: { enabled: true, scaleX: 1.12, scaleY: 0.88, ms: 90 },
+      },
+      cascade: {
+        enabled: true,
+        gravity: true,
+        dimNonWinners: true,
+        multiplier: {
+          enabled: true,
+          start: 1,
+          mode: 'mul',
+          step: 2,
+          cap: 128,
+          persistInFreeSpins: false,
+        },
+      },
+      anticipation: { enabled: true, triggerSymbols: ['scatter'], threshold: 4 },
+      features: {
+        sticky: { enabled: true, durationSpins: 3 },
+        multiplier: { enabled: true, scope: 'perSymbol', combine: 'multiplicative', max: 128 },
+      },
+    },
+  },
+  'moon-spice': {
+    id: 'moon-spice',
+    name: 'Moon Spice 5×4 ways',
+    note: 'Spin + cascade refill, frame shake on wild/scatter, 1024 ways.',
+    config: {
+      grid: { cols: 5, rows: 4, evaluation: 'ways', cellSize: 90, gap: 4 },
+      motion: {
+        style: 'strip',
+        spinUp: 1200,
+        stopStagger: 120,
+        settle: { amp: 6, ms: 220, easing: 'easeOutQuad' },
+      },
+      cascade: {
+        enabled: true,
+        gravity: true,
+        easings: { highlight: 'easeOutQuad', remove: 'easeInBack', drop: 'easeOutBounce' },
+      },
+      win: { frameShake: { enabled: true, amp: 2.2, ms: 180, onlyOnSymbols: ['wild', 'scatter'] } },
+      features: { multiplier: { enabled: true, scope: 'perSymbol', combine: 'additive' } },
+    },
+  },
+  'stone-rush': {
+    id: 'stone-rush',
+    name: 'Stone Rush 7×7 tumble',
+    note: 'Weighty gravity with squash/stretch, per-step deceleration, multiplier orbs.',
+    config: {
+      grid: { cols: 7, rows: 7, evaluation: 'cluster', cellSize: 66, gap: 8 },
+      motion: {
+        style: 'cascade-drop',
+        spinUp: 320,
+        squash: { enabled: true, scaleX: 1.3, scaleY: 0.7, ms: 110 },
+      },
+      cascade: {
+        enabled: true,
+        gravity: true,
+        perStepDecel: 0.08,
+        perStepDecelCap: 1.5,
+        multiplier: {
+          enabled: true,
+          start: 1,
+          mode: 'add',
+          step: 1,
+          cap: 100,
+          persistInFreeSpins: true,
+        },
+      },
+      features: {
+        multiplier: { enabled: true, scope: 'global', combine: 'additive', max: 100 },
+        expandingWild: { enabled: true, symbol: 'wild', toFullReel: false },
+      },
+    },
+  },
+  'hot-ross': {
+    id: 'hot-ross',
+    name: 'Hot Ross 5×5 lines',
+    note: 'Classic strip spin with motion blur, scatter tease, expanding wilds, sticky reels.',
+    config: {
+      grid: { cols: 5, rows: 5, evaluation: 'lines', cellSize: 88, gap: 4 },
+      motion: {
+        style: 'strip',
+        spinUp: 1650,
+        stopStagger: 210,
+        blur: { enabled: true, alpha: 0.82, strength: 8, streaks: true },
+        settle: { amp: 7, ms: 240, easing: 'easeOutBack' },
+      },
+      anticipation: {
+        enabled: true,
+        triggerSymbols: ['scatter'],
+        threshold: 2,
+        slowdownFactor: 0.28,
+        holdMs: 450,
+      },
+      features: {
+        expandingWild: { enabled: true, symbol: 'wild', reels: [1, 2, 3], toFullReel: true },
+        sticky: { enabled: true, durationSpins: 0 },
+      },
+    },
+  },
+  magnus: {
+    id: 'magnus',
+    name: 'Magnus 6×6 transmute',
+    note: 'Cascade with idle-breathing symbols, scatter anticipation + reel zoom, transform.',
+    config: {
+      grid: { cols: 6, rows: 6, evaluation: 'cluster', cellSize: 74, gap: 2 },
+      motion: {
+        style: 'cascade-drop',
+        spinUp: 400,
+        squash: { enabled: true, scaleX: 1.14, scaleY: 0.86, ms: 110 },
+      },
+      cascade: {
+        enabled: true,
+        gravity: true,
+        multiplier: {
+          enabled: true,
+          start: 1,
+          mode: 'add',
+          step: 1,
+          cap: null,
+          persistInFreeSpins: true,
+        },
+      },
+      anticipation: {
+        enabled: true,
+        triggerSymbols: ['scatter'],
+        threshold: 2,
+        holdMs: 280,
+        zoom: { enabled: true, scale: 1.3, ms: 600 },
+      },
+      features: {
+        transform: {
+          enabled: true,
+          source: 'randomLow',
+          target: 'h1',
+          allInstances: true,
+          upgradeOnly: true,
+        },
+      },
+    },
+  },
+  megaways: {
+    id: 'megaways',
+    name: 'Megaways 6× (2–7)',
+    note: 'Variable per-reel heights, tumble + climbing multiplier, anticipation.',
+    config: {
+      grid: {
+        cols: 6,
+        rows: 4,
+        rowsPerReel: [4, 6, 3, 7, 5, 2],
+        evaluation: 'megaways',
+        cellSize: 74,
+        gap: 4,
+        minRows: 2,
+        maxRows: 7,
+      },
+      motion: { style: 'strip', spinUp: 900, stopStagger: 130 },
+      cascade: {
+        enabled: true,
+        gravity: true,
+        multiplier: {
+          enabled: true,
+          start: 1,
+          mode: 'add',
+          step: 1,
+          cap: null,
+          persistInFreeSpins: true,
+        },
+      },
+      anticipation: { enabled: true, triggerSymbols: ['scatter'], threshold: 3 },
+    },
+  },
+};
+
+export const PRESET_LIST: ReelPreset[] = Object.values(PRESETS);

package/src/slot/features/extra.ts

@@ -0,0 +1,189 @@
+// packages/game-engine/src/slot/features/extra.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';
+
+const seeded = (a: number, b: number, seed: number) =>
+  Math.min(b, a + Math.floor(((Math.sin(seed * 53.17) + 1) / 2) * (b - a + 1)));
+
+/** Multiplier symbols: marked cells carry values that combine into the win. */
+export const MultiplierSymbols: ReelFeature = {
+  key: 'multiplier',
+  label: 'Multiplier symbols',
+  enabled: (c) => c.features.multiplier.enabled,
+  async demo(ctx: FeatureContext) {
+    const f = ctx.cfg.features.multiplier;
+    const spots = pickFromBoard(ctx.board, () => true)
+      .filter((_, i) => i % 4 === 0)
+      .slice(0, 3);
+    const values = [2, 3, 5].slice(0, spots.length);
+    spots.forEach((p, i) =>
+      ctx.grid.getCell(p.col, p.row).setData({ symbol: f.symbol ?? 'wild', multiplier: values[i] }),
+    );
+    await Promise.all(spots.map((p) => pulseCell(ctx.grid.getCell(p.col, p.row), 1.2, 240)));
+    const total =
+      f.combine === 'additive'
+        ? values.reduce((a, b) => a + b, 0)
+        : values.reduce((a, b) => a * b, 1);
+    const capped = Math.min(total, f.max);
+    ctx.log?.(
+      `Multiplier (${f.combine}, ${f.scope}): ${values.join(f.combine === 'additive' ? ' + ' : ' × ')} = ×${capped}`,
+    );
+    // fly each value toward the centre, then show the combined total
+    await Promise.all(
+      spots.map(async (p) => {
+        const { x, y } = cellCenter(ctx.grid, p.col, p.row);
+        await floatLabel(ctx.fx, x, y, `×${values[spots.indexOf(p)]}`, 0xffd24a, 500);
+      }),
+    );
+    const cx = (ctx.grid.cols * ctx.grid.cellSize) / 2 - ctx.grid.cellSize / 2;
+    const cy = (ctx.grid.rows * ctx.grid.cellSize) / 2 - ctx.grid.cellSize / 2;
+    await floatLabel(ctx.fx, cx, cy, `×${capped}`, 0xffe24a, 900);
+  },
+};
+
+/** Nudge / xNudge: a reel nudges one position (xNudge fills a stacked wild, +1 mult per nudge). */
+export const NudgeReels: ReelFeature = {
+  key: 'nudge',
+  label: 'Nudge / xNudge',
+  enabled: (c) => c.features.nudge.enabled,
+  async demo(ctx: FeatureContext) {
+    const f = ctx.cfg.features.nudge;
+    const cols = ctx.grid.cols;
+    const reel = f.reels.length ? f.reels[0] : Math.floor(cols / 2);
+    const rows = ctx.grid.rowsOf(reel);
+    ctx.log?.(
+      f.toFullReel ? `xNudge: filling reel ${reel} with wild` : `Nudge reel ${reel} by ${f.step}`,
+    );
+    if (f.toFullReel) {
+      let mult = f.multiplierStart;
+      for (let r = 0; r < rows; r++) {
+        const cell = ctx.grid.getCell(reel, r);
+        await morphSymbol(cell, { symbol: 'wild', multiplier: mult > 1 ? mult : undefined }, 160);
+        mult += f.multiplierPerNudge;
+      }
+      const { x, y } = cellCenter(ctx.grid, reel, Math.floor(rows / 2));
+      await floatLabel(ctx.fx, x, y, `×${mult - f.multiplierPerNudge}`, 0xff7a3c, 800);
+    } else {
+      // shift the whole column down by `step` cells, then settle
+      const step = ctx.grid.cellPosition(reel, 1).y - ctx.grid.cellPosition(reel, 0).y;
+      const cells = Array.from({ length: rows }, (_, r) => ctx.grid.getCell(reel, r));
+      await Promise.all(
+        cells.map((c) =>
+          Tween.to(c, { 'position.y': c.y + step * f.step }, 240, easingByName('easeOutBack')),
+        ),
+      );
+      cells.forEach((c, r) =>
+        c.position.set(ctx.grid.cellPosition(reel, r).x, ctx.grid.cellPosition(reel, r).y),
+      );
+    }
+  },
+};
+
+/** Hold-and-spin / Hold & Win: special symbols lock and respins reset on each new lock. */
+export const HoldAndSpin: ReelFeature = {
+  key: 'holdAndSpin',
+  label: 'Hold & Spin (respin)',
+  enabled: (c) => c.features.holdAndSpin.enabled,
+  async demo(ctx: FeatureContext) {
+    const f = ctx.cfg.features.holdAndSpin;
+    const all = pickFromBoard(ctx.board, () => true);
+    const sym = f.lockSymbols[0] ?? 'coin';
+    const locked = new Set<string>();
+    const lock = async (p: { col: number; row: number }, value: string) => {
+      const cell = ctx.grid.getCell(p.col, p.row);
+      cell.setData({ symbol: sym });
+      await dropCell(ctx.grid, cell, p.col, p.row, 240);
+      glowRing(ctx.fx, ctx.grid, p.col, p.row, 0xffcf5c);
+      const { x, y } = cellCenter(ctx.grid, p.col, p.row);
+      await floatLabel(ctx.fx, x, y, value, 0xffe24a, 500);
+      locked.add(`${p.col}:${p.row}`);
+    };
+    // trigger
+    const trigger = all.slice(0, f.triggerThreshold);
+    ctx.log?.(`Hold & Spin triggered with ${trigger.length} ${sym}`);
+    await Promise.all(trigger.map((p, i) => lock(p, `${(i + 1) * 5}`)));
+    let respins = f.respinsAwarded;
+    let round = 0;
+    while (respins > 0) {
+      round++;
+      const free = all.filter((p) => !locked.has(`${p.col}:${p.row}`));
+      const landed = free.filter((_, i) => seeded(0, 3, i + round * 3) === 0).slice(0, 2);
+      ctx.log?.(
+        `Respin ${round}: ${respins} left` + (landed.length ? ` — ${landed.length} new lock` : ''),
+      );
+      if (landed.length && f.resetOnNewSymbol) {
+        respins = f.respinsAwarded;
+        await Promise.all(landed.map((p) => lock(p, 'JP')));
+      } else respins--;
+      if (locked.size >= all.length) {
+        ctx.log?.(f.fullGridAwardsGrand ? 'Full grid — GRAND!' : 'Full grid');
+        break;
+      }
+      await Tween.delay(120);
+    }
+    ctx.log?.(`Hold & Spin: ${locked.size} locked`);
+  },
+};
+
+/** Random pre-spin reel modifiers (add rows, inject wilds, set giant, guaranteed wilds). */
+export const ReelModifier: ReelFeature = {
+  key: 'reelModifier',
+  label: 'Random reel modifier',
+  enabled: (c) => c.features.reelModifier.enabled,
+  async demo(ctx: FeatureContext) {
+    const f = ctx.cfg.features.reelModifier;
+    const pool = f.pool.length
+      ? f.pool
+      : [{ effect: 'addWilds' as const, magnitude: 3, weight: 1 }];
+    const totalW = pool.reduce((a, m) => a + m.weight, 0);
+    let roll = ((Math.sin(ctx.grid.cols * 7.7) + 1) / 2) * totalW;
+    let mod = pool[0];
+    for (const m of pool) {
+      roll -= m.weight;
+      if (roll <= 0) {
+        mod = m;
+        break;
+      }
+    }
+    ctx.log?.(`Reel modifier: ${mod.effect} (+${mod.magnitude})`);
+    if (mod.effect === 'addRows') {
+      const next = ctx.grid.rowsPerReel.map((r) => r + mod.magnitude);
+      // grow the board (new cells on top) and keep the system config in sync so the new rows
+      // aren't blank and a later spin/rebuild doesn't revert the shape
+      for (let c = 0; c < ctx.board.length; c++) {
+        const col = ctx.board[c] ?? (ctx.board[c] = []);
+        const fill = col[0]?.symbol ?? 'h1';
+        for (let i = 0; i < mod.magnitude; i++) col.unshift({ symbol: fill });
+      }
+      ctx.cfg.grid.rowsPerReel = next;
+      ctx.grid.reshape(next);
+      ctx.grid.setGrid(ctx.board);
+    } else if (mod.effect === 'addWilds' || mod.effect === 'guaranteedWilds') {
+      const spots = pickFromBoard(ctx.board, () => true);
+      const chosen: { col: number; row: number }[] = [];
+      for (let i = 0; i < mod.magnitude && spots.length; i++)
+        chosen.push(spots.splice(seeded(0, spots.length - 1, i), 1)[0]);
+      await Promise.all(
+        chosen.map(async (p) => {
+          const cell = ctx.grid.getCell(p.col, p.row);
+          cell.setData({ symbol: 'wild' });
+          await dropCell(ctx.grid, cell, p.col, p.row, 280);
+        }),
+      );
+    } else if (mod.effect === 'setGiant') {
+      const cell = ctx.grid.getCell(0, 0);
+      await pulseCell(cell, 1.3, 300);
+    }
+  },
+};

package/src/slot/features/index.ts

@@ -0,0 +1,44 @@
+// packages/game-engine/src/slot/features/index.ts
+import type { FeatureKey } from '../config/ReelSystemConfig';
+import { FEATURE_KEYS } from '../config/ReelSystemConfig';
+import type { ReelFeature } from './types';
+import { ExpandingWild, StickySymbols, WalkingWild, RandomWild } from './wilds';
+import {
+  MysterySymbols,
+  SymbolTransform,
+  GiantSymbol,
+  SplitSymbol,
+  StackedSymbols,
+} from './symbols';
+import { MultiplierSymbols, NudgeReels, HoldAndSpin, ReelModifier } from './extra';
+
+export * from './types';
+export { ExpandingWild, StickySymbols, WalkingWild, RandomWild } from './wilds';
+export {
+  MysterySymbols,
+  SymbolTransform,
+  GiantSymbol,
+  SplitSymbol,
+  StackedSymbols,
+} from './symbols';
+export { MultiplierSymbols, NudgeReels, HoldAndSpin, ReelModifier } from './extra';
+
+/** All feature modules keyed by their FeatureKey. */
+export const FEATURES: Record<FeatureKey, ReelFeature> = {
+  expandingWild: ExpandingWild,
+  sticky: StickySymbols,
+  walkingWild: WalkingWild,
+  randomWild: RandomWild,
+  mystery: MysterySymbols,
+  transform: SymbolTransform,
+  giant: GiantSymbol,
+  split: SplitSymbol,
+  stacked: StackedSymbols,
+  multiplier: MultiplierSymbols,
+  nudge: NudgeReels,
+  holdAndSpin: HoldAndSpin,
+  reelModifier: ReelModifier,
+};
+
+/** Features in canonical resolve order (see docs §3.4). */
+export const FEATURE_LIST: ReelFeature[] = FEATURE_KEYS.map((k) => FEATURES[k]);

package/src/slot/features/symbols.ts

@@ -0,0 +1,183 @@
+// packages/game-engine/src/slot/features/symbols.ts
+import { Container } from 'pixi.js';
+import { Tween } from '../../animation';
+import { easingByName } from '../anim/easing-map';
+import {
+  type FeatureContext,
+  type ReelFeature,
+  cellCenter,
+  floatLabel,
+  morphSymbol,
+  pickFromBoard,
+  pulseCell,
+  rowStepOf,
+} from './types';
+
+const pick = <T>(arr: T[], seed: number): T =>
+  arr[Math.floor(((Math.sin(seed * 12.9898) + 1) / 2) * arr.length) % arr.length];
+
+/** Mystery symbols: all mystery tiles reveal the SAME single random symbol per spin. */
+export const MysterySymbols: ReelFeature = {
+  key: 'mystery',
+  label: 'Mystery symbols',
+  enabled: (c) => c.features.mystery.enabled,
+  async demo(ctx: FeatureContext) {
+    const f = ctx.cfg.features.mystery;
+    const spots = pickFromBoard(ctx.board, () => true)
+      .filter((_, i) => i % 3 === 0)
+      .slice(0, 5);
+    spots.forEach((p) => ctx.grid.getCell(p.col, p.row).setData({ symbol: f.symbol }));
+    await Promise.all(spots.map((p) => pulseCell(ctx.grid.getCell(p.col, p.row), 1.1, 200)));
+    const pool = f.revealPool.length ? f.revealPool : ['h1', 'h2', 'h3'];
+    const reveal = pick(pool, ctx.grid.cols + spots.length);
+    ctx.log?.(`Mystery: ${spots.length} tiles reveal "${reveal}"`);
+    await Promise.all(
+      spots.map((p) => morphSymbol(ctx.grid.getCell(p.col, p.row), { symbol: reveal }, f.ms)),
+    );
+    spots.forEach((p) => {
+      if (ctx.board[p.col]) ctx.board[p.col][p.row] = { symbol: reveal };
+    });
+  },
+};
+
+/** Symbol transform / upgrade: every instance of one symbol type becomes another. */
+export const SymbolTransform: ReelFeature = {
+  key: 'transform',
+  label: 'Symbol transform / upgrade',
+  enabled: (c) => c.features.transform.enabled,
+  async demo(ctx: FeatureContext) {
+    const f = ctx.cfg.features.transform;
+    const present = Array.from(
+      new Set(
+        pickFromBoard(ctx.board, (c) => !!c.symbol).map((p) => ctx.board[p.col][p.row].symbol!),
+      ),
+    );
+    const lows = present.filter((s) => /^(l|o|a|k|q|j|t|10)/i.test(s));
+    const source =
+      f.source === 'randomLow'
+        ? (pick(lows.length ? lows : present, ctx.grid.cols) ?? present[0])
+        : f.source;
+    if (!source) {
+      ctx.log?.('Transform: nothing to convert');
+      return;
+    }
+    const matches = pickFromBoard(ctx.board, (c) => c.symbol === source);
+    const targets = f.allInstances ? matches : matches.slice(0, 1);
+    ctx.log?.(`Transform: ${targets.length}× "${source}" → "${f.target}"`);
+    await Promise.all(
+      targets.map(async (p, i) => {
+        await Tween.delay(i * 40);
+        await morphSymbol(ctx.grid.getCell(p.col, p.row), { symbol: f.target }, f.ms);
+        if (ctx.board[p.col]) ctx.board[p.col][p.row] = { symbol: f.target };
+      }),
+    );
+  },
+};
+
+/** Giant / colossal symbol spanning width×height cells. */
+export const GiantSymbol: ReelFeature = {
+  key: 'giant',
+  label: 'Giant / colossal symbol',
+  enabled: (c) => c.features.giant.enabled,
+  async demo(ctx: FeatureContext) {
+    const f = ctx.cfg.features.giant;
+    if (f.onlyInFreeSpins && !ctx.freeSpins) {
+      ctx.log?.('Giant: free-spins only');
+      return;
+    }
+    const cols = ctx.grid.cols;
+    const w = Math.min(f.width, cols);
+    const anchorCol = Math.max(0, Math.floor((cols - w) / 2));
+    // span only as tall as the SHORTEST covered reel so every covered cell exists (Megaways-safe)
+    let minRows = ctx.grid.rowsOf(anchorCol);
+    for (let c = anchorCol; c < anchorCol + w; c++) minRows = Math.min(minRows, ctx.grid.rowsOf(c));
+    const h = Math.min(f.height, minRows);
+    const sym = f.symbols.length ? pick(f.symbols, cols) : 'h1';
+    ctx.log?.(`Giant ${w}×${h} "${sym}"`);
+    const view = ctx.resolve(sym);
+    if (!view) return;
+    const step = rowStepOf(ctx.grid);
+    const tl = cellCenter(ctx.grid, anchorCol, 0);
+    const giant = new Container();
+    giant.addChild(view);
+    view.resize?.(ctx.grid.cellSize * Math.max(w, h));
+    if (view.scale)
+      view.scale.set(
+        ((ctx.grid.cellSize * w) / (ctx.grid.cellSize * Math.max(w, h))) * view.scale.x,
+        ((ctx.grid.cellSize * h) / (ctx.grid.cellSize * Math.max(w, h))) * view.scale.y,
+      );
+    giant.position.set(tl.x + ((w - 1) * step) / 2, tl.y + ((h - 1) * step) / 2);
+    // hide covered cells
+    for (let c = anchorCol; c < anchorCol + w; c++)
+      for (let r = 0; r < h; r++) ctx.grid.getCell(c, r).visible = false;
+    giant.scale.set(0.2);
+    giant.alpha = 0;
+    ctx.fx.addChild(giant);
+    await Tween.to(
+      giant,
+      { 'scale.x': 1, 'scale.y': 1, alpha: 1 },
+      420,
+      easingByName('easeOutBack'),
+    );
+    await Tween.delay(600);
+    giant.destroy();
+    for (let c = anchorCol; c < anchorCol + w; c++)
+      for (let r = 0; r < h; r++) ctx.grid.getCell(c, r).visible = true;
+  },
+};
+
+/** Split symbol (xSplit): doubles every symbol to its left. */
+export const SplitSymbol: ReelFeature = {
+  key: 'split',
+  label: 'Split symbol (xSplit)',
+  enabled: (c) => c.features.split.enabled,
+  async demo(ctx: FeatureContext) {
+    const f = ctx.cfg.features.split;
+    const cols = ctx.grid.cols;
+    const splitReel = f.reels.length ? f.reels[0] : cols - 1;
+    const row = Math.floor(ctx.grid.rowsOf(splitReel) / 2);
+    await morphSymbol(ctx.grid.getCell(splitReel, row), { symbol: f.symbol }, 240);
+    ctx.log?.(`Split ×${f.factor}: doubling symbols left of reel ${splitReel}`);
+    const left = pickFromBoard(ctx.board, (_c, col) => col < splitReel);
+    await Promise.all(
+      left.map(async (p, i) => {
+        await Tween.delay((i % 6) * 30);
+        const { x, y } = cellCenter(ctx.grid, p.col, p.row);
+        await pulseCell(ctx.grid.getCell(p.col, p.row), 1.12, 200);
+        await floatLabel(
+          ctx.fx,
+          x + ctx.grid.cellSize / 3,
+          y - ctx.grid.cellSize / 3,
+          `×${f.factor}`,
+          0x9b5cff,
+          600,
+        );
+      }),
+    );
+  },
+};
+
+/** Stacked symbols: a reel shows a full stack of one symbol. */
+export const StackedSymbols: ReelFeature = {
+  key: 'stacked',
+  label: 'Stacked symbols',
+  enabled: (c) => c.features.stacked.enabled,
+  async demo(ctx: FeatureContext) {
+    const f = ctx.cfg.features.stacked;
+    const cols = ctx.grid.cols;
+    const reel = Math.floor(cols / 2);
+    const rows = ctx.grid.rowsOf(reel);
+    const sym = f.symbols.length ? pick(f.symbols, reel) : 'h1';
+    const height = Math.min(f.height, rows);
+    ctx.log?.(`Stacked "${sym}" ×${height} on reel ${reel}`);
+    const start = Math.floor((rows - height) / 2);
+    await Promise.all(
+      Array.from({ length: height }, (_, i) => start + i).map(async (r, i) => {
+        await Tween.delay(i * 50);
+        const cell = ctx.grid.getCell(reel, r);
+        await morphSymbol(cell, { symbol: sym }, 220);
+        if (ctx.board[reel]) ctx.board[reel][r] = { symbol: sym };
+      }),
+    );
+  },
+};