@nayan-ui/games 1.19.0 → 1.20.0

package/src/games/checkers/CheckersAI.ts

@@ -0,0 +1,255 @@
+// 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

@@ -0,0 +1,68 @@
+// 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

@@ -0,0 +1,322 @@
+// 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);
+}