@nayan-ui/games 1.20.0 → 1.21.0

package/src/games/snakes-and-ladders/SnakesAndLaddersGame.ts

@@ -1,310 +0,0 @@
-// Snakes and Ladders' rules, with no React: build a game with `createGame`, give it a layout, `start` it
-// and `tick` it every frame. You (blue) and the AI (red) take turns rolling the die and moving that many
-// cells; landing on a snake's head slides you down to its tail, on a ladder's foot climbs you to its
-// top. You must land on 100 exactly; a six rolls again, three sixes in a row lose the turn. First to
-// 100 wins.
-//
-// Every step of a turn (the roll, each hop, a slide, the next turn) waits on the game's own clock,
-// advanced by `tick`: a reset simply drops what's pending, nothing can run into the next game, and it
-// all pauses with the view.
-import { type Camera, type Vec3, World } from '@nayan-ui/engine';
-import type { GameTheme } from '../../services/ThemeService';
-import {
-  AI_DELAY,
-  CANT_MOVE_DELAY,
-  cellCenter,
-  DIE_SIZE,
-  DIE_Y,
-  HOP_TIME,
-  landing,
-  type Layout,
-  MAX_SIXES,
-  MOVE_DELAY,
-  NEXT_TURN_DELAY,
-  PENALTY_DELAY,
-  ROLL_TIME,
-  scoreFor,
-  SLIDE_PAUSE,
-  SNAKE_AT,
-  START_X,
-  START_Z,
-  TILE_TOP,
-  toView,
-  WINNING_POSITION
-} from './SnakesAndLaddersConstants';
-import {
-  aimCamera,
-  bobToken,
-  buildScene,
-  confetti,
-  moveToken,
-  placeToken,
-  removeScene,
-  rollDie,
-  type Scene,
-  setSceneTheme,
-  showRollHint,
-  slidePath,
-  snakeBite,
-  sparkle
-} from './SnakesAndLaddersScene';
-
-export type Phase = 'ready' | 'playing' | 'over';
-/** 0 is you, 1 the AI. */
-export type Turn = 0 | 1;
-export type GameEvent = 'tap' | 'roll' | 'six' | 'penalty' | 'cantMove' | 'move' | 'snake' | 'ladder';
-
-const WORLD_CAPACITY = 600; // the board's 192 digits, pawns, die, shadows, backdrop, and bursts
-const MAX_STEP = 0.1; // a long frame (a hitch, coming back from the background) never skips a turn's steps
-const SLIDE_LIFT = 0.012; // a pawn rides on top of a snake or ladder, not through it
-const HOP_HEIGHT = 0.035;
-
-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,
-    /** Each player's cell: 0 before the first move. */
-    positions: [0, 0] as [number, number],
-    turn: 0 as Turn,
-    /** Sixes in a row this turn. */
-    sixes: 0,
-    /** A roll is in play (rolling, moving, or the AI thinking). */
-    busy: false,
-    /** The die is rolling or a pawn moving. */
-    rolling: false,
-    /** The score lives in the engine (Rust). */
-    get score() {
-      return world.scoreboard.score;
-    },
-    won: false,
-    // UI hooks, set by the screen.
-    onPhase: (_p: Phase) => {},
-    onPositions: (_you: number, _ai: number) => {},
-    onScore: (_s: number) => {},
-    onTurn: (_t: Turn) => {},
-    onEvent: (_e: GameEvent, _who: Turn) => {}
-  };
-  world.scoreboard.reset();
-  return g;
-}
-export type Game = ReturnType<typeof createGame>;
-
-/** Runs `run` `seconds` from now on the game's clock. */
-function after(g: Game, seconds: number, run: () => void) {
-  g.world.after(seconds, run);
-}
-
-// ── Scene ─────────────────────────────────────────────────────────────
-
-/** Lays the scene out for the view (first layout, header height, rotation): rebuilt from the game's state. */
-export function setLayout(g: Game, l: Layout) {
-  if (g.scene) removeScene(g.world, g.scene);
-  g.layout = l;
-  aimCamera(g.camera, l);
-  g.scene = buildScene(g.world, l, g.theme);
-  arrange(g, false);
-  idle(g);
-}
-
-/** A new theme repaints the backdrop; the board keeps its classic colors, as the original board did. */
-export function setTheme(g: Game, theme: GameTheme) {
-  g.theme = theme;
-  if (g.scene) setSceneTheme(g.world, g.scene, theme);
-}
-
-/** Where a player's pawn stands on a cell (or the start pad), side by side when they share one. */
-function spot(g: Game, who: Turn, cell: number): Vec3 {
-  const side = who === 0 ? -1 : 1;
-  if (cell === 0) return [START_X + side * 0.03, DIE_Y, START_Z];
-  const [x, y] = cellCenter(cell);
-  const shared = g.positions[1 - who] === cell;
-  return [x + (shared ? side * 0.022 : 0), y, TILE_TOP];
-}
-
-/** Puts both pawns in their places (sliding over when one moves into the other's cell). */
-function arrange(g: Game, animate: boolean) {
-  const { layout: l, scene: s } = g;
-  if (!l || !s) return;
-  for (const who of [0, 1] as const) {
-    const at = spot(g, who, g.positions[who]);
-    if (animate) moveToken(g.world, l, s, who, [at, at], 0.15);
-    else placeToken(g.world, l, s, who, at);
-  }
-}
-
-/** Waiting for a roll: the player's turn shows the gold ring under the die; the pawn to move bobs. */
-function idle(g: Game) {
-  const { layout: l, scene: s } = g;
-  if (!l || !s) return;
-  const playing = g.phase === 'playing';
-  showRollHint(g.world, l, s, playing && !g.busy && g.turn === 0);
-  bobToken(g.world, l, s, playing && !g.rolling ? g.turn : null);
-}
-
-// ── Run ───────────────────────────────────────────────────────────────
-
-export function start(g: Game) {
-  if (g.phase !== 'ready') return;
-  g.phase = 'playing';
-  g.onPhase('playing');
-  idle(g);
-}
-
-/** A fresh game (Stop, Play Again). The world, and the GPU view drawing it, are kept. */
-export function reset(g: Game) {
-  g.world.cancelTimers();
-  g.positions = [0, 0];
-  g.turn = 0;
-  g.sixes = 0;
-  g.busy = false;
-  g.rolling = false;
-  g.world.scoreboard.reset();
-  g.won = false;
-  g.phase = 'ready';
-  arrange(g, false);
-  idle(g);
-  g.onPositions(0, 0);
-  g.onScore(0);
-  g.onTurn(0);
-  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(Math.min(dt, MAX_STEP));
-}
-
-/** Whether a tap at a view point should roll: the player's turn, nothing moving, the finger on the die. */
-export function tap(g: Game, x: number, y: number) {
-  const l = g.layout;
-  if (!l || g.phase !== 'playing' || g.busy || g.turn !== 0) return;
-  const [dx, dy] = toView(l, 0, DIE_Y, DIE_SIZE / 2);
-  const reach = DIE_SIZE * l.size;
-  if ((x - dx) ** 2 + (y - dy) ** 2 > reach * reach) return;
-  g.onEvent('tap', 0);
-  roll(g);
-}
-
-// ── A turn ────────────────────────────────────────────────────────────
-
-function roll(g: Game) {
-  const { layout: l, scene: s } = g;
-  if (!l || !s) return;
-  g.busy = true;
-  g.rolling = true;
-  idle(g);
-  const value = 1 + Math.floor(Math.random() * 6);
-  g.onEvent('roll', g.turn);
-  rollDie(g.world, l, s, value, ROLL_TIME, () => g.world.isDisposed);
-  after(g, ROLL_TIME, () => rolled(g, value));
-}
-
-function rolled(g: Game, value: number) {
-  const who = g.turn;
-  g.sixes = value === 6 ? g.sixes + 1 : 0;
-  if (g.sixes >= MAX_SIXES) {
-    g.onEvent('penalty', who);
-    after(g, PENALTY_DELAY, () => nextTurn(g, false));
-    return;
-  }
-  if (landing(g.positions[who], value).step === g.positions[who]) {
-    g.onEvent('cantMove', who);
-    after(g, CANT_MOVE_DELAY, () => nextTurn(g, false));
-    return;
-  }
-  if (value === 6) g.onEvent('six', who);
-  after(g, MOVE_DELAY, () => move(g, value));
-}
-
-function move(g: Game, value: number) {
-  const who = g.turn;
-  const from = g.positions[who];
-  const { step, end } = landing(from, value);
-  // Past 100: stay put, and the turn passes
-  if (step === from) {
-    g.onEvent('cantMove', who);
-    after(g, CANT_MOVE_DELAY, () => nextTurn(g, false));
-    return;
-  }
-  g.onEvent('move', who);
-  for (let i = 1; i <= step - from; i++) {
-    after(g, (i - 1) * HOP_TIME, () => {
-      const { layout: l, scene: s } = g;
-      if (l && s) moveToken(g.world, l, s, who, [spot(g, who, from + i - 1), spot(g, who, from + i)], HOP_TIME * 0.95, HOP_HEIGHT);
-    });
-  }
-  after(g, (step - from) * HOP_TIME, () => {
-    setPosition(g, who, step);
-    if (end === step) arrive(g, value);
-    else after(g, SLIDE_PAUSE, () => slide(g, step, end, value));
-  });
-}
-
-/** Down a snake or up a ladder, along its body. */
-function slide(g: Game, from: number, to: number, value: number) {
-  const { layout: l, scene: s } = g;
-  const who = g.turn;
-  const snake = SNAKE_AT.has(from);
-  g.onEvent(snake ? 'snake' : 'ladder', who);
-  const path = (slidePath(from) ?? []).map(([x, y, z]): Vec3 => [x, y, z + SLIDE_LIFT]);
-  const target = spot(g, who, to);
-  const [ax, ay] = cellCenter(from);
-  const [bx, by] = cellCenter(to);
-  const time = (snake ? 0.55 : 0.35) + Math.hypot(bx - ax, by - ay) * (snake ? 1.4 : 1);
-  if (l && s) {
-    if (snake) snakeBite(g.world, l, s, g.camera, who);
-    moveToken(g.world, l, s, who, [spot(g, who, from), ...path, target], time);
-  }
-  after(g, time, () => {
-    setPosition(g, who, to);
-    if (!snake && g.layout) sparkle(g.world, g.layout, target);
-    arrive(g, value);
-  });
-}
-
-function setPosition(g: Game, who: Turn, cell: number) {
-  g.positions[who] = cell;
-  arrange(g, true);
-  g.onPositions(g.positions[0], g.positions[1]);
-}
-
-/** The move is done: score it, then a win, another roll on a six, or the other player's turn. */
-function arrive(g: Game, value: number) {
-  g.world.scoreboard.set(scoreFor(g.positions[0], g.positions[1]));
-  g.onScore(g.score);
-  const who = g.turn;
-  if (g.positions[who] === WINNING_POSITION) {
-    g.won = who === 0;
-    g.phase = 'over';
-    g.busy = false;
-    g.rolling = false;
-    if (g.layout) confetti(g.world, g.layout, spot(g, who, WINNING_POSITION));
-    idle(g);
-    g.onPhase('over');
-    return;
-  }
-  after(g, NEXT_TURN_DELAY, () => nextTurn(g, value === 6));
-}
-
-function nextTurn(g: Game, again: boolean) {
-  if (g.phase !== 'playing') return;
-  if (!again) {
-    g.turn = g.turn === 0 ? 1 : 0;
-    g.sixes = 0;
-    g.onTurn(g.turn);
-  }
-  g.busy = g.turn === 1;
-  g.rolling = false;
-  idle(g);
-  if (g.turn === 1) after(g, AI_DELAY, () => roll(g));
-}