clibuddy 1.0.0

package/dist/minigames/moodmatch.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("./types");
+const registry_1 = require("./registry");
+const screen_1 = require("../rendering/screen");
+const MOODS = [
+    { face: "( ^_^ )", correct: "Happy", options: ["Happy", "Excited", "Sleepy", "Angry"] },
+    { face: "( >_< )", correct: "Angry", options: ["Sad", "Angry", "Scared", "Happy"] },
+    { face: "( ;_; )", correct: "Sad", options: ["Tired", "Sad", "Happy", "Confused"] },
+    { face: "( o_O )", correct: "Surprised", options: ["Surprised", "Angry", "Confused", "Happy"] },
+    { face: "( -_- )", correct: "Tired", options: ["Bored", "Tired", "Sad", "Calm"] },
+    { face: "( >w< )", correct: "Excited", options: ["Excited", "Happy", "Angry", "Nervous"] },
+    { face: "( ._. )", correct: "Confused", options: ["Sad", "Tired", "Confused", "Scared"] },
+    { face: "( @_@ )", correct: "Dizzy", options: ["Dizzy", "Surprised", "Excited", "Confused"] },
+    { face: "( ^o^ )", correct: "Joyful", options: ["Happy", "Joyful", "Excited", "Proud"] },
+    { face: "( T_T )", correct: "Crying", options: ["Sad", "Crying", "Tired", "Angry"] },
+];
+function shuffle(arr) {
+    const copy = [...arr];
+    for (let i = copy.length - 1; i > 0; i--) {
+        const j = Math.floor(Math.random() * (i + 1));
+        [copy[i], copy[j]] = [copy[j], copy[i]];
+    }
+    return copy;
+}
+const handler = {
+    def: {
+        id: "moodmatch",
+        name: "Mood Match",
+        description: "Can you read your buddy's emotions?",
+        icon: "▲",
+    },
+    start() {
+        const questions = shuffle(MOODS).slice(0, 8);
+        const q = questions[0];
+        const shuffledOptions = shuffle(q.options);
+        return {
+            active: true,
+            gameId: "moodmatch",
+            phase: "intro",
+            score: 0,
+            round: 1,
+            maxRounds: 8,
+            buddyReaction: "Can you tell how I feel?",
+            data: {
+                questions,
+                currentOptions: shuffledOptions,
+                answered: false,
+                lastCorrect: false,
+            },
+            ticksInPhase: 0,
+        };
+    },
+    tick(game) {
+        game = { ...game, ticksInPhase: game.ticksInPhase + 1 };
+        if (game.phase === "intro" && game.ticksInPhase > 3) {
+            return { ...game, phase: "playing", ticksInPhase: 0 };
+        }
+        // Auto-advance after showing answer
+        if (game.phase === "playing" && game.data.answered && game.ticksInPhase > 3) {
+            if (game.round >= game.maxRounds) {
+                return { ...game, phase: "result", ticksInPhase: 0, buddyReaction: (0, types_1.getReaction)(game.score, game.maxRounds) };
+            }
+            const questions = game.data.questions;
+            const q = questions[game.round]; // 0-indexed, round is already incremented
+            const shuffledOptions = shuffle(q.options);
+            return {
+                ...game,
+                round: game.round + 1,
+                ticksInPhase: 0,
+                data: { ...game.data, currentOptions: shuffledOptions, answered: false },
+                buddyReaction: "What about this one?",
+            };
+        }
+        return game;
+    },
+    handleInput(key, game) {
+        if (game.phase === "intro") {
+            if (key === "\r" || key === "\n")
+                return { ...game, phase: "playing", ticksInPhase: 0 };
+            return game;
+        }
+        if (game.phase === "result") {
+            if (key === "\r" || key === "\n")
+                return { ...game, ticksInPhase: 99 };
+            return game;
+        }
+        if (game.data.answered)
+            return game;
+        const choice = parseInt(key);
+        if (choice < 1 || choice > 4 || isNaN(choice))
+            return game;
+        const questions = game.data.questions;
+        const q = questions[game.round - 1];
+        const options = game.data.currentOptions;
+        const picked = options[choice - 1];
+        const correct = picked === q.correct;
+        return {
+            ...game,
+            score: correct ? game.score + 1 : game.score,
+            ticksInPhase: 0,
+            data: { ...game.data, answered: true, lastCorrect: correct },
+            buddyReaction: correct ? "You know me so well!" : `That was "${q.correct}"!`,
+        };
+    },
+    render(game, buddyName) {
+        const lines = [];
+        lines.push("");
+        lines.push(`  ${screen_1.ansi.bold}Mood Match${screen_1.ansi.reset}  ${screen_1.ansi.dim}Round ${game.round}/${game.maxRounds}  Correct: ${game.score}${screen_1.ansi.reset}`);
+        lines.push(`  ${screen_1.ansi.dim}${"─".repeat(40)}${screen_1.ansi.reset}`);
+        lines.push("");
+        if (game.phase === "intro") {
+            lines.push(`  ${buddyName}: "${game.buddyReaction}"`);
+            lines.push("");
+            lines.push(`  ${screen_1.ansi.dim}Match the face to the emotion!${screen_1.ansi.reset}`);
+            lines.push("");
+            lines.push(`  ${screen_1.ansi.dim}Press Enter to start...${screen_1.ansi.reset}`);
+        }
+        else if (game.phase === "playing") {
+            const questions = game.data.questions;
+            const q = questions[game.round - 1];
+            const options = game.data.currentOptions;
+            lines.push(`  ${buddyName}: "${game.buddyReaction}"`);
+            lines.push("");
+            lines.push(`    ${screen_1.ansi.bold}${screen_1.ansi.colors.yellow}${q.face}${screen_1.ansi.reset}`);
+            lines.push("");
+            for (let i = 0; i < options.length; i++) {
+                const marker = game.data.answered && options[i] === q.correct ? `${screen_1.ansi.colors.green}✓ ` : "  ";
+                lines.push(`  ${marker}[${i + 1}] ${options[i]}${screen_1.ansi.reset}`);
+            }
+        }
+        else {
+            lines.push(`  ${buddyName}: "${game.buddyReaction}"`);
+            lines.push("");
+            lines.push(`  ${screen_1.ansi.bold}Correct: ${game.score}/${game.maxRounds}${screen_1.ansi.reset}`);
+            lines.push("");
+            lines.push(`  ${screen_1.ansi.dim}Press Enter to finish${screen_1.ansi.reset}`);
+        }
+        lines.push("");
+        return lines.join("\n");
+    },
+};
+(0, registry_1.registerGame)(handler);
+//# sourceMappingURL=moodmatch.js.map

package/dist/minigames/quickpaws.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=quickpaws.d.ts.map

package/dist/minigames/quickpaws.js

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("./types");
+const registry_1 = require("./registry");
+const screen_1 = require("../rendering/screen");
+const SYMBOLS = ["★", "♦", "●", "▲"];
+const KEYS = ["1", "2", "3", "4"];
+const TIMEOUT_TICKS = 3; // ~2.4 seconds per symbol
+const handler = {
+    def: {
+        id: "quickpaws",
+        name: "Quick Paws",
+        description: "Press the right key before time runs out!",
+        icon: "♦",
+    },
+    start() {
+        return {
+            active: true,
+            gameId: "quickpaws",
+            phase: "intro",
+            score: 0,
+            round: 1,
+            maxRounds: 10,
+            buddyReaction: "Let's see how fast you are!",
+            data: {
+                currentSymbol: Math.floor(Math.random() * 4),
+                strikes: 0,
+                maxStrikes: 3,
+                ticksOnSymbol: 0,
+                lastResult: "", // "hit" | "miss" | "timeout" | ""
+            },
+            ticksInPhase: 0,
+        };
+    },
+    tick(game) {
+        game = { ...game, ticksInPhase: game.ticksInPhase + 1 };
+        if (game.phase === "intro" && game.ticksInPhase > 3) {
+            return { ...game, phase: "playing", ticksInPhase: 0, data: { ...game.data, ticksOnSymbol: 0 } };
+        }
+        if (game.phase === "playing") {
+            const ticksOnSymbol = game.data.ticksOnSymbol + 1;
+            if (ticksOnSymbol >= TIMEOUT_TICKS) {
+                // Timeout — strike
+                const strikes = game.data.strikes + 1;
+                if (strikes >= game.data.maxStrikes) {
+                    return { ...game, phase: "result", ticksInPhase: 0, data: { ...game.data, strikes }, buddyReaction: (0, types_1.getReaction)(game.score, game.maxRounds) };
+                }
+                return {
+                    ...game,
+                    data: {
+                        ...game.data,
+                        strikes,
+                        currentSymbol: Math.floor(Math.random() * 4),
+                        ticksOnSymbol: 0,
+                        lastResult: "timeout",
+                    },
+                    buddyReaction: "Too slow!",
+                };
+            }
+            return { ...game, data: { ...game.data, ticksOnSymbol } };
+        }
+        return game;
+    },
+    handleInput(key, game) {
+        if (game.phase === "intro") {
+            if (key === "\r" || key === "\n")
+                return { ...game, phase: "playing", ticksInPhase: 0 };
+            return game;
+        }
+        if (game.phase === "result") {
+            if (key === "\r" || key === "\n")
+                return { ...game, ticksInPhase: 99 };
+            return game;
+        }
+        const keyIndex = KEYS.indexOf(key);
+        if (keyIndex === -1)
+            return game;
+        const current = game.data.currentSymbol;
+        if (keyIndex === current) {
+            // Hit!
+            const newScore = game.score + 1;
+            if (newScore >= game.maxRounds) {
+                return { ...game, score: newScore, phase: "result", ticksInPhase: 0, buddyReaction: (0, types_1.getReaction)(newScore, game.maxRounds) };
+            }
+            return {
+                ...game,
+                score: newScore,
+                round: game.round + 1,
+                data: { ...game.data, currentSymbol: Math.floor(Math.random() * 4), ticksOnSymbol: 0, lastResult: "hit" },
+                buddyReaction: "Nice!",
+            };
+        }
+        else {
+            // Miss — strike
+            const strikes = game.data.strikes + 1;
+            if (strikes >= game.data.maxStrikes) {
+                return { ...game, phase: "result", ticksInPhase: 0, data: { ...game.data, strikes }, buddyReaction: (0, types_1.getReaction)(game.score, game.maxRounds) };
+            }
+            return {
+                ...game,
+                data: { ...game.data, strikes, currentSymbol: Math.floor(Math.random() * 4), ticksOnSymbol: 0, lastResult: "miss" },
+                buddyReaction: "Wrong one!",
+            };
+        }
+    },
+    render(game, buddyName) {
+        const lines = [];
+        const strikes = game.data.strikes || 0;
+        const maxStrikes = game.data.maxStrikes || 3;
+        lines.push("");
+        lines.push(`  ${screen_1.ansi.bold}Quick Paws${screen_1.ansi.reset}  ${screen_1.ansi.dim}Score: ${game.score}  Strikes: ${"X".repeat(strikes)}${"_".repeat(maxStrikes - strikes)}${screen_1.ansi.reset}`);
+        lines.push(`  ${screen_1.ansi.dim}${"─".repeat(40)}${screen_1.ansi.reset}`);
+        lines.push("");
+        if (game.phase === "intro") {
+            lines.push(`  ${buddyName}: "${game.buddyReaction}"`);
+            lines.push("");
+            lines.push(`  ${screen_1.ansi.dim}Keys: [1]${SYMBOLS[0]}  [2]${SYMBOLS[1]}  [3]${SYMBOLS[2]}  [4]${SYMBOLS[3]}${screen_1.ansi.reset}`);
+            lines.push("");
+            lines.push(`  ${screen_1.ansi.dim}Press Enter to start...${screen_1.ansi.reset}`);
+        }
+        else if (game.phase === "playing") {
+            const current = game.data.currentSymbol;
+            lines.push(`  ${buddyName}: "${game.buddyReaction}"`);
+            lines.push("");
+            lines.push(`  ${screen_1.ansi.bold}${screen_1.ansi.colors.yellow}  Press [${current + 1}]  →  ${SYMBOLS[current]}${screen_1.ansi.reset}`);
+            lines.push("");
+            const ticksLeft = TIMEOUT_TICKS - game.data.ticksOnSymbol;
+            lines.push(`  ${screen_1.ansi.dim}${"█".repeat(ticksLeft)}${"░".repeat(TIMEOUT_TICKS - ticksLeft)}${screen_1.ansi.reset}`);
+        }
+        else {
+            lines.push(`  ${buddyName}: "${game.buddyReaction}"`);
+            lines.push("");
+            lines.push(`  ${screen_1.ansi.bold}Final Score: ${game.score}/${game.maxRounds}${screen_1.ansi.reset}`);
+            lines.push("");
+            lines.push(`  ${screen_1.ansi.dim}Press Enter to finish${screen_1.ansi.reset}`);
+        }
+        lines.push("");
+        return lines.join("\n");
+    },
+};
+(0, registry_1.registerGame)(handler);
+//# sourceMappingURL=quickpaws.js.map

package/dist/minigames/registry.d.ts

@@ -0,0 +1,5 @@
+import { MiniGameHandler, MiniGameDef } from "./types";
+export declare function registerGame(handler: MiniGameHandler): void;
+export declare function getGameHandler(id: string): MiniGameHandler | undefined;
+export declare function getAllGames(): MiniGameDef[];
+//# sourceMappingURL=registry.d.ts.map

package/dist/minigames/registry.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerGame = registerGame;
+exports.getGameHandler = getGameHandler;
+exports.getAllGames = getAllGames;
+const handlers = new Map();
+function registerGame(handler) {
+    handlers.set(handler.def.id, handler);
+}
+function getGameHandler(id) {
+    return handlers.get(id);
+}
+function getAllGames() {
+    return Array.from(handlers.values()).map((h) => h.def);
+}
+//# sourceMappingURL=registry.js.map

package/dist/minigames/rpsplus.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=rpsplus.d.ts.map

package/dist/minigames/rpsplus.js

@@ -0,0 +1,168 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("./types");
+const registry_1 = require("./registry");
+const screen_1 = require("../rendering/screen");
+const CHOICES = ["Rock", "Paper", "Scissors"];
+const ELEMENTS = ["Nature", "Light", "Shadow"];
+const ICONS = ["🪨", "📄", "✂️"];
+// RPS rules: Rock > Scissors, Scissors > Paper, Paper > Rock
+function rpsWinner(player, enemy) {
+    if (player === enemy)
+        return "draw";
+    if ((player + 1) % 3 === enemy)
+        return "win"; // Rock(0) beats Scissors(2), etc.
+    return "lose";
+}
+function pickRandom(arr) {
+    return arr[Math.floor(Math.random() * arr.length)];
+}
+const handler = {
+    def: {
+        id: "rpsplus",
+        name: "RPS+",
+        description: "Rock Paper Scissors with elemental twists!",
+        icon: "🪨",
+    },
+    start() {
+        return {
+            active: true,
+            gameId: "rpsplus",
+            phase: "intro",
+            score: 0,
+            round: 1,
+            maxRounds: 5,
+            buddyReaction: "Best of 5! Rock, Paper, or Scissors?",
+            data: {
+                enemyChoice: -1,
+                playerChoice: -1,
+                roundResult: "",
+                enemyScore: 0,
+                showResult: false,
+                // Buddy has a slight pattern — favors one choice
+                favoredChoice: Math.floor(Math.random() * 3),
+            },
+            ticksInPhase: 0,
+        };
+    },
+    tick(game) {
+        game = { ...game, ticksInPhase: game.ticksInPhase + 1 };
+        if (game.phase === "intro" && game.ticksInPhase > 3) {
+            return { ...game, phase: "playing", ticksInPhase: 0 };
+        }
+        // Auto-advance after showing round result
+        if (game.phase === "playing" && game.data.showResult && game.ticksInPhase > 4) {
+            const nextRound = game.round + 1;
+            if (nextRound > game.maxRounds) {
+                const won = game.score > game.data.enemyScore;
+                return {
+                    ...game, phase: "result", ticksInPhase: 0,
+                    buddyReaction: won ? (0, types_1.getReaction)(game.score, game.maxRounds) : "Good game! You got me!",
+                };
+            }
+            return {
+                ...game,
+                round: nextRound,
+                ticksInPhase: 0,
+                data: { ...game.data, showResult: false, playerChoice: -1, enemyChoice: -1, roundResult: "" },
+                buddyReaction: `Round ${nextRound}! Choose wisely...`,
+            };
+        }
+        return game;
+    },
+    handleInput(key, game) {
+        if (game.phase === "intro") {
+            if (key === "\r" || key === "\n")
+                return { ...game, phase: "playing", ticksInPhase: 0 };
+            return game;
+        }
+        if (game.phase === "result") {
+            if (key === "\r" || key === "\n")
+                return { ...game, ticksInPhase: 99 };
+            return game;
+        }
+        if (game.data.showResult)
+            return game; // waiting for auto-advance
+        const choice = parseInt(key) - 1;
+        if (choice < 0 || choice > 2 || isNaN(choice))
+            return game;
+        // Enemy choice — slight bias toward favored
+        const favored = game.data.favoredChoice;
+        let enemyChoice;
+        if (Math.random() < 0.4) {
+            enemyChoice = favored;
+        }
+        else {
+            enemyChoice = Math.floor(Math.random() * 3);
+        }
+        const result = rpsWinner(choice, enemyChoice);
+        let points = 0;
+        let reaction;
+        let enemyScore = game.data.enemyScore;
+        if (result === "win") {
+            points = 1;
+            reaction = `${CHOICES[choice]} beats ${CHOICES[enemyChoice]}! Nice!`;
+        }
+        else if (result === "lose") {
+            enemyScore++;
+            reaction = `${CHOICES[enemyChoice]} beats ${CHOICES[choice]}! Got you!`;
+        }
+        else {
+            reaction = `Both chose ${CHOICES[choice]}! Draw!`;
+        }
+        return {
+            ...game,
+            score: game.score + points,
+            ticksInPhase: 0,
+            data: { ...game.data, playerChoice: choice, enemyChoice, roundResult: result, enemyScore, showResult: true },
+            buddyReaction: reaction,
+        };
+    },
+    render(game, buddyName) {
+        const lines = [];
+        const enemyScore = game.data.enemyScore || 0;
+        lines.push("");
+        lines.push(`  ${screen_1.ansi.bold}RPS+${screen_1.ansi.reset}  ${screen_1.ansi.dim}Round ${game.round}/${game.maxRounds}  You: ${game.score} | Buddy: ${enemyScore}${screen_1.ansi.reset}`);
+        lines.push(`  ${screen_1.ansi.dim}${"─".repeat(40)}${screen_1.ansi.reset}`);
+        lines.push("");
+        if (game.phase === "intro") {
+            lines.push(`  ${buddyName}: "${game.buddyReaction}"`);
+            lines.push("");
+            lines.push(`  ${screen_1.ansi.dim}Rock = Nature, Paper = Light, Scissors = Shadow${screen_1.ansi.reset}`);
+            lines.push(`  ${screen_1.ansi.dim}Elemental advantage = bonus point!${screen_1.ansi.reset}`);
+            lines.push("");
+            lines.push(`  ${screen_1.ansi.dim}Press Enter to start...${screen_1.ansi.reset}`);
+        }
+        else if (game.phase === "playing") {
+            lines.push(`  ${buddyName}: "${game.buddyReaction}"`);
+            lines.push("");
+            if (game.data.showResult) {
+                const pc = game.data.playerChoice;
+                const ec = game.data.enemyChoice;
+                lines.push(`  You: ${ICONS[pc]} ${CHOICES[pc]}  vs  ${buddyName}: ${ICONS[ec]} ${CHOICES[ec]}`);
+                lines.push("");
+                const result = game.data.roundResult;
+                const color = result === "win" ? screen_1.ansi.colors.green : result === "lose" ? screen_1.ansi.colors.red : screen_1.ansi.colors.yellow;
+                lines.push(`  ${color}${result === "win" ? "WIN!" : result === "lose" ? "LOSE!" : "DRAW!"}${screen_1.ansi.reset}`);
+            }
+            else {
+                lines.push(`  [1] ${ICONS[0]} Rock    (Nature)`);
+                lines.push(`  [2] ${ICONS[1]} Paper   (Light)`);
+                lines.push(`  [3] ${ICONS[2]} Scissors (Shadow)`);
+            }
+        }
+        else {
+            const won = game.score > enemyScore;
+            lines.push(`  ${buddyName}: "${game.buddyReaction}"`);
+            lines.push("");
+            lines.push(`  ${screen_1.ansi.bold}Final: You ${game.score} - ${enemyScore} Buddy${screen_1.ansi.reset}`);
+            lines.push(`  ${won ? `${screen_1.ansi.colors.green}You win!${screen_1.ansi.reset}` : game.score === enemyScore ? `${screen_1.ansi.colors.yellow}It's a tie!${screen_1.ansi.reset}` : `${screen_1.ansi.colors.red}Buddy wins!${screen_1.ansi.reset}`}`);
+            lines.push("");
+            lines.push(`  ${screen_1.ansi.dim}Press Enter to finish${screen_1.ansi.reset}`);
+        }
+        lines.push("");
+        return lines.join("\n");
+    },
+};
+(0, registry_1.registerGame)(handler);
+//# sourceMappingURL=rpsplus.js.map

package/dist/minigames/treasurehunt.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=treasurehunt.d.ts.map

package/dist/minigames/treasurehunt.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("./types");
+const registry_1 = require("./registry");
+const screen_1 = require("../rendering/screen");
+// Honest hints — indirect, never say the exact number
+const HONEST_HINTS = [
+    (door) => door === 1 ? "I like being first..." : door === 2 ? "The middle is cozy..." : "I went far away...",
+    (door) => door === 1 ? "I didn't go far!" : door === 3 ? "I went as far as I could!" : "I'm somewhere in between...",
+    (door) => door === 2 ? "Not on the edges..." : "I'm on one of the sides...",
+    (door) => door === 1 ? "Think small..." : door === 3 ? "Think big..." : "Not too big, not too small...",
+    (_) => "I'll give you a wink if you're close...",
+    (_) => "Listen to your gut!",
+];
+// Tricky hints — actively misleading or point to wrong door
+const TRICKY_HINTS = [
+    (door) => { const wrong = door === 1 ? 3 : 1; return `I'm definitely behind door ${wrong}!`; },
+    (door) => { const wrong = door === 2 ? 1 : 2; return `The middle one? That's where I am!`.replace("middle", wrong === 1 ? "first" : "last"); },
+    (_) => "I'm NOT behind the middle door! ...or am I?",
+    (_) => "I left footprints going left... on purpose!",
+    (_) => "Would I lie to you? Yes. Yes I would.",
+    (door) => `Stay away from door ${door}... that one's boring!`,
+];
+function pickRandom(arr) {
+    return arr[Math.floor(Math.random() * arr.length)];
+}
+const handler = {
+    def: {
+        id: "treasurehunt",
+        name: "Treasure Hunt",
+        description: "Find where your buddy is hiding!",
+        icon: "●",
+    },
+    start() {
+        const hiddenDoor = Math.floor(Math.random() * 3) + 1;
+        const isHonest = Math.random() < 0.7;
+        const hint = isHonest
+            ? pickRandom(HONEST_HINTS)(hiddenDoor)
+            : pickRandom(TRICKY_HINTS)(hiddenDoor);
+        return {
+            active: true,
+            gameId: "treasurehunt",
+            phase: "intro",
+            score: 0,
+            round: 1,
+            maxRounds: 5,
+            buddyReaction: "I'll hide, you seek!",
+            data: { hiddenDoor, hint, revealed: false, lastCorrect: false },
+            ticksInPhase: 0,
+        };
+    },
+    tick(game) {
+        game = { ...game, ticksInPhase: game.ticksInPhase + 1 };
+        if (game.phase === "intro" && game.ticksInPhase > 3) {
+            return { ...game, phase: "playing", ticksInPhase: 0 };
+        }
+        // After revealing answer, auto-advance to next round
+        if (game.phase === "playing" && game.data.revealed && game.ticksInPhase > 3) {
+            if (game.round >= game.maxRounds) {
+                return { ...game, phase: "result", ticksInPhase: 0, buddyReaction: (0, types_1.getReaction)(game.score, game.maxRounds) };
+            }
+            // Next round
+            const hiddenDoor = Math.floor(Math.random() * 3) + 1;
+            const isHonest = Math.random() < 0.7;
+            const hint = isHonest
+                ? pickRandom(HONEST_HINTS)(hiddenDoor)
+                : pickRandom(TRICKY_HINTS)(hiddenDoor);
+            return {
+                ...game,
+                round: game.round + 1,
+                ticksInPhase: 0,
+                data: { hiddenDoor, hint, revealed: false, lastCorrect: false },
+                buddyReaction: "I'll hide again!",
+            };
+        }
+        return game;
+    },
+    handleInput(key, game) {
+        if (game.phase === "intro") {
+            if (key === "\r" || key === "\n")
+                return { ...game, phase: "playing", ticksInPhase: 0 };
+            return game;
+        }
+        if (game.phase === "result") {
+            if (key === "\r" || key === "\n")
+                return { ...game, ticksInPhase: 99 };
+            return game;
+        }
+        if (game.data.revealed)
+            return game;
+        const choice = parseInt(key);
+        if (choice < 1 || choice > 3 || isNaN(choice))
+            return game;
+        const correct = choice === game.data.hiddenDoor;
+        return {
+            ...game,
+            score: correct ? game.score + 1 : game.score,
+            ticksInPhase: 0,
+            data: { ...game.data, revealed: true, lastCorrect: correct },
+            buddyReaction: correct ? pickRandom(["You found me!", "How did you know?!", "Good guess!"]) : `Nope! I was behind door ${game.data.hiddenDoor}!`,
+        };
+    },
+    render(game, buddyName) {
+        const lines = [];
+        lines.push("");
+        lines.push(`  ${screen_1.ansi.bold}Treasure Hunt${screen_1.ansi.reset}  ${screen_1.ansi.dim}Round ${game.round}/${game.maxRounds}  Found: ${game.score}${screen_1.ansi.reset}`);
+        lines.push(`  ${screen_1.ansi.dim}${"─".repeat(40)}${screen_1.ansi.reset}`);
+        lines.push("");
+        if (game.phase === "intro") {
+            lines.push(`  ${buddyName}: "${game.buddyReaction}"`);
+            lines.push("");
+            lines.push(`  ${screen_1.ansi.dim}Pick a door: [1] [2] [3]${screen_1.ansi.reset}`);
+            lines.push("");
+            lines.push(`  ${screen_1.ansi.dim}Press Enter to start...${screen_1.ansi.reset}`);
+        }
+        else if (game.phase === "playing") {
+            lines.push(`  ${buddyName}: "${game.buddyReaction}"`);
+            lines.push("");
+            if (!game.data.revealed) {
+                lines.push(`  ${screen_1.ansi.dim}Hint: ${game.data.hint}${screen_1.ansi.reset}`);
+                lines.push("");
+                lines.push(`    ${screen_1.ansi.bold}[1] 🚪    [2] 🚪    [3] 🚪${screen_1.ansi.reset}`);
+            }
+            else {
+                const hidden = game.data.hiddenDoor;
+                const doors = [1, 2, 3].map((d) => {
+                    if (d === hidden)
+                        return `${screen_1.ansi.colors.green}[${d}] ✓${screen_1.ansi.reset}`;
+                    return `${screen_1.ansi.dim}[${d}]${screen_1.ansi.reset}`;
+                });
+                lines.push(`    ${doors.join("    ")}`);
+            }
+        }
+        else {
+            lines.push(`  ${buddyName}: "${game.buddyReaction}"`);
+            lines.push("");
+            lines.push(`  ${screen_1.ansi.bold}Found: ${game.score}/${game.maxRounds}${screen_1.ansi.reset}`);
+            lines.push("");
+            lines.push(`  ${screen_1.ansi.dim}Press Enter to finish${screen_1.ansi.reset}`);
+        }
+        lines.push("");
+        return lines.join("\n");
+    },
+};
+(0, registry_1.registerGame)(handler);
+//# sourceMappingURL=treasurehunt.js.map

package/dist/minigames/types.d.ts

@@ -0,0 +1,30 @@
+export interface MiniGameDef {
+    id: string;
+    name: string;
+    description: string;
+    icon: string;
+}
+export interface MiniGameState {
+    active: boolean;
+    gameId: string;
+    phase: "intro" | "playing" | "result";
+    score: number;
+    round: number;
+    maxRounds: number;
+    buddyReaction: string;
+    data: Record<string, unknown>;
+    ticksInPhase: number;
+}
+export interface MiniGameHandler {
+    def: MiniGameDef;
+    start(): MiniGameState;
+    tick(game: MiniGameState): MiniGameState;
+    handleInput(key: string, game: MiniGameState): MiniGameState;
+    render(game: MiniGameState, buddyName: string): string;
+}
+export declare function createInactiveGame(): MiniGameState;
+/** Get XP reward based on score percentage */
+export declare function getXpReward(score: number, maxScore: number, baseXp: number): number;
+/** Pick a buddy reaction based on score percentage */
+export declare function getReaction(score: number, maxScore: number): string;
+//# sourceMappingURL=types.d.ts.map