@nayan-ui/games 1.20.0 → 1.21.0

package/src/games/reversi/ReversiConstants.ts

@@ -1,67 +0,0 @@
-// Reversi's scores, timings, colors and layout. Rules and scores match the original version
-// (games/reversi), so scores carry over.
-import { getScoreBoardTop } from '../shared/EngineHud';
-import type { TiltView } from '../shared/EngineTilt';
-import { frontLight, gameWidthFor } from '../shared/EngineUtils';
-
-// ── Rules and timing ──────────────────────────────────────────────────
-
-export const GAME_DURATION = 300; // seconds; running out loses
-export const POINTS_PER_FLIP = 200;
-export const WIN_BONUS = 5000;
-export const AI_DELAY = 0.5; // the robot "thinks" this long
-export const TAP_SLOP = 12; // points a finger may wander and still tap
-
-// A move's captures turn over one ring at a time, outward from the placed disc
-export const FLIP_TIME = 0.24;
-export const RIPPLE = 0.07;
-export const PLACE_LEAD = 0.09; // the placed disc lands before its captures start turning
-
-// ── Colors ────────────────────────────────────────────────────────────
-
-export const COLORS = {
-  // Flat felt, grid and star points stay green in every theme.
-  FELT: '#1F7A46',
-  BOARD_BORDER: '#0F3D24',
-  GRID: '#155a33',
-  STAR: '#0d3b21',
-  HINT: 'rgba(255,255,255,0.75)',
-  LAST_MOVE: 'rgba(255,213,79,0.9)',
-  BLACK: '#2A2A2A',
-  WHITE: '#F2F2F2'
-} as const;
-
-// ── The scene ─────────────────────────────────────────────────────────
-
-/** Directly overhead, like Checkers: a flat board with only the discs raised in 3D. */
-export const TILT = 0;
-export const BOARD_BORDER_WIDTH = 3;
-export const BOARD_SURFACE = 0.2;
-/** 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);
-
-// ── Layout (view points) ──────────────────────────────────────────────
-
-const SCOREBOARD_HEIGHT = 82;
-const CONTROLS_HEIGHT = 120;
-
-export type Layout = TiltView & { cell: number; size: number };
-
-/** Use Checkers' centered board sizing, reserving space for the thin outer border. */
-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 cell's centre (row 0 along the top), in world units. */
-export const cellCentre = (l: Layout, index: number): [number, number] => [((index % 8) - 3.5) * l.cell, (3.5 - Math.floor(index / 8)) * l.cell];
-
-/** The cell under a board point, or -1. */
-export function cellAt(l: Layout, x: number, y: number): number {
-  const col = Math.floor((x + l.size / 2) / l.cell);
-  const row = Math.floor((l.size / 2 - y) / l.cell);
-  return col < 0 || col > 7 || row < 0 || row > 7 ? -1 : row * 8 + col;
-}

package/src/games/reversi/ReversiGame.ts

@@ -1,266 +0,0 @@
-// Reversi's play, with no React: build a game with `createGame`, give it a layout, `start` it and
-// `tick` it every frame. You play black and go first: tap a ringed cell to place a disc, turning over
-// every white line it outflanks (200 points a disc). The robot (white) answers half a second later. A
-// side with no move passes; when neither can move, the most discs wins (5,000 bonus). Five minutes,
-// then the robot wins.
-//
-// The rules and the robot are the original store's (ReversiRules.ts), turn for turn; 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_DELAY, BOARD_SURFACE, cellAt, GAME_DURATION, type Layout, POINTS_PER_FLIP, TAP_SLOP, WIN_BONUS } from './ReversiConstants';
-import { AI, applyMove, chooseAIMove, counts, flipsFor, HUMAN, initialBoard, type Move, opponent, type Player, validMoves } from './ReversiRules';
-import { buildScene, celebrate, flipDiscs, nudge, placeDisc, removeScene, type Scene, setSceneTheme, showHints, showLast } from './ReversiScene';
-
-export type Phase = 'ready' | 'playing' | 'over';
-/** place / robot: a disc down; invalid: a tap off the legal moves; pass: a side couldn't move; win / lose: how it ended (a timeout is silent). */
-export type GameEvent = 'place' | 'robot' | 'invalid' | 'pass' | 'win' | 'lose';
-
-const WORLD_CAPACITY = 300; // the board, felt and grid, 64 discs, the rings, and the confetti
-
-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 board = initialBoard();
-  const g = {
-    world,
-    camera,
-    theme,
-    layout: null as Layout | null,
-    scene: null as Scene | null,
-    phase: 'ready' as Phase,
-    board,
-    turn: HUMAN as Player,
-    /** Your legal moves (shown as rings; none on the robot's turn). */
-    hints: validMoves(board, HUMAN).map((m) => m.index),
-    last: -1,
-    winner: null as Player | null,
-    timedOut: false,
-    black: 2,
-    white: 2,
-    /** Score and the countdown live in the engine (Rust), advanced by world.update. */
-    get score() {
-      return world.scoreboard.score;
-    },
-    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) => {},
-    onCounts: (_black: number, _white: number) => {},
-    onTurn: (_p: Player) => {},
-    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, g.hints, g.last);
-}
-
-export function setTheme(g: Game, theme: GameTheme) {
-  g.theme = theme;
-  if (g.scene) setSceneTheme(g.world, g.scene, theme);
-}
-
-const setHints = (g: Game, hints: number[]) => {
-  g.hints = hints;
-  if (g.layout && g.scene) showHints(g.world, g.layout, g.scene, hints);
-};
-
-// ── Run ───────────────────────────────────────────────────────────────
-
-/** The opening four discs, your move, nothing on the clock yet. */
-function fresh(g: Game) {
-  g.world.cancelTimers();
-  g.board = initialBoard();
-  g.turn = HUMAN;
-  g.last = -1;
-  g.winner = null;
-  g.timedOut = false;
-  g.black = 2;
-  g.white = 2;
-  g.world.scoreboard.reset(0, GAME_DURATION);
-  g.press = null;
-  if (g.layout) setLayout(g, g.layout);
-  setHints(
-    g,
-    validMoves(g.board, HUMAN).map((m) => m.index)
-  );
-  g.onScore(0);
-  g.onCounts(2, 2);
-  g.onTurn(HUMAN);
-  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');
-}
-
-/** The opening 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;
-  g.world.update(dt);
-}
-
-function end(g: Game) {
-  g.world.cancelTimers();
-  g.world.scoreboard.stop();
-  g.press = null;
-  setHints(g, []);
-  g.phase = 'over';
-  if (g.winner === HUMAN && g.layout && g.scene) celebrate(g.world, g.layout, g.scene, g.board);
-  g.onPhase('over');
-}
-
-// ── Moves (the original store's, step for step) ───────────────────────────
-
-/** A disc down for `who`: its captures turn over, the count and (for you) the score go up. */
-function play(g: Game, m: Move, who: Player) {
-  g.board = applyMove(g.board, m, who);
-  const c = counts(g.board);
-  g.black = c.black;
-  g.white = c.white;
-  if (who === HUMAN) g.world.scoreboard.add(m.flips.length * POINTS_PER_FLIP);
-  g.last = m.index;
-  g.turn = opponent(who);
-  const { layout: l, scene: s } = g;
-  if (l && s) {
-    placeDisc(g.world, l, s, m.index, who);
-    flipDiscs(g.world, l, s, m.index, m.flips, who);
-    showLast(g.world, l, s, m.index);
-  }
-  setHints(g, []);
-  g.onCounts(c.black, c.white);
-  if (who === HUMAN) g.onScore(g.score);
-  g.onEvent(who === HUMAN ? 'place' : 'robot');
-  resolveTurn(g);
-}
-
-/** Your move on a cell: a legal one is played, anything else just buzzes. */
-export function select(g: Game, index: number) {
-  if (g.phase !== 'playing' || g.turn !== HUMAN) return;
-  const flips = flipsFor(g.board, index, HUMAN);
-  if (flips.length === 0) {
-    if (g.layout && g.scene) nudge(g.world, g.layout, g.scene, index);
-    g.onEvent('invalid');
-    return;
-  }
-  play(g, { index, flips }, HUMAN);
-}
-
-function robotMove(g: Game) {
-  if (g.phase !== 'playing' || g.turn !== AI) return;
-  const m = chooseAIMove(g.board);
-  if (!m) {
-    g.turn = HUMAN;
-    g.onTurn(HUMAN);
-    resolveTurn(g);
-    return;
-  }
-  play(g, m, AI);
-}
-
-/** Whose turn it is now: their moves (yours as rings, the robot's after its think), a forced pass, or the end. */
-function resolveTurn(g: Game) {
-  if (g.phase !== 'playing') return;
-  const player = g.turn;
-  const moves = validMoves(g.board, player);
-  if (moves.length > 0) {
-    g.onTurn(player);
-    if (player === HUMAN)
-      setHints(
-        g,
-        moves.map((m) => m.index)
-      );
-    else {
-      setHints(g, []);
-      g.world.cancelTimers();
-      g.world.after(AI_DELAY, () => robotMove(g));
-    }
-    return;
-  }
-  const opp = opponent(player);
-  if (validMoves(g.board, opp).length === 0) return finishByCount(g);
-  g.turn = opp;
-  setHints(g, []);
-  g.onEvent('pass');
-  resolveTurn(g);
-}
-
-function finishByCount(g: Game) {
-  const c = counts(g.board);
-  g.black = c.black;
-  g.white = c.white;
-  g.winner = c.black > c.white ? HUMAN : c.white > c.black ? AI : null;
-  if (g.winner === HUMAN) {
-    g.onScore(g.world.scoreboard.add(WIN_BONUS));
-  }
-  g.onCounts(c.black, c.white);
-  g.onEvent(g.winner === HUMAN ? 'win' : 'lose');
-  end(g);
-}
-
-// ── The finger ────────────────────────────────────────────────────────
-
-/** The cell under a view point (on the felt), or -1. */
-export function cellUnder(g: Game, x: number, y: number): number {
-  const l = g.layout;
-  if (!l) return -1;
-  const [wx, wy] = unproject(l, x, y, BOARD_SURFACE);
-  return cellAt(l, wx, wy);
-}
-
-/** A tap (a finger down and up without wandering) on a cell. */
-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 = cellUnder(g, x, y);
-  if (i >= 0) select(g, i);
-}

package/src/games/reversi/ReversiRules.ts

@@ -1,176 +0,0 @@
-// Reversi's rules and robot, with no React or engine: legal moves and the discs they flip, playing a
-// move, the count, and the robot's choice (a shallow alpha-beta search over a positional table, with
-// the odd random move and a random pick among near-best moves). Ported as they were from the original
-// store (games/reversi), with the same random draws in the same order.
-
-export const N = 8;
-export type Player = 'black' | 'white';
-export type Board = (Player | null)[]; // 64, index = row * 8 + col
-export type Move = { index: number; flips: number[] };
-
-/** You play black and move first; the robot plays white. */
-export const HUMAN: Player = 'black';
-export const AI: Player = 'white';
-export const opponent = (p: Player): Player => (p === 'black' ? 'white' : 'black');
-
-const AI_DEPTH = 2;
-const AI_RANDOM_MOVE_CHANCE = 0.2;
-const AI_SCORE_MARGIN = 12;
-
-const DIRECTIONS = [
-  [-1, -1],
-  [-1, 0],
-  [-1, 1],
-  [0, -1],
-  [0, 1],
-  [1, -1],
-  [1, 0],
-  [1, 1]
-] as const;
-
-// Corners strong, X and C squares risky
-const WEIGHTS = [
-  120, -20, 20, 5, 5, 20, -20, 120, -20, -40, -5, -5, -5, -5, -40, -20, 20, -5, 15, 3, 3, 15, -5, 20, 5, -5, 3, 3, 3, 3, -5, 5, 5, -5, 3, 3, 3, 3, -5,
-  5, 20, -5, 15, 3, 3, 15, -5, 20, -20, -40, -5, -5, -5, -5, -40, -20, 120, -20, 20, 5, 5, 20, -20, 120
-];
-
-const inBounds = (r: number, c: number) => r >= 0 && r < N && c >= 0 && c < N;
-
-export function initialBoard(): Board {
-  const b: Board = new Array(N * N).fill(null);
-  b[27] = 'white';
-  b[28] = 'black';
-  b[35] = 'black';
-  b[36] = 'white';
-  return b;
-}
-
-/** The discs a move at `index` would flip (none: not a legal move). */
-export function flipsFor(b: Board, index: number, player: Player): number[] {
-  if (b[index] !== null) return [];
-  const row = Math.floor(index / N);
-  const col = index % N;
-  const opp = opponent(player);
-  const flips: number[] = [];
-  for (const [dr, dc] of DIRECTIONS) {
-    let r = row + dr;
-    let c = col + dc;
-    const start = flips.length;
-    while (inBounds(r, c) && b[r * N + c] === opp) {
-      flips.push(r * N + c);
-      r += dr;
-      c += dc;
-    }
-    if (!inBounds(r, c) || b[r * N + c] !== player) flips.length = start;
-  }
-  return flips;
-}
-
-export function validMoves(b: Board, player: Player): Move[] {
-  const moves: Move[] = [];
-  for (let i = 0; i < b.length; i++) {
-    if (b[i] !== null) continue;
-    const flips = flipsFor(b, i, player);
-    if (flips.length > 0) moves.push({ index: i, flips });
-  }
-  return moves;
-}
-
-export function applyMove(b: Board, m: Move, player: Player): Board {
-  const nb = b.slice();
-  nb[m.index] = player;
-  for (const f of m.flips) nb[f] = player;
-  return nb;
-}
-
-export function counts(b: Board) {
-  let black = 0;
-  let white = 0;
-  for (const c of b) {
-    if (c === 'black') black++;
-    else if (c === 'white') white++;
-  }
-  return { black, white };
-}
-
-// ── The robot ─────────────────────────────────────────────────────────
-
-function evaluate(b: Board): number {
-  let score = 0;
-  for (let i = 0; i < b.length; i++) {
-    const c = b[i];
-    if (!c) continue;
-    score += c === AI ? WEIGHTS[i]! : -WEIGHTS[i]!;
-  }
-  return score + (mobility(b, AI) - mobility(b, HUMAN)) * 5;
-}
-
-/** Leaf evaluation needs only a count, not move objects and eight temporary flip lists per square. */
-function mobility(b: Board, player: Player): number {
-  const opp = opponent(player);
-  let count = 0;
-  for (let i = 0; i < b.length; i++) {
-    if (b[i] !== null) continue;
-    const row = Math.floor(i / N),
-      col = i % N;
-    for (const [dr, dc] of DIRECTIONS) {
-      let r = row + dr,
-        c = col + dc,
-        crossed = false;
-      while (inBounds(r, c) && b[r * N + c] === opp) {
-        crossed = true;
-        r += dr;
-        c += dc;
-      }
-      if (crossed && inBounds(r, c) && b[r * N + c] === player) {
-        count++;
-        break;
-      }
-    }
-  }
-  return count;
-}
-
-function search(b: Board, player: Player, depth: number, alpha: number, beta: number): number {
-  if (depth === 0) return evaluate(b);
-  const moves = validMoves(b, player);
-  if (moves.length === 0) {
-    if (validMoves(b, opponent(player)).length === 0) return evaluate(b);
-    return search(b, opponent(player), depth - 1, alpha, beta);
-  }
-  if (player === AI) {
-    let best = -Infinity;
-    for (const m of moves) {
-      const v = search(applyMove(b, m, player), opponent(player), depth - 1, alpha, beta);
-      if (v > best) best = v;
-      if (best > alpha) alpha = best;
-      if (beta <= alpha) break;
-    }
-    return best;
-  }
-  let best = Infinity;
-  for (const m of moves) {
-    const v = search(applyMove(b, m, player), opponent(player), depth - 1, alpha, beta);
-    if (v < best) best = v;
-    if (best < beta) beta = best;
-    if (beta <= alpha) break;
-  }
-  return best;
-}
-
-/** The robot's move: now and then a random one, otherwise a random pick among those near the best. */
-export function chooseAIMove(b: Board): Move | null {
-  const moves = validMoves(b, AI);
-  if (moves.length === 0) return null;
-  if (moves.length === 1) return moves[0]!;
-  if (Math.random() < AI_RANDOM_MOVE_CHANCE) return moves[Math.floor(Math.random() * moves.length)]!;
-  let bestScore = -Infinity;
-  const scored: { move: Move; score: number }[] = [];
-  for (const m of moves) {
-    const score = search(applyMove(b, m, AI), HUMAN, AI_DEPTH - 1, -Infinity, Infinity);
-    scored.push({ move: m, score });
-    if (score > bestScore) bestScore = score;
-  }
-  const good = scored.filter((s) => s.score >= bestScore - AI_SCORE_MARGIN);
-  return good[Math.floor(Math.random() * good.length)]!.move;
-}