mtosity 0.0.2 → 0.0.5

package/dist/games/terminal.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseKey = parseKey;
+exports.hideCursor = hideCursor;
+exports.showCursor = showCursor;
+exports.moveTo = moveTo;
+exports.clearScreen = clearScreen;
+exports.clearLine = clearLine;
+exports.enterGame = enterGame;
+function parseKey(data) {
+    const s = data.toString();
+    if (s === "\x03")
+        return { name: "q", ctrl: true }; // Ctrl+C → quit
+    if (s === "\x1B[A")
+        return { name: "up", ctrl: false };
+    if (s === "\x1B[B")
+        return { name: "down", ctrl: false };
+    if (s === "\x1B[C")
+        return { name: "right", ctrl: false };
+    if (s === "\x1B[D")
+        return { name: "left", ctrl: false };
+    if (s === " ")
+        return { name: "space", ctrl: false };
+    if (s === "\r" || s === "\n")
+        return { name: "enter", ctrl: false };
+    return { name: s.toLowerCase(), ctrl: false };
+}
+function hideCursor() {
+    process.stdout.write("\x1B[?25l");
+}
+function showCursor() {
+    process.stdout.write("\x1B[?25h");
+}
+function moveTo(row, col) {
+    process.stdout.write(`\x1B[${row};${col}H`);
+}
+function clearScreen() {
+    process.stdout.write("\x1B[2J\x1B[1;1H");
+}
+function clearLine(row) {
+    moveTo(row, 1);
+    process.stdout.write("\x1B[2K");
+}
+function enterGame(rl) {
+    rl.pause();
+    if (process.stdin.isTTY) {
+        process.stdin.setRawMode(true);
+    }
+    process.stdin.resume();
+    hideCursor();
+    clearScreen();
+    const cleanup = () => {
+        showCursor();
+        clearScreen();
+        if (process.stdin.isTTY) {
+            process.stdin.setRawMode(false);
+        }
+        process.stdin.pause();
+        rl.resume();
+    };
+    return { rl, cleanup };
+}

package/dist/games/tetris/bastard.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pickWorstPiece = pickWorstPiece;
+const pieces_1 = require("./pieces");
+const board_1 = require("./board");
+function scorePlacement(board) {
+    const holes = (0, board_1.countHoles)(board);
+    const height = (0, board_1.aggregateHeight)(board);
+    const bump = (0, board_1.bumpiness)(board);
+    const lines = (0, board_1.clearLines)(board);
+    return holes * 4 + height + bump - lines * 8;
+}
+/**
+ * Bastard algorithm: pick the piece whose best placement still leaves
+ * the worst board. For each piece type, find the best (lowest score)
+ * placement. Then pick the piece type with the highest "best" score.
+ */
+function pickWorstPiece(board) {
+    let worstBest = -Infinity;
+    let worstPieceIdx = 0;
+    for (let pi = 0; pi < pieces_1.PIECE_COUNT; pi++) {
+        const def = pieces_1.PIECES[pi];
+        let bestScore = Infinity;
+        for (let rot = 0; rot < def.rotations.length; rot++) {
+            const grid = def.rotations[rot];
+            const gridW = grid[0].length;
+            for (let x = -(gridW - 1); x < board_1.BOARD_W; x++) {
+                const piece = { def, pieceIndex: pi, rotation: rot, x, y: 0 };
+                // Check if this x position is even valid at the top
+                if ((0, board_1.collides)(board, piece))
+                    continue;
+                // Drop to bottom
+                let dropY = 0;
+                while (!(0, board_1.collides)(board, { ...piece, y: dropY + 1 })) {
+                    dropY++;
+                }
+                piece.y = dropY;
+                const testBoard = (0, board_1.cloneBoard)(board);
+                (0, board_1.lockPiece)(testBoard, piece);
+                const score = scorePlacement(testBoard);
+                if (score < bestScore) {
+                    bestScore = score;
+                }
+            }
+        }
+        if (bestScore === Infinity) {
+            // Piece can't be placed at all — this is very bad for the player
+            bestScore = 1000;
+        }
+        if (bestScore > worstBest) {
+            worstBest = bestScore;
+            worstPieceIdx = pi;
+        }
+    }
+    return worstPieceIdx;
+}

package/dist/games/tetris/board.js

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BOARD_H = exports.BOARD_W = void 0;
+exports.createBoard = createBoard;
+exports.cloneBoard = cloneBoard;
+exports.collides = collides;
+exports.lockPiece = lockPiece;
+exports.clearLines = clearLines;
+exports.countHoles = countHoles;
+exports.aggregateHeight = aggregateHeight;
+exports.bumpiness = bumpiness;
+exports.tryRotate = tryRotate;
+exports.spawnPiece = spawnPiece;
+exports.dropDistance = dropDistance;
+exports.BOARD_W = 10;
+exports.BOARD_H = 20;
+function createBoard() {
+    return Array.from({ length: exports.BOARD_H }, () => new Array(exports.BOARD_W).fill(0));
+}
+function cloneBoard(board) {
+    return board.map((row) => [...row]);
+}
+function getGrid(piece) {
+    return piece.def.rotations[piece.rotation % piece.def.rotations.length];
+}
+function collides(board, piece) {
+    const grid = getGrid(piece);
+    for (let r = 0; r < grid.length; r++) {
+        for (let c = 0; c < grid[r].length; c++) {
+            if (!grid[r][c])
+                continue;
+            const bx = piece.x + c;
+            const by = piece.y + r;
+            if (bx < 0 || bx >= exports.BOARD_W || by >= exports.BOARD_H)
+                return true;
+            if (by >= 0 && board[by][bx] !== 0)
+                return true;
+        }
+    }
+    return false;
+}
+function lockPiece(board, piece) {
+    const grid = getGrid(piece);
+    for (let r = 0; r < grid.length; r++) {
+        for (let c = 0; c < grid[r].length; c++) {
+            if (!grid[r][c])
+                continue;
+            const bx = piece.x + c;
+            const by = piece.y + r;
+            if (by >= 0 && by < exports.BOARD_H && bx >= 0 && bx < exports.BOARD_W) {
+                board[by][bx] = piece.pieceIndex + 1;
+            }
+        }
+    }
+}
+function clearLines(board) {
+    let cleared = 0;
+    for (let r = exports.BOARD_H - 1; r >= 0; r--) {
+        if (board[r].every((c) => c !== 0)) {
+            board.splice(r, 1);
+            board.unshift(new Array(exports.BOARD_W).fill(0));
+            cleared++;
+            r++; // recheck this row
+        }
+    }
+    return cleared;
+}
+function countHoles(board) {
+    let holes = 0;
+    for (let c = 0; c < exports.BOARD_W; c++) {
+        let blockFound = false;
+        for (let r = 0; r < exports.BOARD_H; r++) {
+            if (board[r][c] !== 0) {
+                blockFound = true;
+            }
+            else if (blockFound) {
+                holes++;
+            }
+        }
+    }
+    return holes;
+}
+function aggregateHeight(board) {
+    let total = 0;
+    for (let c = 0; c < exports.BOARD_W; c++) {
+        for (let r = 0; r < exports.BOARD_H; r++) {
+            if (board[r][c] !== 0) {
+                total += exports.BOARD_H - r;
+                break;
+            }
+        }
+    }
+    return total;
+}
+function bumpiness(board) {
+    const heights = [];
+    for (let c = 0; c < exports.BOARD_W; c++) {
+        let h = 0;
+        for (let r = 0; r < exports.BOARD_H; r++) {
+            if (board[r][c] !== 0) {
+                h = exports.BOARD_H - r;
+                break;
+            }
+        }
+        heights.push(h);
+    }
+    let bump = 0;
+    for (let i = 0; i < heights.length - 1; i++) {
+        bump += Math.abs(heights[i] - heights[i + 1]);
+    }
+    return bump;
+}
+function tryRotate(board, piece, dir) {
+    const rotCount = piece.def.rotations.length;
+    const newRot = ((piece.rotation + dir) % rotCount + rotCount) % rotCount;
+    const candidate = { ...piece, rotation: newRot };
+    // Try base position, then wall kicks
+    const offsets = [0, -1, 1, -2, 2];
+    for (const dx of offsets) {
+        const kicked = { ...candidate, x: candidate.x + dx };
+        if (!collides(board, kicked))
+            return kicked;
+    }
+    return null;
+}
+function spawnPiece(pieceIndex, def) {
+    const grid = def.rotations[0];
+    return {
+        def,
+        pieceIndex,
+        rotation: 0,
+        x: Math.floor((exports.BOARD_W - grid[0].length) / 2),
+        y: -1,
+    };
+}
+function dropDistance(board, piece) {
+    let dist = 0;
+    while (!collides(board, { ...piece, y: piece.y + dist + 1 })) {
+        dist++;
+    }
+    return dist;
+}

package/dist/games/tetris/index.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.playTetris = playTetris;
+const terminal_1 = require("../terminal");
+const pieces_1 = require("./pieces");
+const board_1 = require("./board");
+const bastard_1 = require("./bastard");
+const renderer_1 = require("./renderer");
+const LINE_SCORES = [0, 100, 300, 500, 800];
+const LINES_PER_LEVEL = 10;
+function gravityMs(level) {
+    return Math.max(100, 800 - (level - 1) * 70);
+}
+async function playTetris(rl) {
+    const ctx = (0, terminal_1.enterGame)(rl);
+    return new Promise((resolve) => {
+        const board = (0, board_1.createBoard)();
+        let score = 0;
+        let level = 1;
+        let totalLines = 0;
+        let gameOver = false;
+        // Spawn first piece, pre-pick next
+        const firstIdx = (0, bastard_1.pickWorstPiece)(board);
+        let active = (0, board_1.spawnPiece)(firstIdx, pieces_1.PIECES[firstIdx]);
+        let nextPieceIdx = (0, bastard_1.pickWorstPiece)(board);
+        let gravityTimer = null;
+        let lastRender = 0;
+        function getState() {
+            return { board, active, score, level, lines: totalLines, gameOver, nextPieceIndex: nextPieceIdx };
+        }
+        function render() {
+            const now = Date.now();
+            if (now - lastRender < 16)
+                return; // cap at ~60fps
+            lastRender = now;
+            (0, renderer_1.renderBoard)(getState());
+        }
+        function spawnNext() {
+            active = (0, board_1.spawnPiece)(nextPieceIdx, pieces_1.PIECES[nextPieceIdx]);
+            nextPieceIdx = (0, bastard_1.pickWorstPiece)(board);
+            if ((0, board_1.collides)(board, active)) {
+                gameOver = true;
+                active = null;
+                stopGravity();
+                render();
+            }
+        }
+        function lock() {
+            if (!active)
+                return;
+            (0, board_1.lockPiece)(board, active);
+            const cleared = (0, board_1.clearLines)(board);
+            if (cleared > 0) {
+                totalLines += cleared;
+                score += LINE_SCORES[Math.min(cleared, 4)] * level;
+                const newLevel = Math.floor(totalLines / LINES_PER_LEVEL) + 1;
+                if (newLevel > level) {
+                    level = newLevel;
+                    restartGravity();
+                }
+            }
+            spawnNext();
+        }
+        function tick() {
+            if (!active || gameOver)
+                return;
+            const moved = { ...active, y: active.y + 1 };
+            if (!(0, board_1.collides)(board, moved)) {
+                active = moved;
+            }
+            else {
+                lock();
+            }
+            render();
+        }
+        function startGravity() {
+            gravityTimer = setInterval(tick, gravityMs(level));
+        }
+        function stopGravity() {
+            if (gravityTimer) {
+                clearInterval(gravityTimer);
+                gravityTimer = null;
+            }
+        }
+        function restartGravity() {
+            stopGravity();
+            startGravity();
+        }
+        function cleanup() {
+            stopGravity();
+            process.stdin.removeListener("data", onKey);
+            ctx.cleanup();
+            resolve();
+        }
+        function onKey(data) {
+            const key = (0, terminal_1.parseKey)(data);
+            if (key.name === "q") {
+                cleanup();
+                return;
+            }
+            if (gameOver)
+                return;
+            if (!active)
+                return;
+            switch (key.name) {
+                case "left": {
+                    const moved = { ...active, x: active.x - 1 };
+                    if (!(0, board_1.collides)(board, moved))
+                        active = moved;
+                    break;
+                }
+                case "right": {
+                    const moved = { ...active, x: active.x + 1 };
+                    if (!(0, board_1.collides)(board, moved))
+                        active = moved;
+                    break;
+                }
+                case "up": {
+                    const rotated = (0, board_1.tryRotate)(board, active, 1);
+                    if (rotated)
+                        active = rotated;
+                    break;
+                }
+                case "down": {
+                    const moved = { ...active, y: active.y + 1 };
+                    if (!(0, board_1.collides)(board, moved)) {
+                        active = moved;
+                        score += 1;
+                    }
+                    break;
+                }
+                case "space": {
+                    const dist = (0, board_1.dropDistance)(board, active);
+                    active = { ...active, y: active.y + dist };
+                    score += dist * 2;
+                    lock();
+                    break;
+                }
+            }
+            render();
+        }
+        process.stdin.on("data", onKey);
+        render();
+        startGravity();
+    });
+}

package/dist/games/tetris/pieces.js

@@ -0,0 +1,149 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PIECE_COUNT = exports.PIECES = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const I = {
+    name: "I",
+    rotations: [
+        [
+            [0, 0, 0, 0],
+            [1, 1, 1, 1],
+            [0, 0, 0, 0],
+            [0, 0, 0, 0],
+        ],
+        [
+            [0, 0, 1, 0],
+            [0, 0, 1, 0],
+            [0, 0, 1, 0],
+            [0, 0, 1, 0],
+        ],
+    ],
+    color: chalk_1.default.rgb(0, 240, 240),
+};
+const O = {
+    name: "O",
+    rotations: [
+        [
+            [0, 0, 0, 0],
+            [0, 1, 1, 0],
+            [0, 1, 1, 0],
+            [0, 0, 0, 0],
+        ],
+    ],
+    color: chalk_1.default.rgb(240, 240, 0),
+};
+const T = {
+    name: "T",
+    rotations: [
+        [
+            [0, 1, 0],
+            [1, 1, 1],
+            [0, 0, 0],
+        ],
+        [
+            [0, 1, 0],
+            [0, 1, 1],
+            [0, 1, 0],
+        ],
+        [
+            [0, 0, 0],
+            [1, 1, 1],
+            [0, 1, 0],
+        ],
+        [
+            [0, 1, 0],
+            [1, 1, 0],
+            [0, 1, 0],
+        ],
+    ],
+    color: chalk_1.default.rgb(180, 0, 255),
+};
+const S = {
+    name: "S",
+    rotations: [
+        [
+            [0, 1, 1],
+            [1, 1, 0],
+            [0, 0, 0],
+        ],
+        [
+            [0, 1, 0],
+            [0, 1, 1],
+            [0, 0, 1],
+        ],
+    ],
+    color: chalk_1.default.rgb(0, 240, 0),
+};
+const Z = {
+    name: "Z",
+    rotations: [
+        [
+            [1, 1, 0],
+            [0, 1, 1],
+            [0, 0, 0],
+        ],
+        [
+            [0, 0, 1],
+            [0, 1, 1],
+            [0, 1, 0],
+        ],
+    ],
+    color: chalk_1.default.rgb(240, 0, 0),
+};
+const J = {
+    name: "J",
+    rotations: [
+        [
+            [1, 0, 0],
+            [1, 1, 1],
+            [0, 0, 0],
+        ],
+        [
+            [0, 1, 1],
+            [0, 1, 0],
+            [0, 1, 0],
+        ],
+        [
+            [0, 0, 0],
+            [1, 1, 1],
+            [0, 0, 1],
+        ],
+        [
+            [0, 1, 0],
+            [0, 1, 0],
+            [1, 1, 0],
+        ],
+    ],
+    color: chalk_1.default.rgb(0, 100, 240),
+};
+const L = {
+    name: "L",
+    rotations: [
+        [
+            [0, 0, 1],
+            [1, 1, 1],
+            [0, 0, 0],
+        ],
+        [
+            [0, 1, 0],
+            [0, 1, 0],
+            [0, 1, 1],
+        ],
+        [
+            [0, 0, 0],
+            [1, 1, 1],
+            [1, 0, 0],
+        ],
+        [
+            [1, 1, 0],
+            [0, 1, 0],
+            [0, 1, 0],
+        ],
+    ],
+    color: chalk_1.default.rgb(255, 165, 0),
+};
+exports.PIECES = [I, O, T, S, Z, J, L];
+exports.PIECE_COUNT = exports.PIECES.length;