@nayan-ui/games 1.20.0 → 1.21.0

package/src/games/checkers/CheckersAI.ts

@@ -1,255 +0,0 @@
-// The robot's search, ported unchanged from the original version (games/checkers/CheckersAI.ts): fail-soft
-// alpha-beta minimax on one mutable board, picking the same moves for the same position.
-import type { CheckersBoard, FullMove } from './CheckersRules';
-
-// The board's side (CheckersRules imports this file, so it's not imported back from there).
-const BOARD_N = 8;
-
-// ===========================================================================
-// AI search — fail-soft alpha-beta minimax (black maximizes) on one mutable
-// Int8Array board with make / unmake and reused per-ply move buffers, so a
-// search allocates nothing per node. Move order, scores and pruning match the
-// object-board rules in CheckersStore exactly (same move picked every time).
-// ===========================================================================
-
-const SQUARES = BOARD_N * BOARD_N;
-const LAST_ROW_START = SQUARES - BOARD_N;
-
-// Cell codes: 0 empty, +1 black man, +2 black king, -1 red man, -2 red king.
-// Sign is the owner: black (AI) = +1, red (human) = -1.
-const AI_SIDE = 1;
-const HUMAN_SIDE = -1;
-
-// Directions in the original order: up-left, up-right, down-left, down-right.
-// Kings use 0..3, red men 0..1 (move up), black men 2..3 (move down).
-const DIR_R = [-1, -1, 1, 1] as const;
-const DIR_C = [-1, 1, -1, 1] as const;
-// STEP[sq * 4 + d] = adjacent square (-1 off board); JUMP = landing square two away.
-const STEP = new Int8Array(SQUARES * 4);
-const JUMP = new Int8Array(SQUARES * 4);
-for (let sq = 0; sq < SQUARES; sq++) {
-  const row = Math.floor(sq / BOARD_N);
-  const col = sq % BOARD_N;
-  for (let d = 0; d < 4; d++) {
-    const r1 = row + DIR_R[d]!;
-    const c1 = col + DIR_C[d]!;
-    const r2 = row + DIR_R[d]! * 2;
-    const c2 = col + DIR_C[d]! * 2;
-    STEP[sq * 4 + d] = r1 >= 0 && r1 < BOARD_N && c1 >= 0 && c1 < BOARD_N ? r1 * BOARD_N + c1 : -1;
-    JUMP[sq * 4 + d] = r2 >= 0 && r2 < BOARD_N && c2 >= 0 && c2 < BOARD_N ? r2 * BOARD_N + c2 : -1;
-  }
-}
-const dirLo = (code: number): number => (code === 1 ? 2 : 0);
-const dirHi = (code: number): number => (code === -1 ? 2 : 4);
-const promotes = (code: number, to: number): boolean => (code === 1 && to >= LAST_ROW_START) || (code === -1 && to < BOARD_N);
-
-// Static evaluation per (code, square): material + advancement bonus for men.
-const MAN_VALUE = 100;
-const KING_VALUE = 175;
-const EVAL = new Int16Array(5 * SQUARES);
-for (let sq = 0; sq < SQUARES; sq++) {
-  const row = Math.floor(sq / BOARD_N);
-  EVAL[(1 + 2) * SQUARES + sq] = MAN_VALUE + row * 2;
-  EVAL[(2 + 2) * SQUARES + sq] = KING_VALUE;
-  EVAL[(-1 + 2) * SQUARES + sq] = -(MAN_VALUE + (BOARD_N - 1 - row) * 2);
-  EVAL[(-2 + 2) * SQUARES + sq] = -KING_VALUE;
-}
-
-// Move record layout in a buffer: from, to, promoted (0/1), capture count,
-// then (square, captured code) pairs. 12 captures max (one side's pieces).
-const MAX_CAPTURES = 12;
-const STRIDE = 4 + MAX_CAPTURES * 2;
-
-const board = new Int8Array(SQUARES);
-const plyBuffers: number[][] = [];
-// Scratch state for capture-sequence expansion (avoids closures / args).
-let genBuf: number[] = [];
-let genCount = 0;
-const capSq = new Int8Array(MAX_CAPTURES);
-const capCode = new Int8Array(MAX_CAPTURES);
-
-const record = (from: number, to: number, promoted: boolean, nCap: number) => {
-  let o = genCount * STRIDE;
-  genBuf[o++] = from;
-  genBuf[o++] = to;
-  genBuf[o++] = promoted ? 1 : 0;
-  genBuf[o++] = nCap;
-  for (let k = 0; k < nCap; k++) {
-    genBuf[o++] = capSq[k]!;
-    genBuf[o++] = capCode[k]!;
-  }
-  genCount++;
-};
-
-// Depth-first multi-jump expansion, hopping on the real board and undoing —
-// same order and same mid-sequence board as the original applyStep chain.
-const expandJumps = (origin: number, cur: number, code: number, side: number, nCap: number, lo: number, hi: number) => {
-  let found = false;
-  for (let d = lo; d < hi; d++) {
-    const land = JUMP[cur * 4 + d]!;
-    if (land < 0 || board[land] !== 0) continue;
-    const mid = STEP[cur * 4 + d]!;
-    const midCode = board[mid]!;
-    if (midCode * side >= 0) continue; // empty or own piece
-    found = true;
-    board[cur] = 0;
-    board[mid] = 0;
-    board[land] = code;
-    capSq[nCap] = mid;
-    capCode[nCap] = midCode;
-    if (promotes(code, land))
-      record(origin, land, true, nCap + 1); // promotion ends the move
-    else expandJumps(origin, land, code, side, nCap + 1, lo, hi);
-    board[land] = 0;
-    board[mid] = midCode;
-    board[cur] = code;
-  }
-  if (!found && nCap > 0) record(origin, cur, false, nCap);
-};
-
-// All legal full moves for `side` into `buf` (captures mandatory); returns count.
-const generateMoves = (side: number, buf: number[]): number => {
-  genBuf = buf;
-  genCount = 0;
-  for (let i = 0; i < SQUARES; i++) {
-    const code = board[i]!;
-    if (code * side > 0) expandJumps(i, i, code, side, 0, dirLo(code), dirHi(code));
-  }
-  if (genCount > 0) return genCount;
-  for (let i = 0; i < SQUARES; i++) {
-    const code = board[i]!;
-    if (code * side <= 0) continue;
-    const hi = dirHi(code);
-    for (let d = dirLo(code); d < hi; d++) {
-      const to = STEP[i * 4 + d]!;
-      if (to >= 0 && board[to] === 0) record(i, to, promotes(code, to), 0);
-    }
-  }
-  return genCount;
-};
-
-// Equivalent to generateMoves(...) > 0 without building the list (depth-0 leaves).
-const hasAnyMove = (side: number): boolean => {
-  for (let i = 0; i < SQUARES; i++) {
-    const code = board[i]!;
-    if (code * side <= 0) continue;
-    const hi = dirHi(code);
-    for (let d = dirLo(code); d < hi; d++) {
-      const to = STEP[i * 4 + d]!;
-      if (to < 0) continue;
-      const t = board[to]!;
-      if (t === 0) return true;
-      if (t * side < 0) {
-        const land = JUMP[i * 4 + d]!;
-        if (land >= 0 && board[land] === 0) return true;
-      }
-    }
-  }
-  return false;
-};
-
-const evaluate = (): number => {
-  let score = 0;
-  for (let i = 0; i < SQUARES; i++) {
-    const code = board[i]!;
-    if (code !== 0) score += EVAL[(code + 2) * SQUARES + i]!;
-  }
-  return score;
-};
-
-const makeMove = (buf: number[], o: number) => {
-  const from = buf[o]!;
-  const code = board[from]!;
-  board[from] = 0;
-  const nCap = buf[o + 3]!;
-  for (let k = 0; k < nCap; k++) board[buf[o + 4 + k * 2]!] = 0;
-  board[buf[o + 1]!] = buf[o + 2] ? code * 2 : code;
-};
-
-const unmakeMove = (buf: number[], o: number) => {
-  const to = buf[o + 1]!;
-  const code = buf[o + 2] ? board[to]! / 2 : board[to]!;
-  board[to] = 0; // before restoring `from` (a king's loop can end where it began)
-  const nCap = buf[o + 3]!;
-  for (let k = 0; k < nCap; k++) board[buf[o + 4 + k * 2]!] = buf[o + 5 + k * 2]!;
-  board[buf[o]!] = code;
-};
-
-const minimax = (depth: number, maximizing: boolean, alpha: number, beta: number, ply: number): number => {
-  const side = maximizing ? AI_SIDE : HUMAN_SIDE;
-  if (depth === 0) {
-    if (!hasAnyMove(side)) return maximizing ? -100000 : 100000; // side to move loses
-    return evaluate();
-  }
-  const buf = plyBuffers[ply] ?? (plyBuffers[ply] = []);
-  const count = generateMoves(side, buf);
-  if (count === 0) return maximizing ? -100000 + depth : 100000 - depth;
-
-  if (maximizing) {
-    let best = -Infinity;
-    for (let m = 0; m < count; m++) {
-      makeMove(buf, m * STRIDE);
-      const val = minimax(depth - 1, false, alpha, beta, ply + 1);
-      unmakeMove(buf, m * STRIDE);
-      if (val > best) best = val;
-      if (best > alpha) alpha = best;
-      if (beta <= alpha) break;
-    }
-    return best;
-  }
-  let best = Infinity;
-  for (let m = 0; m < count; m++) {
-    makeMove(buf, m * STRIDE);
-    const val = minimax(depth - 1, true, alpha, beta, ply + 1);
-    unmakeMove(buf, m * STRIDE);
-    if (val < best) best = val;
-    if (best < beta) beta = best;
-    if (beta <= alpha) break;
-  }
-  return best;
-};
-
-const rootBuf: number[] = [];
-
-/**
- * Pick the AI's move among `moves` (the legal list for black on `src`).
- * Returns every root move whose depth-`depth` minimax score equals the best.
- *
- * Each root child used to be searched with a full (-Inf, Inf) window. Here the
- * window is (bestSoFar - 1, Inf): scores are integers, so fail-soft alpha-beta
- * still returns the exact score for any move >= bestSoFar and a value
- * <= bestSoFar - 1 for any worse move — the same best set, far fewer nodes.
- */
-export const bestAIMoves = (src: CheckersBoard, moves: FullMove[], depth: number): FullMove[] => {
-  for (let i = 0; i < SQUARES; i++) {
-    const p = src[i];
-    board[i] = p ? (p.player === 'black' ? 1 : -1) * (p.king ? 2 : 1) : 0;
-  }
-  let bestScore = -Infinity;
-  let best: FullMove[] = [];
-  for (const m of moves) {
-    // Encode the root move in the buffer layout so make / unmake can apply it.
-    const last = m.steps[m.steps.length - 1]!;
-    let nCap = 0;
-    for (const s of m.steps) {
-      if (s.captured === null) continue;
-      rootBuf[4 + nCap * 2] = s.captured;
-      rootBuf[5 + nCap * 2] = board[s.captured]!;
-      nCap++;
-    }
-    rootBuf[0] = m.from;
-    rootBuf[1] = last.to;
-    rootBuf[2] = promotes(board[m.from]!, last.to) ? 1 : 0;
-    rootBuf[3] = nCap;
-    makeMove(rootBuf, 0);
-    const score = minimax(depth - 1, false, bestScore - 1, Infinity, 0);
-    unmakeMove(rootBuf, 0);
-    if (score > bestScore) {
-      bestScore = score;
-      best = [m];
-    } else if (score === bestScore) {
-      best.push(m);
-    }
-  }
-  return best;
-};

package/src/games/checkers/CheckersConstants.ts

@@ -1,68 +0,0 @@
-// Checkers' scores, timings, colors and layout. Rules and scores match the original version
-// (games/checkers), so scores carry over.
-import { getScoreBoardTop } from '../shared/EngineHud';
-import type { TiltView } from '../shared/EngineTilt';
-import { frontLight, gameWidthFor } from '../shared/EngineUtils';
-
-// ── Rules and scoring ─────────────────────────────────────────────────
-
-export const GAME_DURATION = 300; // 5 minutes; running out loses
-export const POINTS_PER_CAPTURE = 500;
-export const KING_BONUS = 500; // more for capturing a king
-export const WIN_BONUS = 5000;
-export const AI_MOVE_DELAY = 0.55; // seconds the robot "thinks"
-
-// ── Motion ────────────────────────────────────────────────────────────
-
-export const SLIDE_TIME = 0.22; // a piece gliding one square
-export const HOP_TIME = 0.3; // a piece jumping over another
-
-// ── Colors ────────────────────────────────────────────────────────────
-
-export const COLORS = {
-  LIGHT_SQ: '#EED9B6',
-  DARK_SQ: '#A9744F',
-  BOARD_BORDER: '#61412E',
-  RED: '#E53935',
-  BLACK: '#37474F',
-  GOLD: '#FFC107',
-  SELECT: '#FFD54F',
-  MOVE: '#4CAF50',
-  CAPTURE: '#F44336'
-} as const;
-
-// ── The scene ─────────────────────────────────────────────────────────
-
-/** A directly overhead view keeps the board flat while the turned pawns retain their depth. */
-export const TILT = 0;
-export const BOARD_BORDER_WIDTH = 3;
-/** Lit from the upper left; surfaces facing up off the board (+z) keep their exact color. */
-export const LIGHT = frontLight([-0.4, 0.5, 1], 0.45);
-/** A piece's height, of a square (a king is two stacked). */
-export const PIECE_HEIGHT = 0.16;
-
-// ── Layout (view points) ──────────────────────────────────────────────
-
-const SCOREBOARD_HEIGHT = 82;
-const CONTROLS_HEIGHT = 120;
-
-export type Layout = TiltView & { cell: number; size: number };
-
-/** The board as wide as the original board (the game width, at most 460 points, 560 on a tablet), smaller if the screen is short. */
-export function getLayout(width: number, height: number, offset: number): Layout {
-  const top = getScoreBoardTop(offset) + SCOREBOARD_HEIGHT;
-  const room = Math.max(200, height - top - CONTROLS_HEIGHT);
-  const outer = Math.min(gameWidthFor(width), room / Math.cos(TILT) - 20);
-  const cell = Math.max(16, Math.floor((outer - BOARD_BORDER_WIDTH * 2) / 8));
-  return { width, height, tilt: TILT, centerY: top + room / 2, cell, size: cell * 8 };
-}
-
-/** A square's centre (row 0 along the top, the robot's side), in world units. */
-export const squareCentre = (l: Layout, index: number): [number, number] => [((index % 8) - 3.5) * l.cell, (3.5 - Math.floor(index / 8)) * l.cell];
-
-/** The square under a board point, or -1. */
-export function squareAt(l: Layout, x: number, y: number): number {
-  const col = Math.floor(x / l.cell + 4);
-  const row = Math.floor(4 - y / l.cell);
-  return col < 0 || col > 7 || row < 0 || row > 7 ? -1 : row * 8 + col;
-}

package/src/games/checkers/CheckersGame.ts

@@ -1,322 +0,0 @@
-// Checkers' play, with no React: build a game with `createGame`, give it a layout, `start` it and `tick`
-// it every frame. You are red and move first: tap one of your pieces to see where it can go, then tap a
-// square. Captures are forced and chain (keep tapping while the piece can jump); a man reaching the far
-// row is crowned. The robot (black) answers after a short think. Take or block all its pieces to win;
-// losing all yours, being blocked, or the five-minute clock running out loses.
-//
-// The rules and the robot are the original store's (CheckersRules.ts, CheckersAI.ts); the robot's think and
-// the clock run on the game's own clock, so Stop or leaving can't let a late move into the next game.
-import { type Camera, type DragEvent, World } from '@nayan-ui/engine';
-import type { GameTheme } from '../../services/ThemeService';
-import { aimTilted, unproject } from '../shared/EngineTilt';
-import { AI_MOVE_DELAY, GAME_DURATION, KING_BONUS, type Layout, PIECE_HEIGHT, POINTS_PER_CAPTURE, squareAt, WIN_BONUS } from './CheckersConstants';
-import {
-  AI,
-  allSteps,
-  applyFullMove,
-  applyStep,
-  type CheckerPlayer,
-  type CheckersBoard,
-  chooseAIMove,
-  countPieces,
-  createInitialBoard,
-  generateMoves,
-  HUMAN,
-  playerHasCapture,
-  singleJumps,
-  singleSlides,
-  type Step
-} from './CheckersRules';
-import { buildScene, celebrate, lift, movePiece, removeScene, resetPieces, type Scene, setSceneTheme, showHints, stepScene } from './CheckersScene';
-
-export type Phase = 'ready' | 'playing' | 'over';
-/** select: a piece picked up; move / capture: a hop (yours or the robot's); king: crowned; win / lose: the end (a timeout is silent, as in the original game). */
-export type GameEvent = 'select' | 'move' | 'capture' | 'king' | 'win' | 'lose';
-
-const WORLD_CAPACITY = 300; // the board's 64 squares, 24 pieces with their crowns, hints, and the bursts
-const TAP_SLOP = 12;
-
-export function createGame(theme: GameTheme) {
-  const world = new World(WORLD_CAPACITY);
-  const camera: Camera = { eye: [0, 0, 240], target: [0, 0, 0], fov: 1, ortho: 1 };
-  const g = {
-    world,
-    camera,
-    theme,
-    layout: null as Layout | null,
-    scene: null as Scene | null,
-    phase: 'ready' as Phase,
-    board: createInitialBoard() as CheckersBoard,
-    turn: HUMAN as CheckerPlayer,
-    selected: -1,
-    targets: [] as number[],
-    captures: [] as number[],
-    /** Mid multi-jump: the piece that must keep jumping (-1 when not). */
-    mustContinueFrom: -1,
-    winner: null as CheckerPlayer | null,
-    timedOut: false,
-    redCaptured: 0,
-    blackCaptured: 0,
-    /** Score and the countdown live in the engine (Rust), advanced by world.update. */
-    get score() {
-      return world.scoreboard.score;
-    },
-    moves: 0,
-    get timeLeft() {
-      return world.scoreboard.shownSeconds;
-    },
-    press: null as { x: number; y: number } | null,
-    // UI hooks, set by the screen.
-    onPhase: (_p: Phase) => {},
-    onScore: (_s: number) => {},
-    onCaptured: (_n: number) => {},
-    onTime: (_t: number) => {},
-    onEvent: (_e: GameEvent) => {}
-  };
-  world.scoreboard.reset(0, GAME_DURATION);
-  world.scoreboard.handlers = {
-    onSecond: (t) => g.onTime(t),
-    onTimeUp: () => {
-      if (g.phase !== 'playing') return;
-      g.timedOut = true;
-      g.winner = AI;
-      end(g);
-    }
-  };
-  return g;
-}
-export type Game = ReturnType<typeof createGame>;
-
-// ── Scene ─────────────────────────────────────────────────────────────
-
-/** Lays the board out for the view (first layout, header height, rotation): rebuilt where things stand. */
-export function setLayout(g: Game, l: Layout) {
-  if (g.scene) removeScene(g.world, g.scene);
-  g.layout = l;
-  aimTilted(g.camera, l);
-  g.scene = buildScene(g.world, l, g.theme, g.board);
-  hints(g);
-}
-
-export function setTheme(g: Game, theme: GameTheme) {
-  g.theme = theme;
-  if (g.layout && g.scene) setSceneTheme(g.world, g.layout, g.scene, theme);
-}
-
-function hints(g: Game) {
-  if (g.layout && g.scene) showHints(g.world, g.layout, g.scene, g.selected, g.targets, g.captures);
-}
-
-/** Picks a piece up (or puts it down): its hints, and it lifts. */
-function setSelection(g: Game, selected: number, targets: number[], captures: number[]) {
-  const { layout: l, scene: s } = g;
-  if (l && s && g.selected !== selected) {
-    if (g.selected >= 0 && g.board[g.selected]) lift(g.world, l, s, g.selected, false);
-    if (selected >= 0) lift(g.world, l, s, selected, true);
-  }
-  g.selected = selected;
-  g.targets = targets;
-  g.captures = captures;
-  hints(g);
-}
-
-// ── Run ───────────────────────────────────────────────────────────────
-
-function fresh(g: Game) {
-  g.world.cancelTimers();
-  g.board = createInitialBoard();
-  g.turn = HUMAN;
-  g.selected = -1;
-  g.targets = [];
-  g.captures = [];
-  g.mustContinueFrom = -1;
-  g.winner = null;
-  g.timedOut = false;
-  g.redCaptured = 0;
-  g.blackCaptured = 0;
-  g.world.scoreboard.reset(0, GAME_DURATION);
-  g.moves = 0;
-  g.press = null;
-  if (g.layout && g.scene) resetPieces(g.world, g.layout, g.scene, g.board);
-  hints(g);
-  g.onScore(0);
-  g.onCaptured(0);
-  g.onTime(GAME_DURATION);
-}
-
-/** A fresh board, your move. */
-export function start(g: Game) {
-  if (g.phase !== 'ready') return;
-  fresh(g);
-  g.world.scoreboard.startCountdown(GAME_DURATION);
-  g.phase = 'playing';
-  g.onPhase('playing');
-}
-
-/** A fresh board, not started (Stop, Play Again). The world, and the GPU view drawing it, are kept. */
-export function reset(g: Game) {
-  fresh(g);
-  g.phase = 'ready';
-  g.onPhase('ready');
-}
-
-export function dispose(g: Game) {
-  g.world.dispose();
-}
-
-export function tick(g: Game, dt: number) {
-  if (g.world.isDisposed) return;
-  if (g.scene) stepScene(g.scene, dt);
-  g.world.update(dt);
-}
-
-function end(g: Game) {
-  g.world.cancelTimers();
-  g.world.scoreboard.stop();
-  setSelection(g, -1, [], []);
-  g.mustContinueFrom = -1;
-  g.phase = 'over';
-  g.onPhase('over');
-}
-
-/** The game decided: the win bonus, its sound, and the end. */
-function finish(g: Game, winner: CheckerPlayer) {
-  g.winner = winner;
-  if (winner === HUMAN) {
-    g.onScore(g.world.scoreboard.add(WIN_BONUS));
-    if (g.layout && g.scene) celebrate(g.world, g.layout, g.scene, g.board);
-  }
-  g.onEvent(winner === HUMAN ? 'win' : 'lose');
-  end(g);
-}
-
-// ── Your moves (the original store's handleSelect, step for step) ─────────
-
-/** A square tapped: pick up one of your pieces, put it down, or move the picked one there. */
-export function select(g: Game, index: number) {
-  if (g.phase !== 'playing' || g.turn !== HUMAN) return;
-  const board = g.board;
-  // Mid multi-jump: only the jumping piece may go on
-  if (g.mustContinueFrom >= 0) {
-    if (index !== g.mustContinueFrom && g.targets.includes(index)) playerStep(g, g.mustContinueFrom, index);
-    return;
-  }
-  if (g.selected >= 0 && g.targets.includes(index)) return playerStep(g, g.selected, index);
-  const piece = board[index];
-  if (piece && piece.player === HUMAN) {
-    const steps = playerHasCapture(board, HUMAN) ? singleJumps(board, index, HUMAN, piece.king) : allSteps(board, index, HUMAN, piece.king);
-    if (steps.length === 0) return setSelection(g, -1, [], []);
-    setSelection(
-      g,
-      index,
-      steps.map((s) => s.to),
-      steps.filter((s) => s.captured !== null).map((s) => s.to)
-    );
-    g.onEvent('select');
-    return;
-  }
-  if (g.selected >= 0) setSelection(g, -1, [], []);
-}
-
-/** One hop of yours: a slide ends the turn; a jump chains while the piece can keep jumping. */
-function playerStep(g: Game, from: number, to: number) {
-  const board = g.board;
-  const piece = board[from];
-  if (!piece) return;
-  const step: Step | undefined =
-    singleJumps(board, from, piece.player, piece.king).find((s) => s.to === to) ??
-    singleSlides(board, from, piece.player, piece.king).find((s) => s.to === to);
-  if (!step) return;
-  const applied = applyStep(board, from, step, piece.player);
-  const captured = step.captured !== null;
-  const capturedKing = captured && board[step.captured!]?.king === true;
-  const moved = applied.board[to]!;
-  const canContinue = captured && !applied.promoted && singleJumps(applied.board, to, piece.player, moved.king).length > 0;
-
-  // The piece was lifted when picked: set it down as it goes
-  if (g.layout && g.scene) movePiece(g.world, g.layout, g.scene, from, [to], captured ? [step.captured!] : [], applied.promoted ? moved : null);
-  g.board = applied.board;
-  g.selected = -1;
-  if (captured) {
-    g.redCaptured += 1;
-    g.onScore(g.world.scoreboard.add(POINTS_PER_CAPTURE + (capturedKing ? KING_BONUS : 0)));
-    g.onCaptured(g.redCaptured);
-  }
-  if (canContinue) {
-    const targets = singleJumps(applied.board, to, piece.player, moved.king).map((s) => s.to);
-    g.mustContinueFrom = to;
-    g.selected = to;
-    g.targets = targets;
-    g.captures = targets.slice();
-    hints(g);
-  } else {
-    g.moves += 1;
-    g.mustContinueFrom = -1;
-    setSelection(g, -1, [], []);
-    g.turn = AI;
-  }
-  g.onEvent(captured ? 'capture' : 'move');
-  if (applied.promoted) g.onEvent('king');
-  if (canContinue) return;
-  // The robot's turn: did you just win?
-  if (countPieces(applied.board, AI) === 0 || generateMoves(applied.board, AI).length === 0) return finish(g, HUMAN);
-  g.world.after(AI_MOVE_DELAY, () => robotMove(g));
-}
-
-/** The robot's whole move (every hop of a multi-jump), and whether it leaves you beaten. */
-function robotMove(g: Game) {
-  if (g.phase !== 'playing' || g.turn !== AI) return;
-  const move = chooseAIMove(g.board);
-  if (!move) return finish(g, HUMAN);
-  const start = g.board;
-  const finalBoard = applyFullMove(start, move);
-  const captured = move.steps.filter((s) => s.captured !== null).map((s) => s.captured!);
-  const dest = move.steps[move.steps.length - 1]!.to;
-  const crowned = !start[move.from]!.king && finalBoard[dest]!.king;
-  if (g.layout && g.scene)
-    movePiece(
-      g.world,
-      g.layout,
-      g.scene,
-      move.from,
-      move.steps.map((s) => s.to),
-      captured,
-      crowned ? finalBoard[dest]! : null
-    );
-  g.board = finalBoard;
-  g.blackCaptured += captured.length;
-  g.moves += 1;
-  g.turn = HUMAN;
-  g.mustContinueFrom = -1;
-  setSelection(g, -1, [], []);
-  g.onEvent(captured.length ? 'capture' : 'move');
-  if (countPieces(finalBoard, HUMAN) === 0 || generateMoves(finalBoard, HUMAN).length === 0) finish(g, AI);
-}
-
-// ── The finger ────────────────────────────────────────────────────────
-
-/** The square under a view point (on the pieces' tops), or -1. */
-export function squareUnder(g: Game, x: number, y: number): number {
-  const l = g.layout;
-  if (!l) return -1;
-  const [wx, wy] = unproject(l, x, y, 1.2 + l.cell * PIECE_HEIGHT * 0.6);
-  return squareAt(l, wx, wy);
-}
-
-/** A tap (a finger down and up without wandering) selects the square under it. */
-export function drag(g: Game, { phase, x, y }: DragEvent) {
-  if (phase === 'start') {
-    g.press = { x, y };
-    return;
-  }
-  const p = g.press;
-  if (!p) return;
-  if (Math.hypot(x - p.x, y - p.y) > TAP_SLOP) {
-    g.press = null;
-    return;
-  }
-  if (phase !== 'end') return;
-  g.press = null;
-  const i = squareUnder(g, x, y);
-  if (i >= 0) select(g, i);
-}