brainrot-cli 0.1.0

package/dist/game-types.js

@@ -0,0 +1,55 @@
+/**
+ * Game Framework Types and Interfaces
+ *
+ * Provides common types for building terminal games that run
+ * alongside Claude Code work.
+ */
+/**
+ * Convert direction to vector
+ */
+export function directionToVector(direction) {
+    switch (direction) {
+        case "up":
+            return { x: 0, y: -1 };
+        case "down":
+            return { x: 0, y: 1 };
+        case "left":
+            return { x: -1, y: 0 };
+        case "right":
+            return { x: 1, y: 0 };
+    }
+}
+/**
+ * Check if two points are equal
+ */
+export function pointsEqual(a, b) {
+    return a.x === b.x && a.y === b.y;
+}
+/**
+ * Add two vectors
+ */
+export function addVectors(a, b) {
+    return { x: a.x + b.x, y: a.y + b.y };
+}
+/**
+ * Create a game input object from ink's useInput callback params
+ */
+export function createGameInput(input, key) {
+    return {
+        key: input,
+        ctrl: key.ctrl,
+        shift: key.shift,
+        meta: key.meta,
+        upArrow: key.upArrow,
+        downArrow: key.downArrow,
+        leftArrow: key.leftArrow,
+        rightArrow: key.rightArrow,
+        return: key.return,
+        escape: key.escape,
+        space: input === " ",
+        tab: key.tab,
+        backspace: key.backspace,
+        delete: key.delete,
+    };
+}
+//# sourceMappingURL=game-types.js.map

package/dist/game-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"game-types.js","sourceRoot":"","sources":["../src/game-types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AA6JH;;GAEG;AACH,MAAM,UAAU,iBAAiB,CAAC,SAAoB;IACpD,QAAQ,SAAS,EAAE,CAAC;QAClB,KAAK,IAAI;YACP,OAAO,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC;QACzB,KAAK,MAAM;YACT,OAAO,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;QACxB,KAAK,MAAM;YACT,OAAO,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;QACzB,KAAK,OAAO;YACV,OAAO,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;IAC1B,CAAC;AACH,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,WAAW,CAAC,CAAQ,EAAE,CAAQ;IAC5C,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;AACpC,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,UAAU,CAAC,CAAW,EAAE,CAAW;IACjD,OAAO,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC;AACxC,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,eAAe,CAC7B,KAAa,EACb,GAaC;IAED,OAAO;QACL,GAAG,EAAE,KAAK;QACV,IAAI,EAAE,GAAG,CAAC,IAAI;QACd,KAAK,EAAE,GAAG,CAAC,KAAK;QAChB,IAAI,EAAE,GAAG,CAAC,IAAI;QACd,OAAO,EAAE,GAAG,CAAC,OAAO;QACpB,SAAS,EAAE,GAAG,CAAC,SAAS;QACxB,SAAS,EAAE,GAAG,CAAC,SAAS;QACxB,UAAU,EAAE,GAAG,CAAC,UAAU;QAC1B,MAAM,EAAE,GAAG,CAAC,MAAM;QAClB,MAAM,EAAE,GAAG,CAAC,MAAM;QAClB,KAAK,EAAE,KAAK,KAAK,GAAG;QACpB,GAAG,EAAE,GAAG,CAAC,GAAG;QACZ,SAAS,EAAE,GAAG,CAAC,SAAS;QACxB,MAAM,EAAE,GAAG,CAAC,MAAM;KACnB,CAAC;AACJ,CAAC"}

package/dist/games/MinesweeperGame.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Minesweeper Game
+ *
+ * Classic Minesweeper puzzle game implemented with the game framework.
+ * Features: Multiple difficulty levels, flag mechanics, timer, mine count.
+ */
+import type { GameComponentProps, GameInfo } from "../game-types.js";
+/** Minesweeper game metadata */
+export declare const minesweeperGameInfo: GameInfo;
+/**
+ * Minesweeper game component
+ */
+export declare function MinesweeperGame({ hasFocus, onExit, loopAttention, onLoopAlertDismiss, onGameStateChange }: GameComponentProps): import("react/jsx-runtime").JSX.Element;
+export default MinesweeperGame;
+//# sourceMappingURL=MinesweeperGame.d.ts.map

package/dist/games/MinesweeperGame.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MinesweeperGame.d.ts","sourceRoot":"","sources":["../../src/games/MinesweeperGame.tsx"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,KAAK,EAAE,kBAAkB,EAAE,QAAQ,EAAS,MAAM,kBAAkB,CAAC;AAO5E,gCAAgC;AAChC,eAAO,MAAM,mBAAmB,EAAE,QAOjC,CAAC;AA4YF;;GAEG;AACH,wBAAgB,eAAe,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE,aAAa,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,EAAE,kBAAkB,2CAqd7H;AAED,eAAe,eAAe,CAAC"}

package/dist/games/MinesweeperGame.js

@@ -0,0 +1,555 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Minesweeper Game
+ *
+ * Classic Minesweeper puzzle game implemented with the game framework.
+ * Features: Multiple difficulty levels, flag mechanics, timer, mine count.
+ */
+import { Box, Text, useInput } from "ink";
+import { useState, useCallback, useRef, useEffect } from "react";
+import { useGameLoop } from "../use-game-loop.js";
+import { useBestTimes } from "../use-high-scores.js";
+import { useGameSession } from "../use-stats.js";
+import { Leaderboard, formatTime } from "../Leaderboard.js";
+import { LoopAlertOverlay } from "../LoopAlertOverlay.js";
+/** Minesweeper game metadata */
+export const minesweeperGameInfo = {
+    id: "minesweeper",
+    name: "Minesweeper",
+    description: "Classic Minesweeper - find mines without triggering them!",
+    controls: "Arrows to move, Space to reveal, F to flag, D for difficulty",
+    minWidth: 30,
+    minHeight: 15,
+};
+const DIFFICULTIES = [
+    { name: "Easy", width: 9, height: 9, mines: 10 },
+    { name: "Medium", width: 16, height: 16, mines: 40 },
+    { name: "Hard", width: 20, height: 12, mines: 60 },
+];
+/** Create an empty board */
+function createEmptyBoard(width, height) {
+    return Array(height)
+        .fill(null)
+        .map(() => Array(width)
+        .fill(null)
+        .map(() => ({
+        hasMine: false,
+        revealed: false,
+        flagged: false,
+        adjacentMines: 0,
+    })));
+}
+/** Place mines on the board, avoiding the safe zone around first click */
+function placeMines(board, mineCount, safePoint) {
+    const height = board.length;
+    const width = board[0].length;
+    const newBoard = board.map((row) => row.map((cell) => ({ ...cell })));
+    let placed = 0;
+    while (placed < mineCount) {
+        const x = Math.floor(Math.random() * width);
+        const y = Math.floor(Math.random() * height);
+        // Skip if already has mine or too close to safe point
+        if (newBoard[y][x].hasMine)
+            continue;
+        if (Math.abs(x - safePoint.x) <= 1 && Math.abs(y - safePoint.y) <= 1) {
+            continue;
+        }
+        newBoard[y][x].hasMine = true;
+        placed++;
+    }
+    // Calculate adjacent mine counts
+    for (let y = 0; y < height; y++) {
+        for (let x = 0; x < width; x++) {
+            if (newBoard[y][x].hasMine)
+                continue;
+            let count = 0;
+            for (let dy = -1; dy <= 1; dy++) {
+                for (let dx = -1; dx <= 1; dx++) {
+                    const ny = y + dy;
+                    const nx = x + dx;
+                    if (ny >= 0 && ny < height && nx >= 0 && nx < width) {
+                        if (newBoard[ny][nx].hasMine)
+                            count++;
+                    }
+                }
+            }
+            newBoard[y][x].adjacentMines = count;
+        }
+    }
+    return newBoard;
+}
+/** Reveal a cell and cascade if empty */
+function revealCell(board, point) {
+    const height = board.length;
+    const width = board[0].length;
+    const newBoard = board.map((row) => row.map((cell) => ({ ...cell })));
+    const reveal = (x, y) => {
+        if (x < 0 || x >= width || y < 0 || y >= height)
+            return;
+        if (newBoard[y][x].revealed || newBoard[y][x].flagged)
+            return;
+        newBoard[y][x].revealed = true;
+        // If empty cell (no adjacent mines), reveal neighbors
+        if (newBoard[y][x].adjacentMines === 0 && !newBoard[y][x].hasMine) {
+            for (let dy = -1; dy <= 1; dy++) {
+                for (let dx = -1; dx <= 1; dx++) {
+                    reveal(x + dx, y + dy);
+                }
+            }
+        }
+    };
+    reveal(point.x, point.y);
+    return newBoard;
+}
+/** Reveal all mines (when game is lost) */
+function revealAllMines(board) {
+    return board.map((row) => row.map((cell) => ({
+        ...cell,
+        revealed: cell.hasMine ? true : cell.revealed,
+    })));
+}
+/** Check if the game is won */
+function checkWin(board) {
+    for (const row of board) {
+        for (const cell of row) {
+            // All non-mine cells must be revealed
+            if (!cell.hasMine && !cell.revealed)
+                return false;
+        }
+    }
+    return true;
+}
+/** Count flagged cells */
+function countFlags(board) {
+    let count = 0;
+    for (const row of board) {
+        for (const cell of row) {
+            if (cell.flagged)
+                count++;
+        }
+    }
+    return count;
+}
+/** Create initial game state */
+function createInitialState(difficultyIndex) {
+    const diff = DIFFICULTIES[difficultyIndex];
+    return {
+        board: createEmptyBoard(diff.width, diff.height),
+        cursor: { x: Math.floor(diff.width / 2), y: Math.floor(diff.height / 2) },
+        status: "playing",
+        minesRemaining: diff.mines,
+        timeElapsed: 0,
+        difficultyIndex,
+        firstClick: true,
+        leaderboardPosition: 0,
+    };
+}
+/** Get cell display character */
+function getCellDisplay(cell, isCursor, gameOver) {
+    const bgColor = isCursor ? "blue" : undefined;
+    if (!cell.revealed) {
+        if (cell.flagged) {
+            // Show incorrect flags on game over
+            if (gameOver && !cell.hasMine) {
+                return { char: "✗", color: "red", bgColor };
+            }
+            return { char: "⚑", color: "red", bgColor };
+        }
+        return { char: "■", color: "gray", bgColor };
+    }
+    if (cell.hasMine) {
+        return { char: "💣", color: "red", bgColor };
+    }
+    if (cell.adjacentMines === 0) {
+        return { char: " ", bgColor };
+    }
+    const colors = {
+        1: "blue",
+        2: "green",
+        3: "red",
+        4: "#000080", // Dark blue
+        5: "#800000", // Maroon
+        6: "cyan",
+        7: "black",
+        8: "gray",
+    };
+    return {
+        char: cell.adjacentMines.toString(),
+        color: colors[cell.adjacentMines] || "white",
+        bgColor,
+    };
+}
+/** Game board component */
+function GameBoard({ board, cursor, status, }) {
+    const width = board[0].length;
+    const gameOver = status === "won" || status === "lost";
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: "gray", children: "┌" + "──".repeat(width) + "┐" }), board.map((row, y) => (_jsxs(Box, { children: [_jsx(Text, { color: "gray", children: "\u2502" }), row.map((cell, x) => {
+                        const isCursor = x === cursor.x && y === cursor.y;
+                        const display = getCellDisplay(cell, isCursor, gameOver);
+                        return (_jsx(Text, { color: display.color, backgroundColor: display.bgColor, children: display.char.length === 1 ? display.char + " " : display.char }, x));
+                    }), _jsx(Text, { color: "gray", children: "\u2502" })] }, y))), _jsx(Text, { color: "gray", children: "└" + "──".repeat(width) + "┘" })] }));
+}
+/** HUD component */
+function GameHUD({ minesRemaining, timeElapsed, difficulty, bestTime, fps, }) {
+    return (_jsxs(Box, { flexDirection: "column", marginLeft: 1, children: [_jsxs(Box, { borderStyle: "single", flexDirection: "column", paddingX: 1, children: [_jsx(Text, { bold: true, children: "Mines" }), _jsx(Text, { color: "red", children: minesRemaining.toString().padStart(3, " ") })] }), _jsxs(Box, { borderStyle: "single", flexDirection: "column", paddingX: 1, children: [_jsx(Text, { bold: true, children: "Time" }), _jsx(Text, { color: "yellow", children: formatTime(timeElapsed) })] }), _jsxs(Box, { borderStyle: "single", flexDirection: "column", paddingX: 1, children: [_jsx(Text, { bold: true, children: "Level" }), _jsx(Text, { color: "cyan", children: difficulty })] }), _jsxs(Box, { borderStyle: "single", flexDirection: "column", paddingX: 1, children: [_jsx(Text, { dimColor: true, children: "Best" }), _jsx(Text, { dimColor: true, children: formatTime(bestTime) })] }), _jsxs(Text, { dimColor: true, children: [fps, " FPS"] })] }));
+}
+/** Difficulty selector */
+function DifficultySelector({ selectedIndex, bestTimes, }) {
+    return (_jsxs(Box, { flexDirection: "column", alignItems: "center", padding: 2, children: [_jsx(Text, { bold: true, color: "cyan", children: "Select Difficulty" }), _jsx(Text, { children: " " }), DIFFICULTIES.map((diff, i) => (_jsx(Box, { children: _jsxs(Text, { color: i === selectedIndex ? "green" : "white", bold: i === selectedIndex, children: [i === selectedIndex ? "▶ " : "  ", diff.name.padEnd(8), " ", diff.width, "x", diff.height, " (", diff.mines, " ", "mines) Best: ", formatTime(bestTimes[i])] }) }, i))), _jsx(Text, { children: " " }), _jsx(Text, { dimColor: true, children: "\u2191\u2193 to select, Enter to start" })] }));
+}
+/** Game over overlay */
+function GameOverOverlay({ won, timeElapsed, leaderboardPosition, }) {
+    return (_jsxs(Box, { flexDirection: "column", alignItems: "center", justifyContent: "center", padding: 1, children: [_jsx(Text, { bold: true, color: won ? "green" : "red", children: won ? "YOU WIN!" : "GAME OVER" }), _jsxs(Text, { children: ["Time: ", _jsx(Text, { color: "yellow", children: formatTime(timeElapsed) })] }), won && leaderboardPosition > 0 && (_jsxs(Box, { flexDirection: "column", alignItems: "center", borderStyle: "double", borderColor: "green", paddingX: 2, paddingY: 1, children: [_jsx(Text, { bold: true, color: "green", children: "NEW BEST TIME!" }), _jsxs(Text, { children: ["You ranked", " ", _jsx(Text, { color: "cyan", children: leaderboardPosition === 1
+                                    ? "1st"
+                                    : leaderboardPosition === 2
+                                        ? "2nd"
+                                        : leaderboardPosition === 3
+                                            ? "3rd"
+                                            : `${leaderboardPosition}th` }), " ", "place!"] })] })), _jsx(Text, { dimColor: true, children: "R to restart | H for leaderboard | D to change difficulty" })] }));
+}
+/** Get game ID for a specific difficulty */
+function getGameIdForDifficulty(difficultyIndex) {
+    const diffName = DIFFICULTIES[difficultyIndex].name.toLowerCase();
+    return `minesweeper-${diffName}`;
+}
+/**
+ * Minesweeper game component
+ */
+export function MinesweeperGame({ hasFocus, onExit, loopAttention, onLoopAlertDismiss, onGameStateChange }) {
+    const [state, setState] = useState(() => createInitialState(0));
+    const timerRef = useRef(null);
+    const [selectedDifficulty, setSelectedDifficulty] = useState(0);
+    const scoreSubmittedRef = useRef(false);
+    const statsSubmittedRef = useRef(false);
+    const [showLoopAlert, setShowLoopAlert] = useState(false);
+    const [wasPlayingBeforeAlert, setWasPlayingBeforeAlert] = useState(false);
+    // High score persistence for current difficulty
+    const { bestTime, leaderboard, submitTime } = useBestTimes(getGameIdForDifficulty(state.difficultyIndex));
+    // Stats tracking
+    const { startSession, endSession, isSessionActive } = useGameSession("minesweeper");
+    // Report game state changes to status bar
+    useEffect(() => {
+        // Map minesweeper-specific status to generic game status
+        const mappedStatus = state.status === "won" || state.status === "lost" ? "game_over" :
+            state.status === "selecting_difficulty" || state.status === "leaderboard" ? "menu" :
+                state.status;
+        onGameStateChange?.({
+            score: state.timeElapsed, // Use time as "score" for minesweeper
+            status: mappedStatus,
+            highScore: bestTime > 0 ? bestTime : null,
+        });
+    }, [state.timeElapsed, state.status, bestTime, onGameStateChange]);
+    // Auto-pause when loop needs attention
+    useEffect(() => {
+        if (loopAttention?.needsAttention && state.status === "playing") {
+            setWasPlayingBeforeAlert(true);
+            setShowLoopAlert(true);
+            setState((prev) => ({ ...prev, status: "paused" }));
+        }
+        else if (!loopAttention?.needsAttention && showLoopAlert) {
+            setShowLoopAlert(false);
+            // Auto-resume if we were playing before the alert
+            if (wasPlayingBeforeAlert) {
+                setState((prev) => {
+                    if (prev.status === "paused") {
+                        return { ...prev, status: "playing" };
+                    }
+                    return prev;
+                });
+                setWasPlayingBeforeAlert(false);
+            }
+        }
+    }, [loopAttention?.needsAttention, state.status, showLoopAlert, wasPlayingBeforeAlert]);
+    // Get best times for all difficulties for the selector
+    const { bestTime: easyBest } = useBestTimes("minesweeper-easy");
+    const { bestTime: mediumBest } = useBestTimes("minesweeper-medium");
+    const { bestTime: hardBest } = useBestTimes("minesweeper-hard");
+    const allBestTimes = [easyBest, mediumBest, hardBest];
+    // Start session when game starts
+    useEffect(() => {
+        if (state.status === "playing" && !isSessionActive) {
+            startSession();
+        }
+    }, [state.status, isSessionActive, startSession]);
+    // Submit time when game is won
+    useEffect(() => {
+        if (state.status === "won" && !scoreSubmittedRef.current && state.timeElapsed > 0) {
+            scoreSubmittedRef.current = true;
+            submitTime(state.timeElapsed, { difficulty: DIFFICULTIES[state.difficultyIndex].name }).then((position) => {
+                if (position > 0) {
+                    setState((prev) => ({ ...prev, leaderboardPosition: position }));
+                }
+            });
+        }
+    }, [state.status, state.timeElapsed, state.difficultyIndex, submitTime]);
+    // Record stats when game ends
+    useEffect(() => {
+        if ((state.status === "won" || state.status === "lost") && !statsSubmittedRef.current) {
+            statsSubmittedRef.current = true;
+            const won = state.status === "won";
+            const customStats = {};
+            if (won && state.timeElapsed > 0) {
+                customStats.fastestWin = state.timeElapsed;
+            }
+            void endSession(0, won, Object.keys(customStats).length > 0 ? customStats : undefined);
+        }
+    }, [state.status, state.timeElapsed, endSession]);
+    // Game timer
+    useEffect(() => {
+        if (state.status === "playing" &&
+            !state.firstClick &&
+            hasFocus &&
+            !timerRef.current) {
+            timerRef.current = setInterval(() => {
+                setState((prev) => ({
+                    ...prev,
+                    timeElapsed: Math.min(prev.timeElapsed + 1, 999),
+                }));
+            }, 1000);
+        }
+        else if ((state.status !== "playing" || state.firstClick || !hasFocus) &&
+            timerRef.current) {
+            clearInterval(timerRef.current);
+            timerRef.current = null;
+        }
+        return () => {
+            if (timerRef.current) {
+                clearInterval(timerRef.current);
+                timerRef.current = null;
+            }
+        };
+    }, [state.status, state.firstClick, hasFocus]);
+    // Reveal cell
+    const reveal = useCallback(() => {
+        setState((prev) => {
+            if (prev.status !== "playing")
+                return prev;
+            const { x, y } = prev.cursor;
+            const cell = prev.board[y][x];
+            // Can't reveal flagged cells
+            if (cell.flagged)
+                return prev;
+            // Already revealed - do chord reveal if adjacent flags match adjacent mines
+            if (cell.revealed && cell.adjacentMines > 0) {
+                // Count adjacent flags
+                let flagCount = 0;
+                for (let dy = -1; dy <= 1; dy++) {
+                    for (let dx = -1; dx <= 1; dx++) {
+                        const ny = y + dy;
+                        const nx = x + dx;
+                        if (ny >= 0 &&
+                            ny < prev.board.length &&
+                            nx >= 0 &&
+                            nx < prev.board[0].length) {
+                            if (prev.board[ny][nx].flagged)
+                                flagCount++;
+                        }
+                    }
+                }
+                // If flags match, reveal adjacent non-flagged cells
+                if (flagCount === cell.adjacentMines) {
+                    let newBoard = prev.board.map((row) => row.map((c) => ({ ...c })));
+                    let hitMine = false;
+                    for (let dy = -1; dy <= 1; dy++) {
+                        for (let dx = -1; dx <= 1; dx++) {
+                            const ny = y + dy;
+                            const nx = x + dx;
+                            if (ny >= 0 &&
+                                ny < newBoard.length &&
+                                nx >= 0 &&
+                                nx < newBoard[0].length) {
+                                const neighbor = newBoard[ny][nx];
+                                if (!neighbor.flagged && !neighbor.revealed) {
+                                    if (neighbor.hasMine) {
+                                        hitMine = true;
+                                    }
+                                    newBoard = revealCell(newBoard, { x: nx, y: ny });
+                                }
+                            }
+                        }
+                    }
+                    if (hitMine) {
+                        return {
+                            ...prev,
+                            board: revealAllMines(newBoard),
+                            status: "lost",
+                        };
+                    }
+                    if (checkWin(newBoard)) {
+                        return {
+                            ...prev,
+                            board: newBoard,
+                            status: "won",
+                        };
+                    }
+                    return { ...prev, board: newBoard };
+                }
+                return prev;
+            }
+            // First click - generate mines
+            if (prev.firstClick) {
+                const diff = DIFFICULTIES[prev.difficultyIndex];
+                let newBoard = placeMines(prev.board, diff.mines, prev.cursor);
+                newBoard = revealCell(newBoard, prev.cursor);
+                return {
+                    ...prev,
+                    board: newBoard,
+                    firstClick: false,
+                };
+            }
+            // Hit a mine
+            if (cell.hasMine) {
+                return {
+                    ...prev,
+                    board: revealAllMines(prev.board),
+                    status: "lost",
+                };
+            }
+            // Reveal the cell
+            const newBoard = revealCell(prev.board, prev.cursor);
+            // Check win condition
+            if (checkWin(newBoard)) {
+                return {
+                    ...prev,
+                    board: newBoard,
+                    status: "won",
+                };
+            }
+            return { ...prev, board: newBoard };
+        });
+    }, []);
+    // Toggle flag
+    const toggleFlag = useCallback(() => {
+        setState((prev) => {
+            if (prev.status !== "playing" || prev.firstClick)
+                return prev;
+            const { x, y } = prev.cursor;
+            const cell = prev.board[y][x];
+            // Can't flag revealed cells
+            if (cell.revealed)
+                return prev;
+            const newBoard = prev.board.map((row) => row.map((c) => ({ ...c })));
+            newBoard[y][x].flagged = !newBoard[y][x].flagged;
+            const diff = DIFFICULTIES[prev.difficultyIndex];
+            const flaggedCount = countFlags(newBoard);
+            return {
+                ...prev,
+                board: newBoard,
+                minesRemaining: diff.mines - flaggedCount,
+            };
+        });
+    }, []);
+    // Move cursor
+    const moveCursor = useCallback((dx, dy) => {
+        setState((prev) => {
+            if (prev.status === "selecting_difficulty")
+                return prev;
+            const width = prev.board[0].length;
+            const height = prev.board.length;
+            const newX = Math.max(0, Math.min(width - 1, prev.cursor.x + dx));
+            const newY = Math.max(0, Math.min(height - 1, prev.cursor.y + dy));
+            return {
+                ...prev,
+                cursor: { x: newX, y: newY },
+            };
+        });
+    }, []);
+    // Game loop for FPS display
+    const { loopInfo } = useGameLoop({
+        targetFps: 10, // Low FPS needed, mostly cursor-driven
+        isActive: hasFocus && state.status === "playing",
+    });
+    // Handle input
+    useInput((input, key) => {
+        if (!hasFocus)
+            return;
+        // Exit
+        if (input === "q" || input === "Q" || key.escape) {
+            onExit();
+            return;
+        }
+        // Difficulty selection mode
+        if (state.status === "selecting_difficulty") {
+            if (key.upArrow) {
+                setSelectedDifficulty((prev) => prev > 0 ? prev - 1 : DIFFICULTIES.length - 1);
+            }
+            else if (key.downArrow) {
+                setSelectedDifficulty((prev) => prev < DIFFICULTIES.length - 1 ? prev + 1 : 0);
+            }
+            else if (key.return) {
+                scoreSubmittedRef.current = false;
+                setState(createInitialState(selectedDifficulty));
+            }
+            return;
+        }
+        // Change difficulty
+        if (input === "d" || input === "D") {
+            setSelectedDifficulty(state.difficultyIndex);
+            setState((prev) => ({ ...prev, status: "selecting_difficulty" }));
+            return;
+        }
+        // Show leaderboard (when game over)
+        if ((input === "h" || input === "H") && (state.status === "won" || state.status === "lost" || state.status === "leaderboard")) {
+            setState((prev) => ({
+                ...prev,
+                status: prev.status === "leaderboard" ? "won" : "leaderboard",
+            }));
+            return;
+        }
+        // Dismiss loop alert with Enter key when paused and showing alert
+        if (key.return && showLoopAlert && state.status === "paused") {
+            setShowLoopAlert(false);
+            onLoopAlertDismiss?.();
+            return;
+        }
+        // Pause/unpause
+        if (input === "p" || input === "P") {
+            // If we're showing loop alert, dismiss it and resume
+            if (showLoopAlert) {
+                setShowLoopAlert(false);
+                setWasPlayingBeforeAlert(false);
+            }
+            setState((prev) => ({
+                ...prev,
+                status: prev.status === "playing" ? "paused" : prev.status === "paused" ? "playing" : prev.status,
+            }));
+            return;
+        }
+        // Restart
+        if (input === "r" || input === "R") {
+            scoreSubmittedRef.current = false;
+            statsSubmittedRef.current = false;
+            setState(createInitialState(state.difficultyIndex));
+            return;
+        }
+        if (state.status !== "playing")
+            return;
+        // Movement
+        if (key.leftArrow || input === "a" || input === "A") {
+            moveCursor(-1, 0);
+        }
+        else if (key.rightArrow || input === "d" || input === "D") {
+            moveCursor(1, 0);
+        }
+        else if (key.upArrow || input === "w" || input === "W") {
+            moveCursor(0, -1);
+        }
+        else if (key.downArrow || input === "s" || input === "S") {
+            moveCursor(0, 1);
+        }
+        else if (input === " " || key.return) {
+            reveal();
+        }
+        else if (input === "f" || input === "F") {
+            toggleFlag();
+        }
+    }, { isActive: hasFocus });
+    const diff = DIFFICULTIES[state.difficultyIndex];
+    return (_jsxs(Box, { flexDirection: "column", height: "100%", children: [state.status === "selecting_difficulty" ? (_jsx(Box, { flexGrow: 1, justifyContent: "center", alignItems: "center", children: _jsx(DifficultySelector, { selectedIndex: selectedDifficulty, bestTimes: allBestTimes }) })) : state.status === "leaderboard" ? (_jsx(Box, { flexGrow: 1, justifyContent: "center", alignItems: "center", children: _jsx(Leaderboard, { title: `${diff.name} Best Times`, scores: leaderboard, lowerIsBetter: true, formatScore: formatTime, highlightPosition: state.leaderboardPosition }) })) : state.status === "paused" && showLoopAlert && loopAttention ? (_jsx(Box, { flexGrow: 1, justifyContent: "center", alignItems: "center", children: _jsx(LoopAlertOverlay, { attention: loopAttention, onDismiss: onLoopAlertDismiss }) })) : state.status === "paused" ? (_jsx(Box, { flexGrow: 1, justifyContent: "center", alignItems: "center", children: _jsxs(Box, { flexDirection: "column", alignItems: "center", justifyContent: "center", padding: 1, children: [_jsx(Text, { bold: true, color: "yellow", children: "PAUSED" }), _jsx(Text, { dimColor: true, children: "Press P to resume" })] }) })) : state.status === "won" || state.status === "lost" ? (_jsxs(Box, { flexDirection: "column", flexGrow: 1, children: [_jsxs(Box, { children: [_jsx(GameBoard, { board: state.board, cursor: state.cursor, status: state.status }), _jsx(GameHUD, { minesRemaining: state.minesRemaining, timeElapsed: state.timeElapsed, difficulty: diff.name, bestTime: bestTime, fps: loopInfo.fps })] }), _jsx(GameOverOverlay, { won: state.status === "won", timeElapsed: state.timeElapsed, leaderboardPosition: state.leaderboardPosition })] })) : (_jsxs(Box, { flexGrow: 1, children: [_jsx(GameBoard, { board: state.board, cursor: state.cursor, status: state.status }), _jsx(GameHUD, { minesRemaining: state.minesRemaining, timeElapsed: state.timeElapsed, difficulty: diff.name, bestTime: bestTime, fps: loopInfo.fps })] })), _jsx(Box, { paddingX: 1, children: _jsx(Text, { dimColor: true, children: hasFocus
+                        ? state.status === "leaderboard"
+                            ? "H: Back | R: Restart | D: Difficulty | Q: Exit"
+                            : "←→↑↓: Move | Space: Reveal | F: Flag | D: Difficulty | R: Restart | H: Times | Q: Exit"
+                        : "Press Tab to focus" }) })] }));
+}
+export default MinesweeperGame;
+//# sourceMappingURL=MinesweeperGame.js.map