@compilr-dev/cli 0.4.0 → 0.5.1

package/dist/games/tetris/index.js

@@ -0,0 +1,610 @@
+/**
+ * Tetris Game
+ *
+ * The main Tetris game implementation.
+ */
+import { GameBase } from "../game-base.js";
+import { createBoard, canPlace, placePiece, clearLines, getSpawnPosition, getGhostPosition, getDropDistance, getBoardWithPiece, BOARD_WIDTH, BOARD_HEIGHT, HIDDEN_ROWS, } from "./board.js";
+import { createPiece, rotatePiece, generatePieceBag, } from "./pieces.js";
+import { getGameColors } from "./renderer.js";
+import { isLeaderboardScore, isNewHighScore, addHighScore } from "../scores.js";
+import { awardHighScore, spendCoins, COIN_COST_START_GAME } from "../coins.js";
+// =============================================================================
+// Constants
+// =============================================================================
+const GAME_ID = "tetris";
+const CONFIG = {
+    title: "TETRIS",
+    minWidth: 60,
+    minHeight: 24,
+    targetFps: 30,
+};
+// Scoring (based on Tetris Guideline)
+const SCORE_SINGLE = 100;
+const SCORE_DOUBLE = 300;
+const SCORE_TRIPLE = 500;
+const SCORE_TETRIS = 800;
+const SCORE_SOFT_DROP = 1;
+const SCORE_HARD_DROP = 2;
+// Speed (milliseconds between drops)
+const BASE_DROP_INTERVAL = 800;
+const MIN_DROP_INTERVAL = 50;
+const SPEED_DECREASE_PER_LEVEL = 0.2; // 20% faster per level
+// =============================================================================
+// Tetris Game Class
+// =============================================================================
+export class TetrisGame extends GameBase {
+    state;
+    dropTimer = 0;
+    dropInterval = BASE_DROP_INTERVAL;
+    colors;
+    softDropping = false;
+    enteringInitials = false;
+    initials = ["A", "A", "A"];
+    initialIndex = 0;
+    finalScore = 0;
+    finalLevel = 0;
+    showingPreGame = true;
+    isNewRecord = false;
+    constructor() {
+        super(CONFIG);
+        this.state = this.createInitialState();
+        this.colors = getGameColors();
+    }
+    /**
+     * Create initial game state
+     */
+    createInitialState() {
+        const bag = generatePieceBag();
+        const firstType = bag.pop();
+        const secondType = bag.pop();
+        if (!firstType || !secondType) {
+            throw new Error("Failed to generate piece bag");
+        }
+        return {
+            board: createBoard(),
+            currentPiece: createPiece(firstType),
+            nextPiece: createPiece(secondType),
+            heldPiece: null,
+            canHold: true,
+            position: { x: 0, y: 0 },
+            rotation: 0,
+            score: 0,
+            level: 1,
+            lines: 0,
+            gameOver: false,
+            pieceBag: bag,
+        };
+    }
+    /**
+     * Get next piece from bag (refill if empty)
+     */
+    getNextPiece() {
+        if (this.state.pieceBag.length === 0) {
+            this.state.pieceBag = generatePieceBag();
+        }
+        const type = this.state.pieceBag.pop();
+        if (!type) {
+            throw new Error("Empty piece bag");
+        }
+        return createPiece(type);
+    }
+    /**
+     * Spawn a new piece
+     */
+    spawnPiece() {
+        this.state.currentPiece = this.state.nextPiece;
+        this.state.nextPiece = this.getNextPiece();
+        this.state.rotation = 0;
+        this.state.canHold = true;
+        if (this.state.currentPiece) {
+            const spawnPos = getSpawnPosition(this.state.currentPiece);
+            this.state.position = spawnPos;
+            // Check if piece can spawn (game over check)
+            if (!canPlace(this.state.board, this.state.currentPiece, this.state.position)) {
+                this.state.gameOver = true;
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Move piece horizontally
+     */
+    move(dx) {
+        if (!this.state.currentPiece)
+            return false;
+        const newPos = { x: this.state.position.x + dx, y: this.state.position.y };
+        if (canPlace(this.state.board, this.state.currentPiece, newPos)) {
+            this.state.position = newPos;
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Move piece down (soft drop)
+     */
+    moveDown() {
+        if (!this.state.currentPiece)
+            return false;
+        const newPos = { x: this.state.position.x, y: this.state.position.y + 1 };
+        if (canPlace(this.state.board, this.state.currentPiece, newPos)) {
+            this.state.position = newPos;
+            if (this.softDropping) {
+                this.state.score += SCORE_SOFT_DROP;
+            }
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Rotate piece
+     */
+    rotate(direction) {
+        if (!this.state.currentPiece)
+            return false;
+        const newRotation = (this.state.rotation + direction + 4) % 4;
+        const rotated = rotatePiece(this.state.currentPiece, newRotation);
+        // Try basic rotation
+        if (canPlace(this.state.board, rotated, this.state.position)) {
+            this.state.currentPiece = rotated;
+            this.state.rotation = newRotation;
+            return true;
+        }
+        // Wall kick - try offset positions
+        const kicks = [
+            { x: 1, y: 0 },
+            { x: -1, y: 0 },
+            { x: 0, y: -1 },
+            { x: 1, y: -1 },
+            { x: -1, y: -1 },
+        ];
+        for (const kick of kicks) {
+            const kickPos = {
+                x: this.state.position.x + kick.x,
+                y: this.state.position.y + kick.y,
+            };
+            if (canPlace(this.state.board, rotated, kickPos)) {
+                this.state.currentPiece = rotated;
+                this.state.rotation = newRotation;
+                this.state.position = kickPos;
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Hard drop - instantly place piece
+     */
+    hardDrop() {
+        if (!this.state.currentPiece)
+            return;
+        const distance = getDropDistance(this.state.board, this.state.currentPiece, this.state.position);
+        this.state.score += distance * SCORE_HARD_DROP;
+        const ghostPos = getGhostPosition(this.state.board, this.state.currentPiece, this.state.position);
+        this.state.position = ghostPos;
+        this.lockPiece();
+    }
+    /**
+     * Lock piece in place and check for line clears
+     * Returns true if game ended
+     */
+    lockPiece() {
+        if (!this.state.currentPiece)
+            return false;
+        placePiece(this.state.board, this.state.currentPiece, this.state.position);
+        const linesCleared = clearLines(this.state.board);
+        this.state.lines += linesCleared;
+        // Score based on lines cleared
+        const lineScores = [
+            0,
+            SCORE_SINGLE,
+            SCORE_DOUBLE,
+            SCORE_TRIPLE,
+            SCORE_TETRIS,
+        ];
+        this.state.score += (lineScores[linesCleared] ?? 0) * this.state.level;
+        // Level up every 10 lines
+        const newLevel = Math.floor(this.state.lines / 10) + 1;
+        if (newLevel > this.state.level) {
+            this.state.level = newLevel;
+            this.updateDropSpeed();
+        }
+        // Spawn next piece
+        this.spawnPiece();
+        return this.state.gameOver;
+    }
+    /**
+     * Hold piece
+     */
+    holdPiece() {
+        if (!this.state.currentPiece || !this.state.canHold)
+            return;
+        const currentType = this.state.currentPiece.type;
+        if (this.state.heldPiece) {
+            // Swap with held piece
+            const heldType = this.state.heldPiece.type;
+            this.state.currentPiece = createPiece(heldType);
+            this.state.heldPiece = createPiece(currentType);
+        }
+        else {
+            // Hold current, get next
+            this.state.heldPiece = createPiece(currentType);
+            this.state.currentPiece = this.state.nextPiece;
+            this.state.nextPiece = this.getNextPiece();
+        }
+        // Reset position
+        if (this.state.currentPiece) {
+            this.state.position = getSpawnPosition(this.state.currentPiece);
+        }
+        this.state.rotation = 0;
+        this.state.canHold = false;
+    }
+    /**
+     * Update drop speed based on level
+     */
+    updateDropSpeed() {
+        const speedMultiplier = Math.pow(1 - SPEED_DECREASE_PER_LEVEL, this.state.level - 1);
+        this.dropInterval = Math.max(MIN_DROP_INTERVAL, BASE_DROP_INTERVAL * speedMultiplier);
+    }
+    /**
+     * Handle game over - check for high score
+     */
+    handleGameOver() {
+        this.finalScore = this.state.score;
+        this.finalLevel = this.state.level;
+        // Check if score qualifies for leaderboard (top 10)
+        if (isLeaderboardScore(GAME_ID, this.finalScore)) {
+            this.enteringInitials = true;
+            this.initials = ["A", "A", "A"];
+            this.initialIndex = 0;
+            // Check if this beats the #1 score (for coin award)
+            this.isNewRecord = isNewHighScore(GAME_ID, this.finalScore);
+        }
+    }
+    /**
+     * Submit high score
+     */
+    submitHighScore() {
+        const name = this.initials.join("");
+        addHighScore(GAME_ID, name, this.finalScore, this.finalLevel);
+        // Only award coin for beating #1, not just making top 10
+        if (this.isNewRecord) {
+            awardHighScore();
+        }
+        this.enteringInitials = false;
+    }
+    // =============================================================================
+    // GameBase Implementation
+    // =============================================================================
+    onStart() {
+        // Show pre-game screen first
+        if (this.showingPreGame) {
+            this.render();
+            return;
+        }
+        // Initialize first piece position
+        if (this.state.currentPiece) {
+            this.state.position = getSpawnPosition(this.state.currentPiece);
+        }
+        this.updateDropSpeed();
+        this.render();
+    }
+    /**
+     * Start the actual game (after pre-game screen)
+     */
+    startGame() {
+        // Spend the coin now that user committed to playing
+        spendCoins(COIN_COST_START_GAME);
+        this.showingPreGame = false;
+        if (this.state.currentPiece) {
+            this.state.position = getSpawnPosition(this.state.currentPiece);
+        }
+        this.updateDropSpeed();
+        this.render();
+    }
+    onQuit() {
+        // Nothing special needed
+    }
+    onPause() {
+        this.render(); // Redraw with pause overlay
+    }
+    onResume() {
+        this.render();
+    }
+    onKeyPress(key, raw) {
+        // Handle pre-game screen - any key starts (except Q to quit)
+        if (this.showingPreGame) {
+            if (key === "q" || key === "Q") {
+                this.quit();
+            }
+            else {
+                this.startGame();
+            }
+            return;
+        }
+        // Handle high score initials entry
+        if (this.enteringInitials) {
+            this.handleInitialsInput(key, raw);
+            this.render();
+            return;
+        }
+        // Handle game over - any key to exit
+        if (this.state.gameOver) {
+            this.quit();
+            return;
+        }
+        // Game controls
+        switch (key) {
+            case "\x1b[D": // Left arrow
+            case "a":
+                this.move(-1);
+                break;
+            case "\x1b[C": // Right arrow
+            case "d":
+                this.move(1);
+                break;
+            case "\x1b[B": // Down arrow
+            case "s":
+                this.softDropping = true;
+                this.moveDown();
+                this.softDropping = false;
+                break;
+            case "\x1b[A": // Up arrow
+            case "w":
+                this.rotate(1); // Clockwise
+                break;
+            case "z":
+                this.rotate(-1); // Counter-clockwise
+                break;
+            case " ": // Space - hard drop
+                this.hardDrop();
+                break;
+            case "c": // Hold
+            case "h":
+                this.holdPiece();
+                break;
+        }
+        this.render();
+    }
+    handleInitialsInput(key, raw) {
+        // Letter keys
+        if (/^[a-zA-Z]$/.test(key)) {
+            this.initials[this.initialIndex] = key.toUpperCase();
+            if (this.initialIndex < 2) {
+                this.initialIndex++;
+            }
+            return;
+        }
+        // Arrow keys to navigate
+        if (raw[0] === 0x1b && raw[1] === 0x5b) {
+            if (raw[2] === 0x43 && this.initialIndex < 2) {
+                // Right
+                this.initialIndex++;
+            }
+            else if (raw[2] === 0x44 && this.initialIndex > 0) {
+                // Left
+                this.initialIndex--;
+            }
+            else if (raw[2] === 0x41) {
+                // Up - next letter
+                const current = this.initials[this.initialIndex];
+                this.initials[this.initialIndex] =
+                    current === "Z"
+                        ? "A"
+                        : String.fromCharCode(current.charCodeAt(0) + 1);
+            }
+            else if (raw[2] === 0x42) {
+                // Down - prev letter
+                const current = this.initials[this.initialIndex];
+                this.initials[this.initialIndex] =
+                    current === "A"
+                        ? "Z"
+                        : String.fromCharCode(current.charCodeAt(0) - 1);
+            }
+            return;
+        }
+        // Enter to submit
+        if (key === "\r" || key === "\n") {
+            this.submitHighScore();
+        }
+        // Backspace
+        if (key === "\x7f" && this.initialIndex > 0) {
+            this.initialIndex--;
+        }
+    }
+    update(delta) {
+        if (this.showingPreGame || this.state.gameOver || this.paused)
+            return;
+        // Auto-drop timer
+        this.dropTimer += delta;
+        if (this.dropTimer >= this.dropInterval) {
+            this.dropTimer = 0;
+            if (!this.moveDown()) {
+                // Can't move down - lock piece
+                const isGameOver = this.lockPiece();
+                if (isGameOver) {
+                    this.handleGameOver();
+                }
+            }
+        }
+    }
+    render() {
+        this.clearScreen();
+        const cols = this.stdout.columns || 80;
+        const rows = this.stdout.rows || 24;
+        // Show pre-game screen
+        if (this.showingPreGame) {
+            this.drawPreGameScreen(cols, rows);
+            return;
+        }
+        // Calculate board position (centered)
+        const boardDisplayWidth = BOARD_WIDTH * 2 + 2; // Each cell is 2 chars + borders
+        const totalWidth = boardDisplayWidth + 20; // Extra space for side panel
+        const startX = Math.max(1, Math.floor((cols - totalWidth) / 2));
+        const startY = Math.max(1, Math.floor((rows - BOARD_HEIGHT - 4) / 2));
+        // Draw title
+        this.writeAt(startX, startY, this.colors.title("═══════ T E T R I S ═══════"));
+        // Get display board with current piece
+        const displayBoard = getBoardWithPiece(this.state.board, this.state.currentPiece, this.state.position);
+        // Draw board
+        const boardStartY = startY + 2;
+        this.drawBoard(startX, boardStartY, displayBoard);
+        // Draw side panel
+        const panelX = startX + boardDisplayWidth + 2;
+        this.drawSidePanel(panelX, boardStartY);
+        // Draw controls help
+        const controlsY = boardStartY + BOARD_HEIGHT + 2;
+        this.writeAt(startX, controlsY, this.colors.muted("←→ Move  ↑ Rotate  Space Drop  C Hold  P Pause  Q Quit"));
+        // Draw overlays
+        if (this.paused) {
+            this.drawPauseOverlay(startX, boardStartY);
+        }
+        else if (this.state.gameOver) {
+            if (this.enteringInitials) {
+                this.drawHighScoreEntry(startX, boardStartY);
+            }
+            else {
+                this.drawGameOverOverlay(startX, boardStartY);
+            }
+        }
+    }
+    drawBoard(x, y, board) {
+        // Top border
+        this.writeAt(x, y, "┌" + "──".repeat(BOARD_WIDTH) + "┐");
+        // Board rows (skip hidden rows)
+        for (let row = HIDDEN_ROWS; row < BOARD_HEIGHT + HIDDEN_ROWS; row++) {
+            const displayRow = row - HIDDEN_ROWS;
+            let line = "│";
+            for (let col = 0; col < BOARD_WIDTH; col++) {
+                const cell = board[row][col];
+                if (cell > 0) {
+                    line += this.colors.piece(cell, "██");
+                }
+                else if (cell < 0) {
+                    // Ghost piece
+                    line += this.colors.ghost("░░");
+                }
+                else {
+                    line += "  ";
+                }
+            }
+            line += "│";
+            this.writeAt(x, y + 1 + displayRow, line);
+        }
+        // Bottom border
+        this.writeAt(x, y + BOARD_HEIGHT + 1, "└" + "──".repeat(BOARD_WIDTH) + "┘");
+    }
+    drawSidePanel(x, y) {
+        // Next piece (preview takes 6 lines: y+1 to y+6)
+        this.writeAt(x, y, this.colors.label("NEXT:"));
+        this.drawPiecePreview(x, y + 1, this.state.nextPiece);
+        // Hold piece (preview takes 6 lines: y+8 to y+13)
+        this.writeAt(x, y + 7, this.colors.label("HOLD:"));
+        this.drawPiecePreview(x, y + 8, this.state.heldPiece);
+        // Stats (start after hold preview ends at y+13)
+        this.writeAt(x, y + 14, this.colors.label("SCORE:"));
+        this.writeAt(x, y + 15, this.colors.score(this.state.score.toLocaleString()));
+        this.writeAt(x, y + 17, this.colors.label("LEVEL:"));
+        this.writeAt(x, y + 18, this.colors.value(String(this.state.level)));
+        this.writeAt(x, y + 20, this.colors.label("LINES:"));
+        this.writeAt(x, y + 21, this.colors.value(String(this.state.lines)));
+    }
+    drawPiecePreview(x, y, piece) {
+        // Draw a 4x4 preview box
+        this.writeAt(x, y, "┌────────┐");
+        for (let row = 0; row < 4; row++) {
+            let line = "│";
+            for (let col = 0; col < 4; col++) {
+                if (piece && piece.shape[row]?.[col]) {
+                    line += this.colors.piece(piece.color, "██");
+                }
+                else {
+                    line += "  ";
+                }
+            }
+            line += "│";
+            this.writeAt(x, y + 1 + row, line);
+        }
+        this.writeAt(x, y + 5, "└────────┘");
+    }
+    drawPauseOverlay(x, y) {
+        const centerY = y + Math.floor(BOARD_HEIGHT / 2);
+        this.writeAt(x + 4, centerY - 1, this.colors.overlay("╔══════════════╗"));
+        this.writeAt(x + 4, centerY, this.colors.overlay("║   PAUSED     ║"));
+        this.writeAt(x + 4, centerY + 1, this.colors.overlay("║  P to resume ║"));
+        this.writeAt(x + 4, centerY + 2, this.colors.overlay("╚══════════════╝"));
+    }
+    drawGameOverOverlay(x, y) {
+        const centerY = y + Math.floor(BOARD_HEIGHT / 2);
+        this.writeAt(x + 3, centerY - 2, this.colors.gameOver("╔════════════════╗"));
+        this.writeAt(x + 3, centerY - 1, this.colors.gameOver("║   GAME OVER    ║"));
+        this.writeAt(x + 3, centerY, this.colors.gameOver("║                ║"));
+        this.writeAt(x + 3, centerY + 1, this.colors.gameOver(`║ Score: ${this.state.score.toLocaleString().padStart(7)} ║`));
+        this.writeAt(x + 3, centerY + 2, this.colors.gameOver("║                ║"));
+        this.writeAt(x + 3, centerY + 3, this.colors.gameOver("║ Press any key  ║"));
+        this.writeAt(x + 3, centerY + 4, this.colors.gameOver("╚════════════════╝"));
+    }
+    drawHighScoreEntry(x, y) {
+        const centerY = y + Math.floor(BOARD_HEIGHT / 2);
+        const title = this.isNewRecord
+            ? "║  NEW RECORD! ★   ║"
+            : "║    TOP 10!       ║";
+        this.writeAt(x + 2, centerY - 3, this.colors.highScore("╔══════════════════╗"));
+        this.writeAt(x + 2, centerY - 2, this.colors.highScore(title));
+        this.writeAt(x + 2, centerY - 1, this.colors.highScore("║                  ║"));
+        this.writeAt(x + 2, centerY, this.colors.highScore(`║  ${this.finalScore.toLocaleString().padStart(10)}    ║`));
+        this.writeAt(x + 2, centerY + 1, this.colors.highScore("║                  ║"));
+        this.writeAt(x + 2, centerY + 2, this.colors.highScore("║  Enter initials: ║"));
+        // Draw initials with cursor
+        let initialsDisplay = "║    [ ";
+        for (let i = 0; i < 3; i++) {
+            if (i === this.initialIndex) {
+                initialsDisplay += this.colors.cursor(this.initials[i]);
+            }
+            else {
+                initialsDisplay += this.initials[i];
+            }
+            if (i < 2)
+                initialsDisplay += " ";
+        }
+        initialsDisplay += " ]    ║";
+        this.writeAt(x + 2, centerY + 3, this.colors.highScore(initialsDisplay));
+        this.writeAt(x + 2, centerY + 4, this.colors.highScore("║                  ║"));
+        this.writeAt(x + 2, centerY + 5, this.colors.highScore("║  ↑↓ Change ⏎ OK  ║"));
+        this.writeAt(x + 2, centerY + 6, this.colors.highScore("╚══════════════════╝"));
+    }
+    drawPreGameScreen(cols, rows) {
+        const boxWidth = 40;
+        const boxHeight = 20;
+        const startX = Math.max(1, Math.floor((cols - boxWidth) / 2));
+        const startY = Math.max(1, Math.floor((rows - boxHeight) / 2));
+        let y = startY;
+        // Each line is a complete string - no mixed styling
+        this.writeAt(startX, y++, this.colors.title("╔══════════════════════════════════════╗"));
+        this.writeAt(startX, y++, this.colors.title("║        ▀█▀ █▀▀ ▀█▀ █▀█ █ █▀▀         ║"));
+        this.writeAt(startX, y++, this.colors.title("║         █  █▀   █  ██▀ █ ▀▀█         ║"));
+        this.writeAt(startX, y++, this.colors.title("║         █  ▀▀▀  █  █ █ █ ▀▀▀         ║"));
+        this.writeAt(startX, y++, this.colors.title("╠══════════════════════════════════════╣"));
+        this.writeAt(startX, y++, this.colors.muted("║                                      ║"));
+        this.writeAt(startX, y++, this.colors.muted("║  CONTROLS                            ║"));
+        this.writeAt(startX, y++, this.colors.muted("║                                      ║"));
+        this.writeAt(startX, y++, this.colors.muted("║      Arrows     Move & Soft Drop     ║"));
+        this.writeAt(startX, y++, this.colors.muted("║      Space      Hard Drop            ║"));
+        this.writeAt(startX, y++, this.colors.muted("║      Up         Rotate               ║"));
+        this.writeAt(startX, y++, this.colors.muted("║      C          Hold Piece           ║"));
+        this.writeAt(startX, y++, this.colors.muted("║      P          Pause                ║"));
+        this.writeAt(startX, y++, this.colors.muted("║      Q          Quit                 ║"));
+        this.writeAt(startX, y++, this.colors.muted("║                                      ║"));
+        this.writeAt(startX, y++, this.colors.title("╠══════════════════════════════════════╣"));
+        this.writeAt(startX, y++, this.colors.title("║        Press any key to start        ║"));
+        this.writeAt(startX, y++, this.colors.title("╚══════════════════════════════════════╝"));
+    }
+}
+/**
+ * Launch Tetris game
+ */
+export async function playTetris() {
+    const game = new TetrisGame();
+    await game.start();
+}

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

@@ -0,0 +1,44 @@
+/**
+ * Tetromino Pieces
+ *
+ * Standard 7 Tetris pieces with rotation states.
+ */
+export type PieceType = 'I' | 'O' | 'T' | 'S' | 'Z' | 'J' | 'L';
+export interface Piece {
+    type: PieceType;
+    shape: number[][];
+    color: number;
+}
+/**
+ * Get a piece shape at a specific rotation
+ */
+export declare function getPieceShape(type: PieceType, rotation: number): number[][];
+/**
+ * Get piece color
+ */
+export declare function getPieceColor(type: PieceType): number;
+/**
+ * Create a new piece
+ */
+export declare function createPiece(type: PieceType, rotation?: number): Piece;
+/**
+ * Rotate a piece clockwise
+ */
+export declare function rotatePiece(piece: Piece, rotation: number): Piece;
+/**
+ * Get a random piece type
+ */
+export declare function getRandomPieceType(): PieceType;
+/**
+ * Generate a bag of 7 pieces (one of each type, shuffled)
+ * This is the "7-bag" randomizer used in modern Tetris
+ */
+export declare function generatePieceBag(): PieceType[];
+/**
+ * Get piece width (for centering)
+ */
+export declare function getPieceWidth(piece: Piece): number;
+/**
+ * Get piece height (for preview)
+ */
+export declare function getPieceHeight(piece: Piece): number;