@nayan-ui/games 1.20.0 → 1.21.0

package/src/games/bubble-shooter/BubbleShooterScene.ts

@@ -1,158 +0,0 @@
-// Everything Bubble Shooter draws. Orthographic camera, one world unit per point, looking down -z: x
-// right and y up from the view's centre. Positions come in board points (from the board's top-left). Depth (toward the camera): the game background,
-// the board panel and its border, the aim dots, the bubbles. Bubbles are glossy spheres (the same mesh
-// as Connect Em All's dots) and the aim dots flat discs; both are shared meshes, as mesh ids are
-// app-wide and limited.
-import { type Color, type Entity, extrude, type Model, Path, shapeGeometry, type Vec3, type World } from '@nayan-ui/engine';
-import type { GameTheme } from '../../services/ThemeService';
-import { setBackdropTheme, spawnBackdrop } from '../shared/EngineBackdrop';
-import { popAndBurst } from '../shared/EngineBlasts';
-import { cacheGameAsset, createGameMesh as createShape } from '../shared/EngineMeshes';
-import { toColor } from '../shared/EngineUtils';
-import {
-  AIM_ALPHA_FAR,
-  AIM_ALPHA_NEAR,
-  AIM_DOT_COUNT,
-  BUBBLE_COLORS,
-  BUBBLE_SHINE,
-  BURST_TIME,
-  CLASSIC_AIM,
-  CLASSIC_BOARD,
-  CLASSIC_BORDER,
-  CLASSIC_RADIUS,
-  type Layout,
-  THEMED_RADIUS,
-  TOP_BOUNDARY
-} from './BubbleShooterConstants';
-
-const Z_BACKDROP = -20;
-const Z_BOARD = 0;
-const Z_RIM = 0.2;
-const Z_AIM = 0.5;
-const HIDDEN = 0;
-
-/** A board point at depth `z`, in world space. */
-export const toWorld = (l: Layout, x: number, y: number, z = 0): Vec3 => [l.boardLeft + x - l.width / 2, l.height / 2 - (l.boardTop + y), z];
-const bubbleZ = (l: Layout) => l.radius + 1;
-export const bubblePosition = (l: Layout, x: number, y: number) => toWorld(l, x, y, bubbleZ(l));
-/** A grid bubble's size (the sphere mesh is one across). */
-export const bubbleSize = (l: Layout) => l.radius * 2;
-
-// ── Meshes (registered once per size: mesh ids are app-wide and limited) ──
-
-const meshes = new Map<string, Model>();
-const mesh = (key: string, build: () => Model) => {
-  let m = meshes.get(key);
-  if (!m) {
-    m = cacheGameAsset('bubble-shooter/BubbleShooterScene:' + key, build);
-    meshes.set(key, m);
-  }
-  return m;
-};
-/** A glossy unit sphere: Connect Em All's dot mesh (same geometry and shine, so the same mesh id). */
-const bubbleMesh = () => mesh('dot', () => createShape(shapeGeometry('sphere'), { shine: BUBBLE_SHINE }));
-const discMesh = () => mesh('disc', () => createShape(extrude(new Path().addCircle(0, 0, 0.5), { depth: 0 })));
-/** A flat rounded rectangle from its top-left; with `rim`, only its outline. */
-const panelMesh = (w: number, h: number, r: number, rim = 0) =>
-  mesh(`panel:${w}:${h}:${r}:${rim}`, () => {
-    const path = new Path().addRoundedRect(0, 0, w, h, r);
-    if (rim > 0) path.addRoundedRect(rim, rim, w - rim * 2, h - rim * 2, r - rim);
-    return createShape(extrude(path, { depth: 0, fillRule: 'evenodd' }), { center: false });
-  });
-
-// ── Colors ────────────────────────────────────────────────────────────
-
-const BUBBLES = BUBBLE_COLORS.map((c) => toColor(c));
-export const bubbleColor = (color: number) => BUBBLES[color % BUBBLES.length]!;
-/** White aim dots on classic; light / dark draw them in the theme's text color. */
-export const aimColor = (theme: GameTheme): Color => toColor(theme.mode === 'classic' ? CLASSIC_AIM : theme.TEXT);
-
-// ── Board ─────────────────────────────────────────────────────────────
-
-export type Scenery = { backdrop: Entity; parts: Entity[] };
-
-function spawnBoard(world: World, l: Layout, theme: GameTheme): Entity[] {
-  const classic = theme.mode === 'classic';
-  const radius = classic ? CLASSIC_RADIUS : THEMED_RADIUS;
-  const at = (z: number) => toWorld(l, 0, 0, z);
-  return [
-    world.spawn({
-      mesh: panelMesh(l.boardWidth, l.boardHeight, radius),
-      position: at(Z_BOARD),
-      color: toColor(classic ? CLASSIC_BOARD : theme.BOARD.SURFACE),
-      pickable: false
-    }),
-    world.spawn({
-      mesh: panelMesh(l.boardWidth, l.boardHeight, radius, 1.5),
-      position: at(Z_RIM),
-      color: toColor(classic ? CLASSIC_BORDER : theme.BOARD.BORDER),
-      pickable: false
-    })
-  ];
-}
-
-export function buildScenery(world: World, l: Layout, theme: GameTheme): Scenery {
-  return { backdrop: spawnBackdrop(world, l.width, l.height, Z_BACKDROP, theme), parts: spawnBoard(world, l, theme) };
-}
-
-export function removeScenery(world: World, s: Scenery) {
-  world.despawn(s.backdrop);
-  for (const e of s.parts) world.despawn(e);
-}
-
-export function setSceneryTheme(world: World, l: Layout, s: Scenery, theme: GameTheme) {
-  setBackdropTheme(world, s.backdrop, theme);
-  for (const e of s.parts) world.despawn(e);
-  s.parts = spawnBoard(world, l, theme);
-}
-
-// ── Bubbles ───────────────────────────────────────────────────────────
-
-/** A bubble at (x, y), `scale` of its full size. */
-export function spawnBubble(world: World, l: Layout, color: number, x: number, y: number, scale = 1): Entity {
-  return world.spawn({
-    mesh: bubbleMesh(),
-    position: bubblePosition(l, x, y),
-    scale: bubbleSize(l) * scale,
-    color: bubbleColor(color),
-    pickable: false
-  });
-}
-
-/** A popped bubble: it pops (swells, flashes, settles, shrinks away) and bursts in its color, then it's gone. */
-export function popBubble(world: World, l: Layout, e: Entity, color: number, x: number, y: number) {
-  const at = bubblePosition(l, x, y);
-  popAndBurst(
-    world,
-    e,
-    { scale: bubbleSize(l), color: bubbleColor(color), duration: BURST_TIME },
-    { position: [at[0], at[1], at[2] + l.radius], size: bubbleSize(l), color: bubbleColor(color), glowZ: Z_RIM + 0.3 }
-  ).then(() => world.despawn(e));
-}
-
-// ── Aim guide ─────────────────────────────────────────────────────────
-
-/** The aim dots, hidden until placed. */
-export function spawnAimDots(world: World): Entity[] {
-  return Array.from({ length: AIM_DOT_COUNT }, () => world.spawn({ mesh: discMesh(), scale: HIDDEN, pickable: false }));
-}
-
-/** Shows dots at `points` (x, y, radius triples, nearest first); the rest hide. */
-export function placeAimDots(world: World, l: Layout, dots: Entity[], points: number[], color: Color) {
-  const span = Math.max(1, l.shooterY - TOP_BOUNDARY);
-  dots.forEach((dot, i) => {
-    if (i * 3 >= points.length) {
-      world.set(dot, { scale: HIDDEN });
-      return;
-    }
-    const x = points[i * 3]!;
-    const y = points[i * 3 + 1]!;
-    // Fades from near the shooter toward the ceiling, as the original guide's gradient did
-    const t = Math.max(0, Math.min(1, (l.shooterY - y) / span));
-    world.set(dot, {
-      position: toWorld(l, x, y, Z_AIM),
-      scale: points[i * 3 + 2]! * 2,
-      color: [color[0], color[1], color[2], AIM_ALPHA_NEAR + (AIM_ALPHA_FAR - AIM_ALPHA_NEAR) * t]
-    });
-  });
-}

package/src/games/candy-crush/CandyCrush.tsx

@@ -1,77 +0,0 @@
-// Candy Crush's screen, on the Nayan engine: the board, candies and bursts are one 3D scene (an
-// orthographic camera over a board of glossy candies), under Playtura's scoreboard, controls and
-// modals. The rules are in CandyCrushGame.ts, what it draws in CandyCrushScene.ts.
-//
-// One world serves the whole visit: Start, Stop and Play Again deal a new board in place and a theme
-// change repaints the board, so the GPU view is never rebuilt. Swaps, swells, falls and bursts animate
-// in the engine's Rust core; JS only moves the dragged candy, resolves matches and steps the world.
-import { HapticType } from '../../services/HapticsService';
-import { GAME_SOUNDS } from '../../services/SoundsService';
-import { GAME_IDS } from '../../services/UtilsService';
-import { engineGame, EngineGameScreen } from '../shared/EngineGameScreen';
-import { scoreColumn, timerColumn } from '../shared/EngineHud';
-import { useEngineGame } from '../shared/useEngineGame';
-import { useLiveState } from '../shared/useLiveState';
-import { getLayout, LIGHT, TIME_LIMIT } from './CandyCrushConstants';
-import { createGame, dispose, reset, setLayout, setTheme, start, tick, touchEnd, touchMove, touchStart } from './CandyCrushGame';
-
-const SFX = GAME_SOUNDS.CANDY_CRUSH;
-const scoreFormatter = (s: number) => `${s}`;
-
-export const CandyCrush = engineGame(GAME_IDS.CANDY_CRUSH, (props) => {
-  const [score, setScore] = useLiveState(0);
-  const [timeLeft, setTimeLeft] = useLiveState(TIME_LIMIT);
-
-  const { theme, screen, gameOver } = useEngineGame(props, {
-    gameId: GAME_IDS.CANDY_CRUSH,
-    create: createGame,
-    start,
-    reset,
-    dispose,
-    tick,
-    setTheme,
-    resize: (g, width, height, offset) => {
-      const l = getLayout(width, height, offset);
-      setLayout(g, l);
-      return l.boardSize;
-    },
-    drag: (g, { phase, x, y, dx, dy, cancelled }) => {
-      if (phase === 'start') touchStart(g, x, y);
-      else if (phase === 'move') touchMove(g, dx, dy);
-      else touchEnd(g, dx, dy, cancelled);
-    },
-    // The run only ends when time is up, which counts as a win (any score)
-    outcome: () => 'win',
-    sounds: SFX,
-    onStart: (fx) => fx(SFX.START, HapticType.MEDIUM),
-    wire: (g, fx) => {
-      g.onScore = setScore;
-      g.onTime = setTimeLeft;
-      g.onSelect = () => fx(SFX.SELECT, HapticType.LIGHT);
-      g.onSwap = () => fx(SFX.SWAP, HapticType.MEDIUM);
-      g.onInvalid = () => fx(SFX.INVALID_SWAP, HapticType.WARNING);
-      g.onMatch = (combo) => fx(combo > 1 ? SFX.COMBO : SFX.MATCH, combo > 1 ? HapticType.HEAVY : HapticType.MEDIUM);
-      g.onBomb = () => fx(SFX.BOMB, HapticType.HEAVY);
-      g.onBlast = () => fx(SFX.BLAST, HapticType.HEAVY);
-      g.onWarning = (secondsLeft) => fx(SFX.WARNING, secondsLeft <= 10 ? HapticType.HEAVY : HapticType.MEDIUM);
-      g.onTimeUp = () => fx(SFX.TIME_UP, HapticType.HEAVY);
-    }
-  });
-
-  return (
-    <EngineGameScreen
-      {...screen}
-      light={LIGHT}
-      columns={[scoreColumn(score), timerColumn(timeLeft, theme, 0)]}
-      subtext="Match 3 or more"
-      gameOver={gameOver({
-        title: 'TIME UP!',
-        message: 'Great crushing!',
-        scoreLabel: 'Final Score',
-        score,
-        formatter: scoreFormatter,
-        buttonText: 'Crush Again!'
-      })}
-    />
-  );
-});

package/src/games/candy-crush/CandyCrushConstants.ts

@@ -1,94 +0,0 @@
-// Candy Crush's rules, timings, colors and layout. Rules, scoring and layout match the original version
-// (games/candy-crush), so scores and feel carry over.
-import { frontLight, gameWidthFor } from '../shared/EngineUtils';
-
-// ── Rules ─────────────────────────────────────────────────────────────
-
-export const GRID_SIZE = 7;
-export const CANDY_TYPES = 4; // colors in play: the first four of CANDY_COLORS
-export const MIN_MATCH = 3;
-/** A run this long leaves a color bomb: swap it with any candy to clear every candy of that color (two bombs clear the board). */
-export const BOMB_MATCH = 5;
-/** A color bomb's type: it has no color, so it never matches. */
-export const BOMB = -1;
-export const BOMB_MULTIPLIER = 2; // a color bomb's candies score double
-export const ZAP_TIME = 0.25; // a color bomb's zaps reach their candies before they crush
-export const POINTS_PER_CANDY = 50;
-export const COMBO_MULTIPLIER = 1.25; // each cascade after the first scores 1.25x the one before
-export const TIME_LIMIT = 300; // seconds
-export const WARNING_TIMES = [30, 10] as const; // "Hurry!" at these seconds left
-
-// Vibrant saturated palette for glossy 3D candies
-export const CANDY_COLORS = ['#EF2D36', '#2DC84E', '#3B9FFF', '#FFD020', '#B44CFF', '#FF8820'] as const;
-
-// ── Feel (seconds) ────────────────────────────────────────────────────
-
-export const SWAP_TIME = 0.2; // two candies glide past each other; matches are checked after it
-export const MATCH_TIME = 0.42; // matched candies pop (swell, flash, settle, shrink away) and burst, as Block Blast's
-export const CLEAR_RIPPLE = 0.025; // seconds per cell: clears ripple out from where the swap landed
-export const FALL_TIME = 0.4; // survivors drop and new candies fall in, then the board is checked again
-export const FALL_SPRING = { damping: 13, stiffness: 170, mass: 0.9 }; // a small bounce on landing
-export const LIFT_SPRING = { damping: 14, stiffness: 300 };
-export const RETURN_SPRING = { damping: 16, stiffness: 260 };
-export const LIFT_SCALE = 1.1;
-export const NUDGE_TIME = 0.09; // a rejected swap bumps the candies together...
-export const NUDGE_SPRING = { damping: 9, stiffness: 320 }; // ...and they spring back
-export const NUDGE_DISTANCE = 0.28; // cells
-// Fresh board: candies rain in column by column, bottom rows first
-export const INTRO_COL_STAGGER = 0.028;
-export const INTRO_ROW_STAGGER = 0.022;
-
-// ── Look ──────────────────────────────────────────────────────────────
-
-// Lit from the top-left, like the original sprites' highlight; flat surfaces keep their exact color.
-export const LIGHT = frontLight([-0.35, 0.6, 1], 0.5);
-export const CANDY_SHINE = 0.55;
-
-// Classic (no host theme) board colors
-export const CLASSIC_BOARD = 'rgba(255, 255, 255, 0.13)';
-export const CLASSIC_BORDER = 'rgba(255, 255, 255, 0.25)';
-export const CLASSIC_CELL = 'rgba(255, 255, 255, 0.10)';
-export const CLASSIC_RADIUS = 16;
-export const THEMED_RADIUS = 8;
-
-// ── Layout (points; same arithmetic as the original version) ──────────────
-
-export const CELL_GAP = 3;
-
-export type Layout = {
-  /** The GameView's size. */
-  width: number;
-  height: number;
-  boardLeft: number;
-  boardTop: number;
-  /** The board's side, padding included. */
-  boardSize: number;
-  cell: number;
-  /** From one cell's top-left to the next. */
-  step: number;
-  /** A drag this far starts a swap. */
-  swipeThreshold: number;
-};
-
-/** The board as wide as the game area (360 phones / 500 tablets), centred in the space below the header. */
-export function getLayout(width: number, height: number, offset: number): Layout {
-  const gameWidth = gameWidthFor(width);
-  const cell = Math.floor((gameWidth - CELL_GAP * (GRID_SIZE + 1)) / GRID_SIZE);
-  const boardSize = GRID_SIZE * cell + (GRID_SIZE + 1) * CELL_GAP;
-  return {
-    width,
-    height,
-    boardLeft: (width - boardSize) / 2,
-    boardTop: offset + (height - offset - boardSize) / 2,
-    boardSize,
-    cell,
-    step: cell + CELL_GAP,
-    swipeThreshold: cell * 0.3
-  };
-}
-
-/** Centre of cell (row, col), in view points. `row` may be negative: above the board. */
-export const cellCenter = (l: Layout, row: number, col: number): [number, number] => [
-  l.boardLeft + CELL_GAP + col * l.step + l.cell / 2,
-  l.boardTop + CELL_GAP + row * l.step + l.cell / 2
-];