@nayan-ui/games 1.20.0 → 1.21.0

package/src/games/block-blast/BlockBlast.tsx

@@ -1,73 +0,0 @@
-// Block Blast's screen, on the Nayan engine: the board, pieces and effects are one 3D scene (an
-// orthographic camera, so it reads as a flat board with bevelled blocks), under Playtura's scoreboard,
-// controls and modals. The rules are in BlockBlastGame.ts, what it draws in BlockBlastScene.ts.
-//
-// One world serves the whole visit: Start, Stop and Play Again reset it in place, and a theme change
-// repaints it, so the GPU view is never rebuilt. The engine animates blocks, flashes and blasts in its
-// Rust core; JS only steps it once a frame and moves the held piece.
-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 { GAME_DURATION, getLayout, LIGHT } from './BlockBlastConstants';
-import { createGame, dispose, dragEnd, dragMove, dragStart, reset, setLayout, setTheme, start, tick } from './BlockBlastGame';
-
-const SFX = GAME_SOUNDS.BLOCK_BLAST;
-
-export const BlockBlast = engineGame(GAME_IDS.BLOCK_BLAST, (props) => {
-  const [score, setScore] = useLiveState(0);
-  const [timeLeft, setTimeLeft] = useLiveState(GAME_DURATION);
-
-  // Win when the timer runs out, lose with no room left
-  const { theme, status, screen, gameOver } = useEngineGame(props, {
-    gameId: GAME_IDS.BLOCK_BLAST,
-    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 }) => {
-      if (phase === 'start') dragStart(g, x, y);
-      else if (phase === 'move') dragMove(g, x, y);
-      else dragEnd(g);
-    },
-    onStart: (fx) => fx(SFX.START, HapticType.SUCCESS),
-    onOver: (fx, status) => {
-      if (status === 'win') fx(SFX.WIN, HapticType.SUCCESS);
-    },
-    wire: (g, fx) => {
-      g.onScore = setScore;
-      g.onTime = setTimeLeft;
-      g.onPick = () => fx(SFX.PICK, HapticType.LIGHT);
-      g.onInvalid = () => fx(SFX.INVALID, HapticType.WARNING);
-      g.onPlace = () => fx(SFX.PLACE, HapticType.LIGHT);
-      g.onClear = () => fx(SFX.CLEAR, HapticType.SUCCESS);
-      g.onGameOver = () => fx(SFX.GAME_OVER, HapticType.ERROR);
-    }
-  });
-
-  return (
-    <EngineGameScreen
-      {...screen}
-      light={LIGHT}
-      columns={[scoreColumn(score), timerColumn(timeLeft, theme)]}
-      subtext="Place blocks, clear lines!"
-      gameOver={gameOver({
-        title: status === 'win' ? 'YOU WON!' : 'GAME OVER',
-        message: status === 'win' ? 'Time completed! Great job!' : 'No more moves available!',
-        scoreLabel: 'Final Score',
-        score,
-        buttonText: 'Play Again!'
-      })}
-    />
-  );
-});

package/src/games/block-blast/BlockBlastConstants.ts

@@ -1,179 +0,0 @@
-// Block Blast's rules, shapes, colors and screen layout. The rules and layout match the original version
-// (games/block-blast) so scores, timing and feel carry over.
-import type { Color } from '@nayan-ui/engine';
-import { getSceneInputInsets } from '../shared/EngineHud';
-import { frontLight, gameWidthFor } from '../shared/EngineUtils';
-
-export { toColor } from '../shared/EngineUtils';
-
-// ── Rules ─────────────────────────────────────────────────────────────
-
-export const GRID_SIZE = 9;
-export const NEXT_PIECES_COUNT = 3;
-export const POINTS_PER_BLOCK = 50;
-export const POINTS_PER_LINE = 500;
-export const GAME_DURATION = 300; // seconds: surviving the timer wins
-
-// 6 maximally distinct colors, readable on every board theme
-export const BLOCK_COLORS = ['#FF3B3B', '#32CD32', '#FFD700', '#4DA6FF', '#BF5AF2', '#FF9500'] as const;
-
-// Every shape up to 4 blocks
-export const BLOCK_SHAPES: readonly (readonly (readonly number[])[])[] = [
-  [[1]],
-  [[1, 1]],
-  [[1], [1]],
-  [[1, 1, 1]],
-  [[1], [1], [1]],
-  [
-    [1, 1],
-    [1, 0]
-  ],
-  [
-    [1, 1],
-    [0, 1]
-  ],
-  [
-    [1, 0],
-    [1, 1]
-  ],
-  [
-    [0, 1],
-    [1, 1]
-  ],
-  [[1, 1, 1, 1]],
-  [[1], [1], [1], [1]],
-  [
-    [1, 1],
-    [1, 1]
-  ],
-  [
-    [1, 1, 1],
-    [0, 1, 0]
-  ],
-  [
-    [0, 1, 0],
-    [1, 1, 1]
-  ],
-  [
-    [0, 1, 1],
-    [1, 1, 0]
-  ],
-  [
-    [1, 1, 0],
-    [0, 1, 1]
-  ],
-  [
-    [1, 1, 1],
-    [1, 0, 0]
-  ],
-  [
-    [0, 0, 1],
-    [1, 1, 1]
-  ],
-  [
-    [1, 0, 0],
-    [1, 1, 1]
-  ],
-  [
-    [1, 1, 1],
-    [0, 0, 1]
-  ]
-];
-
-// ── Feel ──────────────────────────────────────────────────────────────
-
-export const TRAY_SCALE = 0.7; // tray pieces, relative to board cells
-export const DRAG_LIFT = 50; // points the held piece floats above the finger, so it stays visible
-export const LIFT_TIME = 0.14; // seconds to lift on pickup
-export const RETURN_TIME = 0.18; // seconds to fly back to the tray after an invalid drop
-export const DEAL_TIME = 0.24; // seconds for a new tray piece to pop in
-export const FLASH_TIME = 0.26; // seconds of the white glint on placed blocks
-export const FLASH_AMOUNT = 0.55;
-export const CLEAR_TIME = 0.5; // seconds for a cleared block to pop: swell, flash, settle and shrink away
-export const CLEAR_RIPPLE = 0.025; // seconds per cell: clears ripple out from where the piece landed
-export const PICKUP_SPRING = { stiffness: 320, damping: 18, mass: 0.6 };
-
-// ── Layout (points; same arithmetic as the original version) ──────────────
-
-export const CELL_GAP = 2;
-const TRAY_HEIGHT = 120;
-const CONTROLS_HEIGHT = 110;
-const GRID_TRAY_GAP = 30;
-const GRID_TOP_PADDING = 20;
-const TRAY_PADDING = 20;
-const TRAY_SPACING = 30;
-
-export type Layout = {
-  /** The GameView's size in points. */
-  width: number;
-  height: number;
-  cell: number;
-  /** Cell plus gap: the distance between neighbouring cells. */
-  step: number;
-  /** Board's outer square: top-left corner and side, in view points. */
-  boardLeft: number;
-  boardTop: number;
-  boardSize: number;
-  /** Centre of each tray slot, in view points. */
-  slots: [number, number][];
-  /** Width of each slot's touch area. */
-  slotWidth: number;
-  trayTop: number;
-  trayHeight: number;
-  /** Block thickness toward the camera. */
-  depth: number;
-};
-
-export function getLayout(width: number, height: number, offset: number): Layout {
-  const top = getSceneInputInsets(offset).top;
-  const available = height - top - CONTROLS_HEIGHT;
-  // Scale the tray on short screens so the board keeps useful cell sizes.
-  const trayHeight = Math.min(TRAY_HEIGHT, Math.max(48, available * 0.2));
-  // Reserve the piece tray and its gap before choosing the square board's width.
-  const gameWidth = Math.max(96, Math.min(gameWidthFor(width), available - trayHeight - GRID_TRAY_GAP - 20));
-  const cell = (gameWidth - CELL_GAP * (GRID_SIZE + 1)) / GRID_SIZE;
-  const step = cell + CELL_GAP;
-  const boardSize = GRID_SIZE * step + CELL_GAP;
-  const extraTop = gameWidth > 400 ? 20 : 0;
-  const contentHeight = boardSize + extraTop + GRID_TRAY_GAP + trayHeight;
-  const contentTop = Math.max(top + (available - contentHeight) / 2, top + 10);
-  const trayTop = contentTop + boardSize + extraTop + GRID_TRAY_GAP;
-  const trayLeft = (width - gameWidth) / 2 + TRAY_PADDING;
-  const slotWidth = (gameWidth - TRAY_PADDING * 2 - TRAY_SPACING * (NEXT_PIECES_COUNT - 1)) / NEXT_PIECES_COUNT;
-  const slots = Array.from(
-    { length: NEXT_PIECES_COUNT },
-    (_, i) => [trayLeft + i * (slotWidth + TRAY_SPACING) + slotWidth / 2, trayTop + trayHeight / 2] as [number, number]
-  );
-  return {
-    width,
-    height,
-    cell,
-    step,
-    boardLeft: (width - boardSize) / 2,
-    boardTop: contentTop + GRID_TOP_PADDING,
-    boardSize,
-    slots,
-    slotWidth: slotWidth + TRAY_SPACING,
-    trayTop,
-    trayHeight,
-    depth: cell * 0.5
-  };
-}
-
-// ── Look ──────────────────────────────────────────────────────────────
-
-// Light directly overhead along +z, aligned with the top-down camera; no cast shadows.
-export const LIGHT = frontLight([0, 0, 1], 0.45);
-
-/** Self-lit (flat, unshaded): the engine draws a color whose brightest channel is 2 at full brightness. */
-export function flat([r, g, b, a = 1]: Color): Color {
-  const peak = Math.max(r, g, b);
-  if (peak <= 0) return [0, 0, 0, a];
-  const k = 2 / peak;
-  return [r * k, g * k, b * k, a];
-}
-
-/** `color` blended toward white, for the placement glint. */
-export function tint([r, g, b]: Color, amount: number): Color {
-  return [r + (1 - r) * amount, g + (1 - g) * amount, b + (1 - b) * amount, 1];
-}