@nayan-ui/games 1.20.0 → 1.21.0

package/src/games/spider-solitaire/SpiderSolitaireConstants.ts

@@ -1,107 +0,0 @@
-// Spider Solitaire's timings, colors and layout. The rules (in SpiderSolitaireRules.ts) and the score
-// reported on a win match the original version (games/spider-solitaire), so scores carry over.
-import { getScoreBoardTop } from '../shared/EngineHud';
-import { project, type TiltView } from '../shared/EngineTilt';
-import { frontLight, gameWidthFor } from '../shared/EngineUtils';
-import type { Suit } from './SpiderSolitaireRules';
-
-// ── Rules and scoring ─────────────────────────────────────────────────
-
-/** A win scores by its time against ten minutes, as the original game did. */
-export const EXPECTED_TIME = 600;
-export const BASE_SCORE = 100;
-
-// ── Touch and feel ────────────────────────────────────────────────────
-
-export const TAP_SLOP = 10; // points a finger may wander and still tap
-export const MOVE_TIME = 0.24; // a card gliding to its place
-export const DEAL_STAGGER = 0.05; // between the cards of a dealt row
-export const RUN_STAGGER = 0.045; // between the cards of a finished run flying off
-export const WIN_DELAY = 1.1; // the last run flies home before the win card shows
-
-// ── Colors ────────────────────────────────────────────────────────────
-
-export const COLORS = {
-  FACE: '#FFFFFF',
-  BACK: '#1565C0',
-  BACK_LIGHT: '#3B82D6',
-  BACK_FRAME: '#E3F2FD',
-  RED: '#DC2626',
-  BLACK: '#1F2937',
-  SELECTED: '#FFE082',
-  CLASSIC_SLOT: 'rgba(255, 255, 255, 0.35)'
-} as const;
-export const SUIT_COLORS: Record<Suit, string> = { hearts: COLORS.RED, diamonds: COLORS.RED, clubs: COLORS.BLACK, spades: COLORS.BLACK };
-
-// ── The scene ─────────────────────────────────────────────────────────
-
-/** The camera leans back a little from straight down, so the cards' thickness and the stacks read as 3D. */
-export const TILT = 0.2;
-/** Lit from the upper left; surfaces facing up off the table (+z) keep their exact color. */
-export const LIGHT = frontLight([-0.35, 0.5, 1], 0.5);
-
-/** A card is 1.4 times as tall as it is wide, and this thin (of its width). */
-export const CARD_RATIO = 1.4;
-export const THICKNESS = 0.024;
-/** How far down a pile each card shows below the one under it (of a card's height), as the original piles. */
-export const FACE_DOWN_STEP = 0.15;
-export const FACE_UP_STEP = 0.25;
-/** The deck and the finished runs along the bottom are drawn at this size. */
-export const SMALL = 0.74;
-
-// ── Layout (view points; the world is one unit per point) ─────────────
-
-const SCOREBOARD_HEIGHT = 82;
-const CONTROLS_HEIGHT = 110;
-
-export type Layout = TiltView & {
-  /** A tableau card's width and height. */
-  card: number;
-  cardH: number;
-  /** Each pile's centre (world x). */
-  columns: number[];
-  pitch: number;
-  /** The top edge of a pile's first card, and the lowest a pile may reach (world y). */
-  pileTop: number;
-  pileBottom: number;
-  /** The bottom row: its centre (world y), the deck's right edge and the first finished run's centre (world x). */
-  rowY: number;
-  stockRight: number;
-  foundationX: number;
-  /** Heights between stacked cards (world z). */
-  dz: number;
-};
-
-/** The world y under a view y on the table. */
-const tableY = (v: TiltView, sy: number) => (v.centerY - sy) / Math.cos(v.tilt);
-
-/** All ten piles side by side across the game area (the original piles scrolled sideways), the deck and runs below. */
-export function getLayout(width: number, height: number, offset: number, tablet: boolean): Layout {
-  const gameWidth = gameWidthFor(width);
-  const gap = Math.max(3, Math.min(8, Math.round(width * 0.012)));
-  const card = Math.max(20, Math.min(tablet ? 96 : 64, Math.floor((gameWidth - gap * 9) / 10)));
-  const cardH = card * CARD_RATIO;
-  const pitch = card + gap;
-  const v: TiltView = { width, height, centerY: height / 2, tilt: TILT };
-  const top = getScoreBoardTop(offset) + SCOREBOARD_HEIGHT;
-  const bottom = height - CONTROLS_HEIGHT;
-  const smallH = cardH * SMALL;
-  const rowSy = bottom - smallH / 2 - 4;
-  const left = -((pitch * 10 - gap) / 2);
-  return {
-    ...v,
-    card,
-    cardH,
-    columns: Array.from({ length: 10 }, (_, i) => left + card / 2 + i * pitch),
-    pitch,
-    pileTop: tableY(v, top + 6),
-    pileBottom: tableY(v, rowSy - smallH / 2 - 10),
-    rowY: tableY(v, rowSy),
-    stockRight: -left,
-    foundationX: left + (card * SMALL) / 2,
-    dz: card * THICKNESS + 0.35
-  };
-}
-
-/** Where a table point at height z shows in the view. */
-export const onScreen = (l: Layout, x: number, y: number, z: number) => project(l, x, y, z);

package/src/games/spider-solitaire/SpiderSolitaireGame.ts

@@ -1,387 +0,0 @@
-// Spider Solitaire's play, with no React: build a game with `createGame`, give it a layout, `start` it
-// and `tick` it every frame. Tap a face-up card to pick up the run from it down (it must descend by
-// one), then tap another pile to put it there: on a card one rank higher, or an empty pile. Or drag the
-// run straight there. Tap the deck to deal a card onto every pile. A King-to-Ace run of one suit lifts
-// off by itself; all eight home wins. The clock counts up; the win scores by the time it took.
-//
-// The rules are the original store's (SpiderSolitaireRules.ts); every tap does what it did there.
-import { type Camera, type DragEvent, World } from '@nayan-ui/engine';
-import { calculateTimeBasedScore } from '../../services/ScoringService';
-import type { GameTheme } from '../../services/ThemeService';
-import { aimTilted, project, unproject } from '../shared/EngineTilt';
-import { BASE_SCORE, DEAL_STAGGER, EXPECTED_TIME, type Layout, MOVE_TIME, RUN_STAGGER, SMALL, TAP_SLOP, WIN_DELAY } from './SpiderSolitaireConstants';
-import {
-  type Board,
-  canMove,
-  type Card,
-  dealBlocked,
-  dealRow,
-  dealsLeft,
-  moveRun,
-  newBoard,
-  pickable,
-  PILES,
-  RUNS_TO_WIN,
-  takeCompletedRun
-} from './SpiderSolitaireRules';
-import {
-  buildScene,
-  celebrate,
-  type Held,
-  layoutCards,
-  pileOffsets,
-  pileSpot,
-  placeCards,
-  removeScene,
-  type Scene,
-  setSceneTheme,
-  shakeCards,
-  sparkle
-} from './SpiderSolitaireScene';
-
-export type Phase = 'ready' | 'playing' | 'over';
-/** select / deselect: a run picked up or put back; invalid: a move or deal not allowed; place: a run moved; deal: a row dealt; complete: a run lifted off; win: the eighth. */
-export type GameEvent = 'select' | 'deselect' | 'invalid' | 'place' | 'deal' | 'complete' | 'win';
-
-const WORLD_CAPACITY = 900; // 104 cards with their pips, the empty places, and the bursts
-
-/** What a finger is on: a pile's card, a pile (its empty place or below its cards), or the deck. */
-type Hit = { kind: 'card'; pile: number; index: number } | { kind: 'pile'; pile: number } | { kind: 'stock' } | null;
-
-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: newBoard(),
-    /** The run picked up (tapped), or being dragged. */
-    held: null as Held,
-    /** A finger down: where, on what, and (once it's moved off) where it grabbed the dragged run. */
-    press: null as { x: number; y: number; hit: Hit; grab: [number, number] | null; dragging: boolean } | null,
-    /** Seconds since the start (the original game's elapsed clock), and the score a win reports: both in the engine (Rust). */
-    get time() {
-      return world.scoreboard.shownSeconds;
-    },
-    get score() {
-      return world.scoreboard.score;
-    },
-    won: false,
-    // UI hooks, set by the screen.
-    onPhase: (_p: Phase) => {},
-    onDeals: (_n: number) => {},
-    onCompleted: (_n: number) => {},
-    onEvent: (_e: GameEvent) => {}
-  };
-  world.scoreboard.reset();
-  return g;
-}
-export type Game = ReturnType<typeof createGame>;
-
-const allCards = (b: Board): Card[] => [...b.tableau.flat(), ...b.stock, ...b.completed.flat()];
-
-// ── Scene ─────────────────────────────────────────────────────────────
-
-/** Lays the table out for the view (first layout, header height, rotation); the first deal glides out of the deck. */
-export function setLayout(g: Game, l: Layout) {
-  const first = !g.scene;
-  if (g.scene) removeScene(g.world, g.scene);
-  g.layout = l;
-  aimTilted(g.camera, l);
-  g.scene = buildScene(g.world, l, g.theme, allCards(g.board));
-  if (first) draw(g, dealOrder(g.board));
-  else draw(g, () => 0, true);
-}
-
-export function setTheme(g: Game, theme: GameTheme) {
-  g.theme = theme;
-  if (g.scene) setSceneTheme(g.world, g.scene, theme);
-}
-
-function draw(g: Game, delay?: (id: string) => number, instant = false, onlyHeld = false) {
-  const { layout: l, scene: s } = g;
-  if (l && s) placeCards(g.world, l, s, layoutCards(l, g.board, g.held, onlyHeld), delay, instant);
-}
-
-/** A fresh deal's cards leave the deck one after another, round the piles as a dealer would. */
-function dealOrder(b: Board) {
-  const order = new Map<string, number>();
-  b.tableau.forEach((pile, col) => pile.forEach((c, i) => order.set(c.id, (i * PILES + col) * 0.018)));
-  return (id: string) => order.get(id) ?? 0;
-}
-
-function report(g: Game) {
-  g.onDeals(dealsLeft(g.board));
-  g.onCompleted(g.board.completed.length);
-}
-
-// ── Run ───────────────────────────────────────────────────────────────
-
-/** Starts play on the deal already on the table. */
-export function start(g: Game) {
-  if (g.phase !== 'ready') return;
-  g.phase = 'playing';
-  g.world.scoreboard.reset();
-  g.world.scoreboard.startClock();
-  g.won = false;
-  g.onPhase('playing');
-}
-
-/** A fresh shuffle dealt out, not started (Stop, Play Again). The world, and the GPU view drawing it, are kept. */
-export function reset(g: Game) {
-  g.world.cancelTimers();
-  g.board = newBoard();
-  g.held = null;
-  g.press = null;
-  g.world.scoreboard.reset();
-  g.won = false;
-  g.phase = 'ready';
-  draw(g, dealOrder(g.board));
-  report(g);
-  g.onPhase('ready');
-}
-
-export function dispose(g: Game) {
-  g.world.dispose();
-}
-
-export function tick(g: Game, dt: number) {
-  if (g.world.isDisposed) return;
-  g.world.update(dt);
-}
-
-const canPlay = (g: Game) => g.phase === 'playing' && !g.won;
-
-// ── The finger ────────────────────────────────────────────────────────
-
-/** What's under a view point: the top-most card there, a pile's column, or the deck. */
-export function hitAt(g: Game, sx: number, sy: number): Hit {
-  const l = g.layout;
-  if (!l) return null;
-  const b = g.board;
-  // The deck (or its empty place)
-  const small = l.card * SMALL;
-  const fan = Math.max(0, dealsLeft(b) - 1) * small * 0.22;
-  const [, deckTop] = project(l, 0, l.rowY + (l.cardH * SMALL) / 2, 2);
-  const [, deckBottom] = project(l, 0, l.rowY - (l.cardH * SMALL) / 2, 2);
-  const [deckLeft] = project(l, l.stockRight - small - fan, 0);
-  const [deckRight] = project(l, l.stockRight, 0);
-  if (sx >= deckLeft - 4 && sx <= deckRight + 4 && sy >= deckTop - 4 && sy <= deckBottom + 4) return { kind: 'stock' };
-  // A pile: the column under the finger, then the top-most of its cards there
-  const [wx] = unproject(l, sx, sy);
-  const col = l.columns.findIndex((x) => Math.abs(wx - x) <= l.pitch / 2);
-  if (col < 0) return null;
-  const pile = b.tableau[col]!;
-  const offsets = pileOffsets(l, pile);
-  for (let i = pile.length - 1; i >= 0; i--) {
-    const [, y, z] = pileSpot(l, col, offsets[i]!, i);
-    const [, top] = project(l, 0, y + l.cardH / 2, z);
-    const [, bottom] = project(l, 0, y - l.cardH / 2, z);
-    if (sy >= top && sy <= bottom) return { kind: 'card', pile: col, index: i };
-  }
-  const [, pileTop] = project(l, 0, l.pileTop, 0);
-  const [, pileBottom] = project(l, 0, l.pileBottom, 0);
-  return sy >= pileTop && sy <= pileBottom ? { kind: 'pile', pile: col } : null;
-}
-
-/** A quick tap does what it did in the original game; a finger that moves off a face-up run drags it. */
-export function drag(g: Game, e: DragEvent) {
-  const l = g.layout;
-  if (!l) return;
-  if (e.phase === 'start') {
-    g.press = { x: e.x, y: e.y, hit: canPlay(g) ? hitAt(g, e.x, e.y) : null, grab: null, dragging: false };
-    return;
-  }
-  const p = g.press;
-  if (!p) return;
-  if (!p.dragging && Math.hypot(e.x - p.x, e.y - p.y) > TAP_SLOP) {
-    if (!beginDrag(g, p)) {
-      g.press = null;
-      return;
-    }
-  }
-  if (p.dragging) {
-    const held = g.held;
-    if (!held || !canPlay(g)) {
-      g.press = null;
-      return;
-    }
-    const [wx, wy] = unproject(l, e.x, e.y, 40);
-    held.drag = { x: wx + p.grab![0], y: wy + p.grab![1] };
-    if (e.phase !== 'end') {
-      draw(g, undefined, true, true);
-      return;
-    }
-    g.press = null;
-    held.drag = null;
-    if (e.cancelled) return putBack(g);
-    // Dropped on the pile nearest the run's top card
-    const x = wx + p.grab![0];
-    let to = 0;
-    for (let i = 1; i < l.columns.length; i++) if (Math.abs(l.columns[i]! - x) < Math.abs(l.columns[to]! - x)) to = i;
-    if (to === held.pile || Math.abs(l.columns[to]! - x) > l.pitch) return putBack(g);
-    moveTo(g, to);
-    return;
-  }
-  if (e.phase !== 'end') return;
-  g.press = null;
-  tap(g, p.hit);
-}
-
-/** Picks up the run under a finger that's moved off it, if it can be picked up. */
-function beginDrag(g: Game, p: NonNullable<Game['press']>): boolean {
-  const l = g.layout!;
-  const hit = p.hit;
-  if (!canPlay(g) || !hit || hit.kind !== 'card') return false;
-  const run = pickable(g.board, hit.pile, hit.index);
-  if (!run) {
-    // A face-up card that doesn't head a run: as the original tap, "not allowed"
-    if (g.board.tableau[hit.pile]![hit.index]!.faceUp) {
-      if (g.scene)
-        shakeCards(
-          g.world,
-          g.scene,
-          g.board.tableau[hit.pile]!.slice(hit.index).map((c) => c.id)
-        );
-      g.onEvent('invalid');
-    }
-    return false;
-  }
-  const offsets = pileOffsets(l, g.board.tableau[hit.pile]!);
-  const [x, y] = pileSpot(l, hit.pile, offsets[hit.index]!, hit.index);
-  const [wx, wy] = unproject(l, p.x, p.y, 40);
-  p.grab = [x - wx, y - wy];
-  p.dragging = true;
-  const had = g.held;
-  g.held = { pile: hit.pile, index: hit.index, drag: { x, y } };
-  if (!had || had.pile !== hit.pile || had.index !== hit.index) g.onEvent('select');
-  // Clear any previously selected run once; subsequent moves lay out only the held cards.
-  draw(g, undefined, true);
-  return true;
-}
-
-/** A dragged run let go off any pile (or back on its own) settles back where it was. */
-function putBack(g: Game) {
-  g.held = null;
-  draw(g);
-}
-
-function tap(g: Game, hit: Hit) {
-  if (!canPlay(g) || !hit) return;
-  if (hit.kind === 'stock') return deal(g);
-  if (hit.kind === 'card') return select(g, hit.pile, hit.index);
-  // An empty pile (or the space below a pile's cards) takes the picked-up run
-  const held = g.held;
-  if (held && held.pile !== hit.pile) moveTo(g, hit.pile);
-}
-
-// ── Moves (the original store's, step for step) ───────────────────────────
-
-/** A card tapped: put back the run if it's the one picked up, move the picked-up run here, or pick up from here. */
-export function select(g: Game, pile: number, index: number) {
-  if (!canPlay(g)) return;
-  const held = g.held;
-  if (held && held.pile === pile && held.index === index) {
-    g.held = null;
-    draw(g);
-    g.onEvent('deselect');
-    return;
-  }
-  if (held && held.pile !== pile) return moveTo(g, pile);
-  if (held) g.held = null;
-  const card = g.board.tableau[pile]?.[index];
-  if (!card || !card.faceUp) return draw(g);
-  if (!pickable(g.board, pile, index)) {
-    draw(g);
-    if (g.scene)
-      shakeCards(
-        g.world,
-        g.scene,
-        g.board.tableau[pile]!.slice(index).map((c) => c.id)
-      );
-    g.onEvent('invalid');
-    return;
-  }
-  g.held = { pile, index, drag: null };
-  draw(g);
-  g.onEvent('select');
-}
-
-/** Puts the picked-up run on a pile, if it may go there. */
-export function moveTo(g: Game, to: number) {
-  const held = g.held;
-  if (!held) return;
-  g.held = null;
-  if (held.pile === to) return draw(g);
-  const run = g.board.tableau[held.pile]!.slice(held.index);
-  if (!canMove(g.board, run, to)) {
-    draw(g);
-    if (g.scene)
-      shakeCards(
-        g.world,
-        g.scene,
-        run.map((c) => c.id)
-      );
-    g.onEvent('invalid');
-    return;
-  }
-  moveRun(g.board, held.pile, held.index, to);
-  const done = checkRun(g, to, MOVE_TIME);
-  draw(g, done);
-  report(g);
-  g.onEvent('place');
-}
-
-/** One card onto every pile from the deck (not while a pile is empty). */
-export function deal(g: Game) {
-  if (!canPlay(g)) return;
-  if (dealBlocked(g.board)) {
-    g.onEvent('invalid');
-    return;
-  }
-  const dealt = g.board.stock.slice(-PILES).reverse();
-  dealRow(g.board);
-  g.held = null;
-  const delays = new Map<string, number>(dealt.map((c, i) => [c.id, i * DEAL_STAGGER]));
-  const runs: ((id: string) => number)[] = [];
-  for (let i = 0; i < PILES; i++) runs.push(checkRun(g, i, MOVE_TIME + PILES * DEAL_STAGGER));
-  draw(g, (id) => delays.get(id) ?? Math.max(0, ...runs.map((r) => r(id))));
-  report(g);
-  g.onEvent('deal');
-}
-
-/**
- * Lifts a finished run off a pile, if there is one: it flies home Ace first, after `after` seconds (the
- * move that made it lands first). Returns each of its cards' delay; the eighth wins.
- */
-function checkRun(g: Game, pile: number, after: number): (id: string) => number {
-  const offsets = g.layout ? pileOffsets(g.layout, g.board.tableau[pile]!) : [];
-  const run = takeCompletedRun(g.board, pile);
-  if (!run) return () => 0;
-  const l = g.layout;
-  if (l) {
-    const i = g.board.tableau[pile]!.length;
-    const [x, y] = pileSpot(l, pile, offsets[Math.min(i, offsets.length - 1)] ?? 0, i);
-    g.world.after(after, () => sparkle(g.world, l, x, y - l.cardH * 0.5));
-  }
-  g.onEvent('complete');
-  if (g.board.completed.length >= RUNS_TO_WIN) win(g);
-  const delays = new Map<string, number>(run.map((c, j) => [c.id, after + (12 - j) * RUN_STAGGER]));
-  return (id) => delays.get(id) ?? 0;
-}
-
-function win(g: Game) {
-  g.won = true;
-  g.world.scoreboard.stop();
-  g.world.scoreboard.set(calculateTimeBasedScore(g.time, EXPECTED_TIME, BASE_SCORE));
-  g.onEvent('win');
-  g.world.after(WIN_DELAY, () => {
-    if (g.layout) celebrate(g.world, g.layout);
-    g.phase = 'over';
-    g.onPhase('over');
-  });
-}

package/src/games/spider-solitaire/SpiderSolitaireRules.ts

@@ -1,123 +0,0 @@
-// Spider Solitaire's rules, with no React or engine: the deal, which runs may be picked up, where they
-// may go, dealing a row from the stock and lifting out a finished King-to-Ace run. Ported from the
-// original store (games/spider-solitaire), so a deal and every move play out as they did.
-
-export const SUITS = ['hearts', 'diamonds', 'clubs', 'spades'] as const;
-export const VALUES = ['A', '2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K'] as const;
-export type Suit = (typeof SUITS)[number];
-export type Value = (typeof VALUES)[number];
-
-export type Card = { id: string; suit: Suit; value: Value; faceUp: boolean };
-/** The 10 piles, the stock (dealt from its end) and the runs lifted out so far (each K first). */
-export type Board = { tableau: Card[][]; stock: Card[]; completed: Card[][] };
-
-export const PILES = 10;
-export const RUNS_TO_WIN = 8;
-/** As the original game: always two suits. */
-export const SUIT_COUNT = 2;
-
-const RANK: Record<Value, number> = { 'A': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9, '10': 10, 'J': 11, 'Q': 12, 'K': 13 };
-export const rank = (v: Value) => RANK[v];
-
-/** Two decks' worth: enough of each suit in play to make eight runs. */
-function createDeck(suitCount: number): Card[] {
-  const deck: Card[] = [];
-  const suits = SUITS.slice(0, suitCount);
-  let id = 0;
-  for (let d = 0; d < Math.ceil(8 / suitCount); d++)
-    for (const suit of suits) for (const value of VALUES) deck.push({ id: `${suit}-${value}-${id++}`, suit, value, faceUp: false });
-  return deck.slice(0, 104);
-}
-
-function shuffle(deck: Card[]): Card[] {
-  const out = [...deck];
-  for (let i = out.length - 1; i > 0; i--) {
-    const j = Math.floor(Math.random() * (i + 1));
-    [out[i], out[j]] = [out[j]!, out[i]!];
-  }
-  return out;
-}
-
-/** A fresh deal: six cards in each of the first four piles, five in the rest, only the top ones face up; 50 left to deal. */
-export function newBoard(): Board {
-  const deck = shuffle(createDeck(SUIT_COUNT));
-  const tableau: Card[][] = [];
-  let k = 0;
-  for (let i = 0; i < PILES; i++) {
-    const n = i < 4 ? 6 : 5;
-    const pile: Card[] = [];
-    for (let j = 0; j < n; j++) pile.push({ ...deck[k++]!, faceUp: j === n - 1 });
-    tableau.push(pile);
-  }
-  return { tableau, stock: deck.slice(k).map((c) => ({ ...c, faceUp: false })), completed: [] };
-}
-
-/** Descending by one all the way down (any suit), so it can be picked up together. */
-export function isValidSequence(cards: Card[]): boolean {
-  if (!cards.length) return false;
-  for (let i = 0; i < cards.length - 1; i++) if (rank(cards[i]!.value) !== rank(cards[i + 1]!.value) + 1) return false;
-  return true;
-}
-
-/** Whether a run can go on a pile: anything on an empty one, else one rank below its face-up top card. */
-export function canMove(b: Board, cards: Card[], to: number): boolean {
-  const pile = b.tableau[to];
-  const first = cards[0];
-  if (!pile || !first) return false;
-  const top = pile[pile.length - 1];
-  if (!top) return true;
-  return top.faceUp && rank(first.value) === rank(top.value) - 1;
-}
-
-/** The run from `index` down, if it may be picked up (a single face-up card always may). */
-export function pickable(b: Board, pile: number, index: number): Card[] | null {
-  const p = b.tableau[pile];
-  const card = p?.[index];
-  if (!p || !card || !card.faceUp) return null;
-  const run = p.slice(index);
-  return run.length === 1 || isValidSequence(run) ? run : null;
-}
-
-const flipTop = (pile: Card[]) => {
-  const top = pile[pile.length - 1];
-  if (top && !top.faceUp) top.faceUp = true;
-};
-
-/** Moves the run from `from` at `index` onto `to` (already checked), turning up the card it uncovers. */
-export function moveRun(b: Board, from: number, index: number, to: number) {
-  const src = b.tableau[from]!;
-  const run = src.splice(index);
-  flipTop(src);
-  b.tableau[to]!.push(...run.map((c) => ({ ...c, faceUp: true })));
-}
-
-/** Why a row can't be dealt (an empty pile, or nothing left), or null if it can. */
-export const dealBlocked = (b: Board): 'empty-pile' | 'no-stock' | null =>
-  b.tableau.some((p) => p.length === 0) ? 'empty-pile' : b.stock.length === 0 ? 'no-stock' : null;
-
-/** One card face up onto every pile, from the stock's end. */
-export function dealRow(b: Board) {
-  for (let i = 0; i < PILES && b.stock.length > 0; i++) {
-    const card = b.stock.pop()!;
-    card.faceUp = true;
-    b.tableau[i]!.push(card);
-  }
-}
-
-const RUN: Value[] = ['K', 'Q', 'J', '10', '9', '8', '7', '6', '5', '4', '3', '2', 'A'];
-
-/** Lifts a finished King-to-Ace run of one suit off the end of a pile, if there is one; returns it. */
-export function takeCompletedRun(b: Board, pile: number): Card[] | null {
-  const p = b.tableau[pile];
-  if (!p || p.length < 13) return null;
-  const last = p.slice(-13);
-  const suit = last[0]!.suit;
-  if (!last.every((c, i) => c.suit === suit && c.value === RUN[i])) return null;
-  p.splice(-13);
-  flipTop(p);
-  b.completed.push(last);
-  return last;
-}
-
-/** Deals left (each a row of 10). */
-export const dealsLeft = (b: Board) => Math.ceil(b.stock.length / PILES);