@nayan-ui/games 1.20.0 → 1.21.0

package/src/games/nuts-and-bolts/NutsAndBoltsRules.ts

@@ -1,474 +0,0 @@
-// Nuts and Bolts' puzzles and moves, as plain functions: the planks laid across a 5 x 5 grid of points,
-// a bolt wherever two or more cross, three swap holes below, and what moving a bolt frees. The original
-// version's service (games/nuts-and-bolts), unchanged, so every puzzle plays the same.
-import { BOARD_COLS, BOARD_ROWS, EXTRA_HOLES } from './NutsAndBoltsConstants';
-
-export interface Hole {
-  id: string;
-  row: number;
-  col: number;
-  boltId: string | null; // null means empty hole
-}
-
-export interface Bolt {
-  id: string;
-  row: number;
-  col: number;
-  originalRow: number; // Original position where bolt started (never changes)
-  originalCol: number;
-  holeId: string | null; // null means bolt is at a grid position
-}
-
-export interface Plank {
-  id: string;
-  orientation: 'horizontal' | 'vertical';
-  startRow: number;
-  startCol: number;
-  length: number;
-  color: string;
-  zIndex: number; // for layering - higher = on top
-}
-
-export interface PuzzleState {
-  holes: Hole[]; // only the 3 extra holes at bottom
-  bolts: Bolt[];
-  planks: Plank[];
-}
-
-const PLANK_COLORS = {
-  horizontal: '#8B4513', // Brown for horizontal planks
-  vertical: '#C0C0C0' // Silver/Gray for vertical planks
-};
-
-// Get all grid positions a plank covers
-export const getPlankPositions = (plank: Plank): { row: number; col: number }[] => {
-  const positions: { row: number; col: number }[] = [];
-  for (let i = 0; i < plank.length; i++) {
-    if (plank.orientation === 'horizontal') {
-      positions.push({ row: plank.startRow, col: plank.startCol + i });
-    } else {
-      positions.push({ row: plank.startRow + i, col: plank.startCol });
-    }
-  }
-  return positions;
-};
-
-// Check if a plank covers a specific position - optimized to avoid array creation
-export const plankCoversPosition = (plank: Plank, row: number, col: number): boolean => {
-  const offset = plank.orientation === 'horizontal' ? col - plank.startCol : row - plank.startRow;
-  const aligned = plank.orientation === 'horizontal' ? row === plank.startRow : col === plank.startCol;
-  return aligned && Number.isInteger(offset) && offset >= 0 && offset < plank.length;
-};
-
-// Helper to generate random integer in range [min, max]
-const randomInt = (min: number, max: number): number => {
-  return Math.floor(Math.random() * (max - min + 1)) + min;
-};
-
-// Helper to shuffle array
-const shuffleArray = <T>(array: T[]): T[] => {
-  const shuffled = [...array];
-  for (let i = shuffled.length - 1; i > 0; i--) {
-    const j = Math.floor(Math.random() * (i + 1));
-    [shuffled[i], shuffled[j]] = [shuffled[j]!, shuffled[i]!];
-  }
-  return shuffled;
-};
-
-export const generatePuzzle = (): PuzzleState => {
-  const holes: Hole[] = [];
-  const bolts: Bolt[] = [];
-  let planks: Plank[] = [];
-
-  // Hard: four planks each way over the 5 x 5 grid
-  const numHorizontal = 4;
-  const numVertical = 4;
-
-  let plankId = 0;
-  let boltId = 0;
-
-  // Keep trying until we get a valid puzzle
-  let validPuzzle = false;
-  let attempts = 0;
-
-  while (!validPuzzle && attempts < 500) {
-    attempts++;
-    planks = [];
-    plankId = 0;
-
-    // Randomly decide pattern type for variety
-    const patternType = randomInt(0, 3);
-
-    if (patternType === 0) {
-      // Pattern 1: Grid pattern - horizontal and vertical planks at random positions
-      const availableRows = shuffleArray([...Array(BOARD_ROWS).keys()]).slice(0, numHorizontal);
-      const availableCols = shuffleArray([...Array(BOARD_COLS).keys()]).slice(0, numVertical);
-
-      for (const row of availableRows) {
-        const startCol = randomInt(0, 1);
-        const length = BOARD_COLS - startCol - randomInt(0, 1);
-        planks.push({
-          id: `plank-${plankId++}`,
-          orientation: 'horizontal',
-          startRow: row,
-          startCol,
-          length: Math.max(2, length),
-          color: PLANK_COLORS.horizontal,
-          zIndex: plankId
-        });
-      }
-
-      for (const col of availableCols) {
-        const startRow = randomInt(0, 1);
-        const length = BOARD_ROWS - startRow - randomInt(0, 1);
-        planks.push({
-          id: `plank-${plankId++}`,
-          orientation: 'vertical',
-          startRow,
-          startCol: col,
-          length: Math.max(2, length),
-          color: PLANK_COLORS.vertical,
-          zIndex: plankId
-        });
-      }
-    } else if (patternType === 1) {
-      // Pattern 2: Cross pattern - planks crossing at center
-      const centerRow = Math.floor(BOARD_ROWS / 2);
-      const centerCol = Math.floor(BOARD_COLS / 2);
-
-      // Add horizontal planks around center
-      for (let i = 0; i < numHorizontal; i++) {
-        const row = (centerRow - 1 + i) % BOARD_ROWS;
-        planks.push({
-          id: `plank-${plankId++}`,
-          orientation: 'horizontal',
-          startRow: row,
-          startCol: randomInt(0, 1),
-          length: BOARD_COLS - randomInt(0, 1),
-          color: PLANK_COLORS.horizontal,
-          zIndex: plankId
-        });
-      }
-
-      // Add vertical planks around center
-      for (let i = 0; i < numVertical; i++) {
-        const col = (centerCol - 1 + i) % BOARD_COLS;
-        planks.push({
-          id: `plank-${plankId++}`,
-          orientation: 'vertical',
-          startRow: randomInt(0, 1),
-          startCol: col,
-          length: BOARD_ROWS - randomInt(0, 1),
-          color: PLANK_COLORS.vertical,
-          zIndex: plankId
-        });
-      }
-    } else if (patternType === 2) {
-      // Pattern 3: Staggered pattern
-      for (let i = 0; i < numHorizontal; i++) {
-        const row = randomInt(0, BOARD_ROWS - 1);
-        const startCol = i % 2 === 0 ? 0 : randomInt(0, 1);
-        const endCol = i % 2 === 0 ? BOARD_COLS - randomInt(0, 1) : BOARD_COLS;
-        planks.push({
-          id: `plank-${plankId++}`,
-          orientation: 'horizontal',
-          startRow: row,
-          startCol,
-          length: Math.max(2, endCol - startCol),
-          color: PLANK_COLORS.horizontal,
-          zIndex: plankId
-        });
-      }
-
-      for (let i = 0; i < numVertical; i++) {
-        const col = randomInt(0, BOARD_COLS - 1);
-        const startRow = i % 2 === 0 ? 0 : randomInt(0, 1);
-        const endRow = i % 2 === 0 ? BOARD_ROWS - randomInt(0, 1) : BOARD_ROWS;
-        planks.push({
-          id: `plank-${plankId++}`,
-          orientation: 'vertical',
-          startRow,
-          startCol: col,
-          length: Math.max(2, endRow - startRow),
-          color: PLANK_COLORS.vertical,
-          zIndex: plankId
-        });
-      }
-    } else {
-      // Pattern 4: Random lengths and positions
-      for (let i = 0; i < numHorizontal; i++) {
-        const row = randomInt(0, BOARD_ROWS - 1);
-        const length = randomInt(2, BOARD_COLS);
-        const startCol = randomInt(0, Math.max(0, BOARD_COLS - length));
-        planks.push({
-          id: `plank-${plankId++}`,
-          orientation: 'horizontal',
-          startRow: row,
-          startCol,
-          length,
-          color: PLANK_COLORS.horizontal,
-          zIndex: plankId
-        });
-      }
-
-      for (let i = 0; i < numVertical; i++) {
-        const col = randomInt(0, BOARD_COLS - 1);
-        const length = randomInt(2, BOARD_ROWS);
-        const startRow = randomInt(0, Math.max(0, BOARD_ROWS - length));
-        planks.push({
-          id: `plank-${plankId++}`,
-          orientation: 'vertical',
-          startRow,
-          startCol: col,
-          length,
-          color: PLANK_COLORS.vertical,
-          zIndex: plankId
-        });
-      }
-    }
-
-    // Trim planks so each has at most 3 bolt holes (intersections)
-    const MAX_HOLES_PER_PLANK = 3;
-    for (let p = 0; p < planks.length; p++) {
-      const plank = planks[p]!;
-      const positions = getPlankPositions(plank);
-      const holePositions: number[] = [];
-
-      for (let i = 0; i < positions.length; i++) {
-        const pos = positions[i]!;
-        // Check if this position intersects with any other plank
-        for (let q = 0; q < planks.length; q++) {
-          if (q === p) continue;
-          if (plankCoversPosition(planks[q]!, pos.row, pos.col)) {
-            holePositions.push(i);
-            break;
-          }
-        }
-      }
-
-      if (holePositions.length > MAX_HOLES_PER_PLANK) {
-        // Keep only the first MAX_HOLES_PER_PLANK intersections by trimming the plank
-        const lastKeptIndex = holePositions[MAX_HOLES_PER_PLANK - 1]!;
-        plank.length = lastKeptIndex + 1;
-      }
-    }
-
-    // Validate: every plank must have at least one intersection
-    const intersections = getPlankIntersections(planks);
-
-    // Need minimum intersections for a valid puzzle (hard: 8 bolts). Planks keep at most 3 bolts
-    // (MAX_HOLES_PER_PLANK), so the 3 swap holes can always free some plank: every puzzle stays solvable.
-    const minIntersections = 8;
-
-    if (intersections.length < minIntersections) {
-      continue;
-    }
-
-    let allPlanksHaveBolts = true;
-    for (const plank of planks) {
-      const plankPositions = getPlankPositions(plank);
-      const hasIntersection = plankPositions.some((pos) => intersections.some((int) => int.row === pos.row && int.col === pos.col));
-      if (!hasIntersection) {
-        allPlanksHaveBolts = false;
-        break;
-      }
-    }
-
-    // Need all planks to have bolts and minimum intersections
-    if (allPlanksHaveBolts && intersections.length >= minIntersections && planks.length >= 3) {
-      validPuzzle = true;
-    }
-  }
-
-  // Find all intersection points and create bolts
-  const intersections = getPlankIntersections(planks);
-
-  for (const pos of intersections) {
-    bolts.push({
-      id: `bolt-${boltId++}`,
-      row: pos.row,
-      col: pos.col,
-      originalRow: pos.row,
-      originalCol: pos.col,
-      holeId: null
-    });
-  }
-
-  // Create extra holes at the bottom for swapping
-  for (let i = 0; i < EXTRA_HOLES; i++) {
-    holes.push({
-      id: `hole-${i}`,
-      row: BOARD_ROWS,
-      col: i + Math.floor((BOARD_COLS - EXTRA_HOLES) / 2),
-      boltId: null
-    });
-  }
-
-  return { holes, bolts, planks };
-};
-
-export const getBoltById = (boltId: string, bolts: Bolt[]): Bolt | null => {
-  return bolts.find((b) => b.id === boltId) || null;
-};
-
-export const getBoltAtPosition = (row: number, col: number, bolts: Bolt[]): Bolt | null => {
-  return bolts.find((b) => b.row === row && b.col === col && b.holeId === null) || null;
-};
-
-export const getHoleById = (holeId: string, holes: Hole[]): Hole | null => {
-  return holes.find((h) => h.id === holeId) || null;
-};
-
-// Get planks that a bolt is holding (at a specific position)
-export const getPlanksAtPosition = (row: number, col: number, planks: Plank[]): Plank[] => {
-  return planks.filter((plank) => plankCoversPosition(plank, row, col));
-};
-
-// Get all intersection points where bolts can be placed (where 2+ planks overlap)
-export const getPlankIntersections = (planks: Plank[]): { row: number; col: number }[] => {
-  const positionCount = new Map<string, number>();
-
-  for (const plank of planks) {
-    const positions = getPlankPositions(plank);
-    for (const pos of positions) {
-      const key = `${pos.row}-${pos.col}`;
-      positionCount.set(key, (positionCount.get(key) || 0) + 1);
-    }
-  }
-
-  // Return positions where 2+ planks overlap
-  const intersections: { row: number; col: number }[] = [];
-  for (const [key, count] of positionCount) {
-    if (count >= 2) {
-      const [row, col] = key.split('-').map(Number);
-      intersections.push({ row: row!, col: col! });
-    }
-  }
-
-  return intersections;
-};
-
-// Get all valid bolt positions (where bolts can be placed)
-// This includes all intersection points on remaining planks
-export const getValidBoltPositions = (planks: Plank[]): { row: number; col: number }[] => {
-  return getPlankIntersections(planks);
-};
-
-// Get empty grid holes (original bolt positions that don't have a bolt on them)
-// Simple logic: show hole at every original position that has no bolt currently there
-export const getEmptyGridHoles = (_planks: Plank[], bolts: Bolt[]): { row: number; col: number }[] => {
-  // Get all positions where bolts are currently on the grid
-  const boltCurrentPositions = new Set(bolts.filter((b) => b.holeId === null).map((b) => `${b.row}-${b.col}`));
-
-  // Get all original bolt positions
-  const originalPositions = new Map<string, { row: number; col: number }>();
-  for (const bolt of bolts) {
-    const key = `${bolt.originalRow}-${bolt.originalCol}`;
-    originalPositions.set(key, { row: bolt.originalRow, col: bolt.originalCol });
-  }
-
-  // Show hole at every original position that doesn't have a bolt currently
-  const emptyHoles: { row: number; col: number }[] = [];
-  for (const [key, pos] of originalPositions) {
-    // If no bolt is currently at this original position, show a hole
-    if (!boltCurrentPositions.has(key)) {
-      emptyHoles.push(pos);
-    }
-  }
-
-  return emptyHoles;
-};
-
-// Check if a bolt can be moved (tapped to select)
-export const canSelectBolt = (bolt: Bolt, planks: Plank[]): boolean => {
-  // Bolt must be on the grid (not in a hole)
-  if (bolt.holeId !== null) return false;
-
-  // Get planks at this bolt position
-  const planksAtBolt = getPlanksAtPosition(bolt.row, bolt.col, planks);
-  if (planksAtBolt.length === 0) return true; // Free bolt
-
-  // Bolt can be selected if it's on the topmost plank (highest zIndex)
-  const maxZIndex = Math.max(...planksAtBolt.map((p) => p.zIndex));
-  const topPlank = planksAtBolt.find((p) => p.zIndex === maxZIndex);
-
-  return topPlank !== undefined;
-};
-
-// Check if a hole can receive a bolt
-export const canPlaceBoltInHole = (hole: Hole): boolean => {
-  return hole.boltId === null;
-};
-
-// Move bolt to a hole
-export const moveBoltToHole = (boltId: string, holeId: string, bolts: Bolt[], holes: Hole[]): { bolts: Bolt[]; holes: Hole[] } => {
-  const newBolts = bolts.map((b) => ({ ...b }));
-  const newHoles = holes.map((h) => ({ ...h }));
-
-  const bolt = newBolts.find((b) => b.id === boltId);
-  const hole = newHoles.find((h) => h.id === holeId);
-
-  if (!bolt || !hole) return { bolts, holes };
-
-  // If bolt was in another hole, clear it
-  if (bolt.holeId) {
-    const oldHole = newHoles.find((h) => h.id === bolt.holeId);
-    if (oldHole) oldHole.boltId = null;
-  }
-
-  // Move bolt to new hole
-  hole.boltId = boltId;
-  bolt.holeId = holeId;
-
-  return { bolts: newBolts, holes: newHoles };
-};
-
-// Move bolt from hole back to grid position
-export const moveBoltToGrid = (boltId: string, row: number, col: number, bolts: Bolt[], holes: Hole[]): { bolts: Bolt[]; holes: Hole[] } => {
-  const newBolts = bolts.map((b) => ({ ...b }));
-  const newHoles = holes.map((h) => ({ ...h }));
-
-  const bolt = newBolts.find((b) => b.id === boltId);
-  if (!bolt) return { bolts, holes };
-
-  // Clear the hole the bolt was in
-  if (bolt.holeId) {
-    const oldHole = newHoles.find((h) => h.id === bolt.holeId);
-    if (oldHole) oldHole.boltId = null;
-  }
-
-  // Move bolt to grid position
-  bolt.row = row;
-  bolt.col = col;
-  bolt.holeId = null;
-
-  return { bolts: newBolts, holes: newHoles };
-};
-
-// Check which planks should fall (no bolts holding them)
-export const checkPlankRemoval = (planks: Plank[], bolts: Bolt[]): { removedPlanks: Plank[]; remainingPlanks: Plank[] } => {
-  const removedPlanks: Plank[] = [];
-  const remainingPlanks: Plank[] = [];
-
-  // Get all bolt positions on the grid (not in holes)
-  const boltPositions = new Set(bolts.filter((b) => b.holeId === null).map((b) => `${b.row}-${b.col}`));
-
-  for (const plank of planks) {
-    const plankPositions = getPlankPositions(plank);
-
-    // A plank is held if ANY of its positions has a bolt
-    const isHeld = plankPositions.some((pos) => boltPositions.has(`${pos.row}-${pos.col}`));
-
-    if (!isHeld) {
-      removedPlanks.push(plank);
-    } else {
-      remainingPlanks.push(plank);
-    }
-  }
-
-  return { removedPlanks, remainingPlanks };
-};
-
-export const isPuzzleComplete = (planks: Plank[]): boolean => {
-  return planks.length === 0;
-};