@compilr-dev/cli 0.5.0 → 0.5.1

package/dist/games/scores.d.ts

@@ -0,0 +1,69 @@
+/**
+ * High Scores System
+ *
+ * Manages high scores for all games.
+ */
+export interface HighScore {
+    name: string;
+    score: number;
+    level: number;
+    date: string;
+}
+export interface ScoresData {
+    [gameId: string]: HighScore[];
+}
+/**
+ * Get all scores data
+ */
+export declare function getScoresData(): ScoresData;
+/**
+ * Get high scores for a specific game
+ */
+export declare function getHighScores(gameId: string): HighScore[];
+/**
+ * Check if a score qualifies for the leaderboard (top 10)
+ */
+export declare function isLeaderboardScore(gameId: string, score: number): boolean;
+/**
+ * Check if a score beats the current high score (#1)
+ * This is the "NEW HIGH SCORE!" condition for coin award
+ */
+export declare function isNewHighScore(gameId: string, score: number): boolean;
+/**
+ * Check if a score qualifies for the leaderboard
+ * @deprecated Use isLeaderboardScore for top-10 check, isNewHighScore for #1 check
+ */
+export declare function isHighScore(gameId: string, score: number): boolean;
+/**
+ * Get the rank a score would achieve (1-based, or null if not a high score)
+ */
+export declare function getScoreRank(gameId: string, score: number): number | null;
+/**
+ * Add a new high score
+ * Returns the rank achieved (1-based) or null if didn't make the leaderboard
+ */
+export declare function addHighScore(gameId: string, name: string, score: number, level: number): number | null;
+/**
+ * Get the player's best score for a game
+ */
+export declare function getBestScore(gameId: string): HighScore | null;
+/**
+ * Clear high scores for a game (for testing)
+ */
+export declare function clearHighScores(gameId: string): void;
+/**
+ * Clear all high scores (for testing)
+ */
+export declare function clearAllHighScores(): void;
+/**
+ * Clear cache (for testing)
+ */
+export declare function clearScoresCache(): void;
+/**
+ * Format a score number with commas
+ */
+export declare function formatScore(score: number): string;
+/**
+ * Format a high score entry for display
+ */
+export declare function formatHighScoreEntry(rank: number, entry: HighScore, maxScoreWidth?: number): string;

package/dist/games/scores.js

@@ -0,0 +1,191 @@
+/**
+ * High Scores System
+ *
+ * Manages high scores for all games.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+// =============================================================================
+// Constants
+// =============================================================================
+const CONFIG_DIR = path.join(os.homedir(), '.compilr-dev');
+const SCORES_FILE = path.join(CONFIG_DIR, 'highscores.json');
+const MAX_SCORES_PER_GAME = 10;
+// =============================================================================
+// In-memory cache
+// =============================================================================
+let scoresCache = null;
+// =============================================================================
+// Persistence
+// =============================================================================
+function loadFromDisk() {
+    try {
+        if (fs.existsSync(SCORES_FILE)) {
+            const data = fs.readFileSync(SCORES_FILE, 'utf-8');
+            return JSON.parse(data);
+        }
+    }
+    catch {
+        // Ignore errors
+    }
+    return {};
+}
+function saveToDisk(data) {
+    try {
+        fs.mkdirSync(CONFIG_DIR, { recursive: true });
+        fs.writeFileSync(SCORES_FILE, JSON.stringify(data, null, 2), 'utf-8');
+    }
+    catch (error) {
+        console.error('Failed to save high scores:', error);
+    }
+}
+// =============================================================================
+// Public API
+// =============================================================================
+/**
+ * Get all scores data
+ */
+export function getScoresData() {
+    if (scoresCache) {
+        return scoresCache;
+    }
+    scoresCache = loadFromDisk();
+    return scoresCache;
+}
+/**
+ * Get high scores for a specific game
+ */
+export function getHighScores(gameId) {
+    const data = getScoresData();
+    return data[gameId] ?? [];
+}
+/**
+ * Check if a score qualifies for the leaderboard (top 10)
+ */
+export function isLeaderboardScore(gameId, score) {
+    const scores = getHighScores(gameId);
+    if (scores.length < MAX_SCORES_PER_GAME) {
+        return true;
+    }
+    const lowestScore = scores[scores.length - 1].score;
+    return score > lowestScore;
+}
+/**
+ * Check if a score beats the current high score (#1)
+ * This is the "NEW HIGH SCORE!" condition for coin award
+ */
+export function isNewHighScore(gameId, score) {
+    const scores = getHighScores(gameId);
+    if (scores.length === 0) {
+        return true; // First score is always a high score
+    }
+    return score > scores[0].score; // Must beat #1
+}
+/**
+ * Check if a score qualifies for the leaderboard
+ * @deprecated Use isLeaderboardScore for top-10 check, isNewHighScore for #1 check
+ */
+export function isHighScore(gameId, score) {
+    return isLeaderboardScore(gameId, score);
+}
+/**
+ * Get the rank a score would achieve (1-based, or null if not a high score)
+ */
+export function getScoreRank(gameId, score) {
+    const scores = getHighScores(gameId);
+    // Find where this score would be inserted
+    let rank = 1;
+    for (const existing of scores) {
+        if (score > existing.score) {
+            break;
+        }
+        rank++;
+    }
+    // Check if it makes the leaderboard
+    if (rank > MAX_SCORES_PER_GAME) {
+        return null;
+    }
+    return rank;
+}
+/**
+ * Add a new high score
+ * Returns the rank achieved (1-based) or null if didn't make the leaderboard
+ */
+export function addHighScore(gameId, name, score, level) {
+    const data = getScoresData();
+    const partialData = data;
+    const scores = partialData[gameId] ?? [];
+    const newScore = {
+        name: name.toUpperCase().slice(0, 3).padEnd(3, ' '),
+        score,
+        level,
+        date: new Date().toISOString().split('T')[0],
+    };
+    // Insert in sorted order (descending by score)
+    let insertIndex = 0;
+    for (let i = 0; i < scores.length; i++) {
+        if (score > scores[i].score) {
+            break;
+        }
+        insertIndex++;
+    }
+    scores.splice(insertIndex, 0, newScore);
+    // Keep only top scores
+    if (scores.length > MAX_SCORES_PER_GAME) {
+        scores.length = MAX_SCORES_PER_GAME;
+    }
+    data[gameId] = scores;
+    scoresCache = data;
+    saveToDisk(data);
+    // Return rank if made the leaderboard
+    if (insertIndex < MAX_SCORES_PER_GAME) {
+        return insertIndex + 1;
+    }
+    return null;
+}
+/**
+ * Get the player's best score for a game
+ */
+export function getBestScore(gameId) {
+    const scores = getHighScores(gameId);
+    return scores.length > 0 ? scores[0] : null;
+}
+/**
+ * Clear high scores for a game (for testing)
+ */
+export function clearHighScores(gameId) {
+    const data = getScoresData();
+    // Create a new object without the specified gameId
+    const { [gameId]: _removed, ...rest } = data;
+    scoresCache = rest;
+    saveToDisk(rest);
+}
+/**
+ * Clear all high scores (for testing)
+ */
+export function clearAllHighScores() {
+    scoresCache = {};
+    saveToDisk({});
+}
+/**
+ * Clear cache (for testing)
+ */
+export function clearScoresCache() {
+    scoresCache = null;
+}
+/**
+ * Format a score number with commas
+ */
+export function formatScore(score) {
+    return score.toLocaleString();
+}
+/**
+ * Format a high score entry for display
+ */
+export function formatHighScoreEntry(rank, entry, maxScoreWidth = 10) {
+    const rankStr = String(rank).padStart(2, ' ');
+    const scoreStr = formatScore(entry.score).padStart(maxScoreWidth, '.');
+    const levelStr = `Lv.${String(entry.level).padStart(2, ' ')}`;
+    return `${rankStr}. ${entry.name} ${scoreStr}  ${levelStr}  ${entry.date}`;
+}

package/dist/games/tetris/board.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Tetris Board
+ *
+ * Game board logic - collision detection, line clearing, etc.
+ */
+import type { Piece } from './pieces.js';
+export declare const BOARD_WIDTH = 10;
+export declare const BOARD_HEIGHT = 20;
+export declare const HIDDEN_ROWS = 2;
+export interface Position {
+    x: number;
+    y: number;
+}
+export type Board = number[][];
+/**
+ * Create an empty board
+ */
+export declare function createBoard(): Board;
+/**
+ * Check if a position is within bounds
+ */
+export declare function isInBounds(x: number, y: number): boolean;
+/**
+ * Check if a piece can be placed at a position
+ */
+export declare function canPlace(board: Board, piece: Piece, position: Position): boolean;
+/**
+ * Place a piece on the board (mutates board)
+ */
+export declare function placePiece(board: Board, piece: Piece, position: Position): void;
+/**
+ * Check for and clear completed lines
+ * Returns the number of lines cleared
+ */
+export declare function clearLines(board: Board): number;
+/**
+ * Get the spawn position for a new piece
+ */
+export declare function getSpawnPosition(piece: Piece): Position;
+/**
+ * Get the ghost piece position (where piece would land)
+ */
+export declare function getGhostPosition(board: Board, piece: Piece, position: Position): Position;
+/**
+ * Check if the game is over (piece can't spawn)
+ */
+export declare function isGameOver(board: Board, piece: Piece): boolean;
+/**
+ * Calculate drop distance for hard drop scoring
+ */
+export declare function getDropDistance(board: Board, piece: Piece, position: Position): number;
+/**
+ * Clone a board (for preview/undo)
+ */
+export declare function cloneBoard(board: Board): Board;
+/**
+ * Get the board with current piece overlaid (for rendering)
+ */
+export declare function getBoardWithPiece(board: Board, piece: Piece | null, position: Position | null, showGhost?: boolean): Board;

package/dist/games/tetris/board.js

@@ -0,0 +1,170 @@
+/**
+ * Tetris Board
+ *
+ * Game board logic - collision detection, line clearing, etc.
+ */
+// =============================================================================
+// Constants
+// =============================================================================
+export const BOARD_WIDTH = 10;
+export const BOARD_HEIGHT = 20;
+export const HIDDEN_ROWS = 2; // Extra rows above visible area for spawning
+// =============================================================================
+// Board Functions
+// =============================================================================
+/**
+ * Create an empty board
+ */
+export function createBoard() {
+    const board = [];
+    for (let row = 0; row < BOARD_HEIGHT + HIDDEN_ROWS; row++) {
+        board.push(new Array(BOARD_WIDTH).fill(0));
+    }
+    return board;
+}
+/**
+ * Check if a position is within bounds
+ */
+export function isInBounds(x, y) {
+    return x >= 0 && x < BOARD_WIDTH && y >= 0 && y < BOARD_HEIGHT + HIDDEN_ROWS;
+}
+/**
+ * Check if a piece can be placed at a position
+ */
+export function canPlace(board, piece, position) {
+    for (let row = 0; row < piece.shape.length; row++) {
+        for (let col = 0; col < piece.shape[row].length; col++) {
+            if (piece.shape[row][col]) {
+                const boardX = position.x + col;
+                const boardY = position.y + row;
+                // Check bounds
+                if (!isInBounds(boardX, boardY)) {
+                    return false;
+                }
+                // Check collision with existing pieces
+                if (board[boardY][boardX] !== 0) {
+                    return false;
+                }
+            }
+        }
+    }
+    return true;
+}
+/**
+ * Place a piece on the board (mutates board)
+ */
+export function placePiece(board, piece, position) {
+    for (let row = 0; row < piece.shape.length; row++) {
+        for (let col = 0; col < piece.shape[row].length; col++) {
+            if (piece.shape[row][col]) {
+                const boardX = position.x + col;
+                const boardY = position.y + row;
+                if (isInBounds(boardX, boardY)) {
+                    board[boardY][boardX] = piece.color;
+                }
+            }
+        }
+    }
+}
+/**
+ * Check for and clear completed lines
+ * Returns the number of lines cleared
+ */
+export function clearLines(board) {
+    let linesCleared = 0;
+    // Check from bottom to top
+    for (let row = BOARD_HEIGHT + HIDDEN_ROWS - 1; row >= 0; row--) {
+        if (isLineFull(board, row)) {
+            // Remove the line
+            board.splice(row, 1);
+            // Add a new empty line at the top
+            board.unshift(new Array(BOARD_WIDTH).fill(0));
+            linesCleared++;
+            // Check the same row again (since we shifted down)
+            row++;
+        }
+    }
+    return linesCleared;
+}
+/**
+ * Check if a line is full
+ */
+function isLineFull(board, row) {
+    return board[row].every(cell => cell !== 0);
+}
+/**
+ * Get the spawn position for a new piece
+ */
+export function getSpawnPosition(piece) {
+    // Center horizontally
+    const x = Math.floor((BOARD_WIDTH - piece.shape[0].length) / 2);
+    // Start at top (in hidden area)
+    const y = 0;
+    return { x, y };
+}
+/**
+ * Get the ghost piece position (where piece would land)
+ */
+export function getGhostPosition(board, piece, position) {
+    let ghostY = position.y;
+    while (canPlace(board, piece, { x: position.x, y: ghostY + 1 })) {
+        ghostY++;
+    }
+    return { x: position.x, y: ghostY };
+}
+/**
+ * Check if the game is over (piece can't spawn)
+ */
+export function isGameOver(board, piece) {
+    const spawnPos = getSpawnPosition(piece);
+    return !canPlace(board, piece, spawnPos);
+}
+/**
+ * Calculate drop distance for hard drop scoring
+ */
+export function getDropDistance(board, piece, position) {
+    const ghostPos = getGhostPosition(board, piece, position);
+    return ghostPos.y - position.y;
+}
+/**
+ * Clone a board (for preview/undo)
+ */
+export function cloneBoard(board) {
+    return board.map(row => [...row]);
+}
+/**
+ * Get the board with current piece overlaid (for rendering)
+ */
+export function getBoardWithPiece(board, piece, position, showGhost = true) {
+    const display = cloneBoard(board);
+    if (piece && position) {
+        // Draw ghost piece first (if enabled)
+        if (showGhost) {
+            const ghostPos = getGhostPosition(board, piece, position);
+            for (let row = 0; row < piece.shape.length; row++) {
+                for (let col = 0; col < piece.shape[row].length; col++) {
+                    if (piece.shape[row][col]) {
+                        const boardX = ghostPos.x + col;
+                        const boardY = ghostPos.y + row;
+                        if (isInBounds(boardX, boardY) && display[boardY][boardX] === 0) {
+                            display[boardY][boardX] = -piece.color; // Negative for ghost
+                        }
+                    }
+                }
+            }
+        }
+        // Draw actual piece
+        for (let row = 0; row < piece.shape.length; row++) {
+            for (let col = 0; col < piece.shape[row].length; col++) {
+                if (piece.shape[row][col]) {
+                    const boardX = position.x + col;
+                    const boardY = position.y + row;
+                    if (isInBounds(boardX, boardY)) {
+                        display[boardY][boardX] = piece.color;
+                    }
+                }
+            }
+        }
+    }
+    return display;
+}

package/dist/games/tetris/index.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Tetris Game
+ *
+ * The main Tetris game implementation.
+ */
+import { GameBase } from "../game-base.js";
+import { type Board, type Position } from "./board.js";
+import { type Piece, type PieceType } from "./pieces.js";
+export interface TetrisState {
+    board: Board;
+    currentPiece: Piece | null;
+    nextPiece: Piece | null;
+    heldPiece: Piece | null;
+    canHold: boolean;
+    position: Position;
+    rotation: number;
+    score: number;
+    level: number;
+    lines: number;
+    gameOver: boolean;
+    pieceBag: PieceType[];
+}
+export declare class TetrisGame extends GameBase {
+    private readonly state;
+    private dropTimer;
+    private dropInterval;
+    private readonly colors;
+    private softDropping;
+    private enteringInitials;
+    private initials;
+    private initialIndex;
+    private finalScore;
+    private finalLevel;
+    private showingPreGame;
+    private isNewRecord;
+    constructor();
+    /**
+     * Create initial game state
+     */
+    private createInitialState;
+    /**
+     * Get next piece from bag (refill if empty)
+     */
+    private getNextPiece;
+    /**
+     * Spawn a new piece
+     */
+    private spawnPiece;
+    /**
+     * Move piece horizontally
+     */
+    private move;
+    /**
+     * Move piece down (soft drop)
+     */
+    private moveDown;
+    /**
+     * Rotate piece
+     */
+    private rotate;
+    /**
+     * Hard drop - instantly place piece
+     */
+    private hardDrop;
+    /**
+     * Lock piece in place and check for line clears
+     * Returns true if game ended
+     */
+    private lockPiece;
+    /**
+     * Hold piece
+     */
+    private holdPiece;
+    /**
+     * Update drop speed based on level
+     */
+    private updateDropSpeed;
+    /**
+     * Handle game over - check for high score
+     */
+    private handleGameOver;
+    /**
+     * Submit high score
+     */
+    private submitHighScore;
+    protected onStart(): void;
+    /**
+     * Start the actual game (after pre-game screen)
+     */
+    private startGame;
+    protected onQuit(): void;
+    protected onPause(): void;
+    protected onResume(): void;
+    protected onKeyPress(key: string, raw: Buffer): void;
+    private handleInitialsInput;
+    protected update(delta: number): void;
+    protected render(): void;
+    private drawBoard;
+    private drawSidePanel;
+    private drawPiecePreview;
+    private drawPauseOverlay;
+    private drawGameOverOverlay;
+    private drawHighScoreEntry;
+    private drawPreGameScreen;
+}
+/**
+ * Launch Tetris game
+ */
+export declare function playTetris(): Promise<void>;