clibuddy 1.0.0

package/dist/inventory/finding.d.ts

@@ -0,0 +1,11 @@
+import { BuddyState } from "../buddy/types";
+import { ItemDef } from "./items";
+/**
+ * Check if the buddy finds an item this tick.
+ * ~0.1% chance per tick during idle = roughly every 10-15 minutes on average.
+ */
+export declare function checkForItemFind(state: BuddyState): {
+    item: ItemDef;
+    flavorText: string;
+} | null;
+//# sourceMappingURL=finding.d.ts.map

package/dist/inventory/finding.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkForItemFind = checkForItemFind;
+const items_1 = require("./items");
+const RARITY_WEIGHTS = { common: 60, uncommon: 30, rare: 10 };
+const GENERIC_FLAVOR = [
+    "was digging around and found",
+    "stumbled upon",
+    "spotted something shiny —",
+    "tripped over something... it's",
+    "sniffed out",
+    "was nosing around and discovered",
+    "found something hidden behind a rock:",
+    "noticed something glinting in the corner —",
+];
+const SPECIES_FLAVOR = {
+    rabbit: [
+        "was hopping around and kicked up",
+        "found something buried near a carrot patch:",
+        "dug a hole and uncovered",
+    ],
+    cat: [
+        "knocked something off a shelf —",
+        "batted something out from under the couch:",
+        "gracefully presented you with",
+    ],
+    frog: [
+        "found something in the pond:",
+        "caught something with its tongue! It's",
+        "sat on something interesting —",
+    ],
+    owl: [
+        "spotted something from above:",
+        "wisely located",
+        "used its keen eyes to find",
+    ],
+    fox: [
+        "snuck off and came back with",
+        "used its cunning to acquire",
+        "raided a stash and found",
+    ],
+    phoenix: [
+        "pulled something from the ashes:",
+        "set something ablaze and revealed",
+        "found something fireproof:",
+    ],
+    dragon: [
+        "added to its hoard:",
+        "declared ownership of",
+        "guarded a new treasure:",
+    ],
+};
+function pickRandom(arr) {
+    return arr[Math.floor(Math.random() * arr.length)];
+}
+const CONSUMABLE_TYPES = new Set(["food", "toy", "medicine"]);
+function rollItem() {
+    const total = RARITY_WEIGHTS.common + RARITY_WEIGHTS.uncommon + RARITY_WEIGHTS.rare;
+    let roll = Math.random() * total;
+    let rarity = "common";
+    roll -= RARITY_WEIGHTS.common;
+    if (roll > 0) {
+        rarity = "uncommon";
+        roll -= RARITY_WEIGHTS.uncommon;
+    }
+    if (roll > 0) {
+        rarity = "rare";
+    }
+    // Only consumables from idle finding — gear comes from adventures
+    const candidates = items_1.ITEMS.filter((i) => i.rarity === rarity && CONSUMABLE_TYPES.has(i.type));
+    if (candidates.length === 0)
+        return items_1.ITEMS.filter((i) => CONSUMABLE_TYPES.has(i.type))[0];
+    return pickRandom(candidates);
+}
+/**
+ * Check if the buddy finds an item this tick.
+ * ~0.1% chance per tick during idle = roughly every 10-15 minutes on average.
+ */
+function checkForItemFind(state) {
+    if (!state.alive)
+        return null;
+    if (state.activity && state.activity.type !== "idle")
+        return null;
+    if (Math.random() > 0.001)
+        return null;
+    const item = rollItem();
+    // Pick flavor text — species-specific 40% of the time
+    const speciesPool = SPECIES_FLAVOR[state.speciesId];
+    let intro;
+    if (speciesPool && Math.random() < 0.4) {
+        intro = pickRandom(speciesPool);
+    }
+    else {
+        intro = pickRandom(GENERIC_FLAVOR);
+    }
+    const flavorText = `${state.name} ${intro} a ${item.name}!`;
+    return { item, flavorText };
+}
+//# sourceMappingURL=finding.js.map

package/dist/inventory/items.d.ts

@@ -0,0 +1,31 @@
+import { BuddyStats } from "../buddy/types";
+export type ItemRarity = "common" | "uncommon" | "rare" | "epic" | "legendary";
+export type ItemType = "food" | "toy" | "medicine" | "weapon" | "armor" | "helmet" | "boots" | "accessory";
+export interface ItemDef {
+    id: string;
+    name: string;
+    description: string;
+    rarity: ItemRarity;
+    type: ItemType;
+    statEffect: Partial<BuddyStats>;
+    xpBonus: number;
+    combatATK?: number;
+    combatDEF?: number;
+    combatHP?: number;
+    combatSPD?: number;
+    critBonus?: number;
+    dodgeBonus?: number;
+    energyBonus?: number;
+    damageReduction?: number;
+    gearElement?: string;
+    onHitEffect?: string;
+    onHitChance?: number;
+    onHitPower?: number;
+}
+export declare const ITEMS: ItemDef[];
+export declare function getItem(id: string): ItemDef | undefined;
+export declare function isGear(item: ItemDef): boolean;
+/** Add an item to inventory. Gear is unique (count always 1, no duplicates). Consumables stack. */
+export declare function addItemToInventory(inventory: import("../buddy/types").InventorySlot[], itemId: string): import("../buddy/types").InventorySlot[];
+export declare const ITEM_RARITY_COLORS: Record<ItemRarity, string>;
+//# sourceMappingURL=items.d.ts.map

package/dist/inventory/items.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ITEM_RARITY_COLORS = exports.ITEMS = void 0;
+exports.getItem = getItem;
+exports.isGear = isGear;
+exports.addItemToInventory = addItemToInventory;
+const gear_1 = require("../adventure/combat/gear");
+exports.ITEMS = [
+    // ─── Consumables ───────────────────────────────────
+    // Food
+    { id: "berry", name: "Berry", description: "+15 hunger", rarity: "common", type: "food", statEffect: { hunger: 15 }, xpBonus: 3 },
+    { id: "fish", name: "Fish", description: "+25 hunger", rarity: "uncommon", type: "food", statEffect: { hunger: 25 }, xpBonus: 5 },
+    { id: "cake", name: "Cake", description: "+40 hunger, +10 happiness", rarity: "rare", type: "food", statEffect: { hunger: 40, happiness: 10 }, xpBonus: 8 },
+    // Toys
+    { id: "stick", name: "Stick", description: "+15 happiness", rarity: "common", type: "toy", statEffect: { happiness: 15 }, xpBonus: 5 },
+    { id: "ball", name: "Ball", description: "+25 happiness", rarity: "uncommon", type: "toy", statEffect: { happiness: 25 }, xpBonus: 8 },
+    { id: "puzzle", name: "Puzzle", description: "+30 happiness, +15 XP", rarity: "rare", type: "toy", statEffect: { happiness: 30 }, xpBonus: 15 },
+    // Medicine
+    { id: "herb", name: "Herb", description: "+15 health", rarity: "common", type: "medicine", statEffect: { health: 15 }, xpBonus: 2 },
+    { id: "potion", name: "Potion", description: "+35 health", rarity: "uncommon", type: "medicine", statEffect: { health: 35 }, xpBonus: 5 },
+    { id: "elixir", name: "Elixir", description: "+50 health, +20 energy", rarity: "rare", type: "medicine", statEffect: { health: 50, energy: 20 }, xpBonus: 10 },
+    // Epic/Legendary consumables
+    { id: "golden_apple", name: "Golden Apple", description: "+60 hunger, +15 happiness", rarity: "epic", type: "food", statEffect: { hunger: 60, happiness: 15 }, xpBonus: 12 },
+    { id: "dragon_steak", name: "Dragon Steak", description: "+50 hunger, +10 energy", rarity: "epic", type: "food", statEffect: { hunger: 50, energy: 10 }, xpBonus: 15 },
+    { id: "enchanted_ball", name: "Enchanted Ball", description: "+40 happiness, +10 energy", rarity: "epic", type: "toy", statEffect: { happiness: 40, energy: 10 }, xpBonus: 12 },
+    { id: "phoenix_tears", name: "Phoenix Tears", description: "+60 health, +30 energy", rarity: "epic", type: "medicine", statEffect: { health: 60, energy: 30 }, xpBonus: 15 },
+    { id: "ambrosia", name: "Ambrosia", description: "+80 hunger, +20 happiness, +10 hp", rarity: "legendary", type: "food", statEffect: { hunger: 80, happiness: 20, health: 10 }, xpBonus: 20 },
+    { id: "elixir_of_life", name: "Elixir of Life", description: "+100 health, +50 energy", rarity: "legendary", type: "medicine", statEffect: { health: 100, energy: 50 }, xpBonus: 25 },
+    // ─── Gear (from adventure system) ──────────────────
+    ...gear_1.GEAR_ITEMS,
+];
+function getItem(id) {
+    return exports.ITEMS.find((i) => i.id === id);
+}
+function isGear(item) {
+    return item.type === "weapon" || item.type === "armor" || item.type === "helmet" || item.type === "boots" || item.type === "accessory";
+}
+/** Add an item to inventory. Gear is unique (count always 1, no duplicates). Consumables stack. */
+function addItemToInventory(inventory, itemId) {
+    const item = getItem(itemId);
+    if (!item)
+        return inventory;
+    const existing = inventory.find((s) => s.itemId === itemId);
+    if (isGear(item)) {
+        // Gear: own 0 or 1, never stack
+        if (existing)
+            return inventory; // already owned
+        return [...inventory, { itemId, count: 1 }];
+    }
+    // Consumable: stack
+    if (existing) {
+        return inventory.map((s) => s.itemId === itemId ? { ...s, count: s.count + 1 } : s);
+    }
+    return [...inventory, { itemId, count: 1 }];
+}
+exports.ITEM_RARITY_COLORS = {
+    common: "\x1b[37m",
+    uncommon: "\x1b[32m",
+    rare: "\x1b[33m",
+    epic: "\x1b[35m",
+    legendary: "\x1b[33m",
+};
+//# sourceMappingURL=items.js.map

package/dist/minigames/copycat.d.ts

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

package/dist/minigames/copycat.js

@@ -0,0 +1,153 @@
+"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"];
+function pickRandom(arr) {
+    return arr[Math.floor(Math.random() * arr.length)];
+}
+const handler = {
+    def: {
+        id: "copycat",
+        name: "Copycat",
+        description: "Remember and repeat the sequence!",
+        icon: "★",
+    },
+    start() {
+        return {
+            active: true,
+            gameId: "copycat",
+            phase: "intro",
+            score: 0,
+            round: 1,
+            maxRounds: 10,
+            buddyReaction: "Watch closely!",
+            data: {
+                sequence: [Math.floor(Math.random() * 4)],
+                showIndex: 0, // which symbol is being shown
+                playerIndex: 0, // which symbol player is inputting
+                subPhase: "showing", // "showing" | "input"
+            },
+            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, subPhase: "showing", showIndex: 0 } };
+        }
+        if (game.phase === "playing" && game.data.subPhase === "showing") {
+            const seq = game.data.sequence;
+            const showIndex = game.data.showIndex;
+            // Show each symbol for 2 ticks (1.6s)
+            if (game.ticksInPhase > 0 && game.ticksInPhase % 2 === 0) {
+                const nextIndex = showIndex + 1;
+                if (nextIndex >= seq.length) {
+                    // Done showing, switch to input
+                    return { ...game, ticksInPhase: 0, data: { ...game.data, subPhase: "input", playerIndex: 0 }, buddyReaction: "Your turn!" };
+                }
+                return { ...game, data: { ...game.data, showIndex: nextIndex } };
+            }
+        }
+        if (game.phase === "result") {
+            return game;
+        }
+        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 }; // Signal to finish
+            }
+            return game;
+        }
+        if (game.phase !== "playing" || game.data.subPhase !== "input")
+            return game;
+        const keyIndex = KEYS.indexOf(key);
+        if (keyIndex === -1)
+            return game;
+        const seq = game.data.sequence;
+        const playerIndex = game.data.playerIndex;
+        if (keyIndex !== seq[playerIndex]) {
+            // Wrong! Game over
+            return {
+                ...game,
+                phase: "result",
+                ticksInPhase: 0,
+                buddyReaction: (0, types_1.getReaction)(game.score, game.maxRounds),
+            };
+        }
+        // Correct
+        const nextPlayerIndex = playerIndex + 1;
+        if (nextPlayerIndex >= seq.length) {
+            // Completed the sequence! Next round
+            const newSeq = [...seq, Math.floor(Math.random() * 4)];
+            const newScore = game.score + 1;
+            if (newScore >= game.maxRounds) {
+                return { ...game, score: newScore, phase: "result", ticksInPhase: 0, buddyReaction: "PERFECT! You got them all!" };
+            }
+            return {
+                ...game,
+                score: newScore,
+                round: game.round + 1,
+                ticksInPhase: 0,
+                buddyReaction: newScore >= 5 ? "Wow, you remembered that?!" : "Nice!",
+                data: { ...game.data, sequence: newSeq, showIndex: 0, subPhase: "showing", playerIndex: 0 },
+            };
+        }
+        return { ...game, data: { ...game.data, playerIndex: nextPlayerIndex } };
+    },
+    render(game, buddyName) {
+        const lines = [];
+        lines.push("");
+        lines.push(`  ${screen_1.ansi.bold}Copycat${screen_1.ansi.reset}  ${screen_1.ansi.dim}Round ${game.round}  Score: ${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}: "Watch closely and repeat the sequence!"`);
+            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 seq = game.data.sequence;
+            if (game.data.subPhase === "showing") {
+                lines.push(`  ${buddyName}: "Watch closely!"`);
+                lines.push("");
+                const showIndex = game.data.showIndex;
+                const symbol = SYMBOLS[seq[showIndex]];
+                lines.push(`  ${screen_1.ansi.bold}${screen_1.ansi.colors.yellow}    ${symbol}${screen_1.ansi.reset}`);
+                lines.push("");
+                lines.push(`  ${screen_1.ansi.dim}Showing ${showIndex + 1}/${seq.length}...${screen_1.ansi.reset}`);
+            }
+            else {
+                const playerIndex = game.data.playerIndex;
+                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}Input ${playerIndex + 1}/${seq.length}...${screen_1.ansi.reset}`);
+            }
+        }
+        else {
+            lines.push(`  ${buddyName}: "${game.buddyReaction}"`);
+            lines.push("");
+            lines.push(`  ${screen_1.ansi.bold}Score: ${game.score}${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=copycat.js.map

package/dist/minigames/fetch.d.ts

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

package/dist/minigames/fetch.js

@@ -0,0 +1,179 @@
+"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 FIELD_WIDTH = 30;
+const CATCH_ZONE_START = 12;
+const CATCH_ZONE_END = 18;
+const handler = {
+    def: {
+        id: "fetch",
+        name: "Fetch",
+        description: "Catch the ball at the right moment!",
+        icon: "◎",
+    },
+    start() {
+        return {
+            active: true,
+            gameId: "fetch",
+            phase: "intro",
+            score: 0,
+            round: 1,
+            maxRounds: 5,
+            buddyReaction: "Throw it! Throw it!",
+            data: {
+                ballPos: 0,
+                ballSpeed: 1,
+                ballDirection: 1,
+                caught: false,
+                roundResult: "", // "perfect" | "good" | "miss" | ""
+            },
+            ticksInPhase: 0,
+        };
+    },
+    tick(game) {
+        game = { ...game, ticksInPhase: game.ticksInPhase + 1 };
+        if (game.phase === "intro" && game.ticksInPhase > 3) {
+            return { ...game, phase: "playing", ticksInPhase: 0 };
+        }
+        if (game.phase === "playing" && !game.data.caught) {
+            // Move ball
+            let pos = game.data.ballPos;
+            const speed = game.data.ballSpeed;
+            const dir = game.data.ballDirection;
+            pos += speed * dir;
+            // Bounce at edges
+            let newDir = dir;
+            if (pos >= FIELD_WIDTH - 1) {
+                pos = FIELD_WIDTH - 1;
+                newDir = -1;
+            }
+            if (pos <= 0) {
+                pos = 0;
+                newDir = 1;
+            }
+            return { ...game, data: { ...game.data, ballPos: pos, ballDirection: newDir } };
+        }
+        // After catching/missing, advance to next round
+        if (game.phase === "playing" && game.data.caught && game.ticksInPhase > 3) {
+            if (game.round >= game.maxRounds) {
+                return { ...game, phase: "result", ticksInPhase: 0, buddyReaction: (0, types_1.getReaction)(game.score, game.maxRounds * 2) };
+            }
+            // Next round — faster ball
+            return {
+                ...game,
+                round: game.round + 1,
+                ticksInPhase: 0,
+                data: {
+                    ballPos: 0,
+                    ballSpeed: 1 + game.round * 0.5,
+                    ballDirection: 1,
+                    caught: false,
+                    roundResult: "",
+                },
+                buddyReaction: "Again! 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.caught)
+            return game;
+        // Space to catch
+        if (key === " ") {
+            const pos = game.data.ballPos;
+            const center = (CATCH_ZONE_START + CATCH_ZONE_END) / 2;
+            const dist = Math.abs(pos - center);
+            let result;
+            let points;
+            let reaction;
+            if (dist <= 1) {
+                result = "perfect";
+                points = 2;
+                reaction = "PERFECT CATCH!";
+            }
+            else if (pos >= CATCH_ZONE_START && pos <= CATCH_ZONE_END) {
+                result = "good";
+                points = 1;
+                reaction = "Nice catch!";
+            }
+            else {
+                result = "miss";
+                points = 0;
+                reaction = "Missed it! Aww...";
+            }
+            return {
+                ...game,
+                score: game.score + points,
+                ticksInPhase: 0,
+                data: { ...game.data, caught: true, roundResult: result },
+                buddyReaction: reaction,
+            };
+        }
+        return game;
+    },
+    render(game, buddyName) {
+        const lines = [];
+        lines.push("");
+        lines.push(`  ${screen_1.ansi.bold}Fetch${screen_1.ansi.reset}  ${screen_1.ansi.dim}Round ${game.round}/${game.maxRounds}  Points: ${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}Press Space when the ball is in the [===] zone!${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("");
+            // Draw the field
+            const pos = Math.round(game.data.ballPos);
+            let field = "";
+            for (let i = 0; i < FIELD_WIDTH; i++) {
+                if (i === pos && !game.data.caught) {
+                    field += `${screen_1.ansi.bold}o${screen_1.ansi.reset}`;
+                }
+                else if (i >= CATCH_ZONE_START && i <= CATCH_ZONE_END) {
+                    field += `${screen_1.ansi.colors.green}=${screen_1.ansi.reset}`;
+                }
+                else {
+                    field += `${screen_1.ansi.dim}-${screen_1.ansi.reset}`;
+                }
+            }
+            lines.push(`  ${field}`);
+            lines.push("");
+            if (!game.data.caught) {
+                lines.push(`  ${screen_1.ansi.dim}Press Space to catch!${screen_1.ansi.reset}`);
+            }
+            else {
+                const result = game.data.roundResult;
+                const color = result === "perfect" ? screen_1.ansi.colors.yellow : result === "good" ? screen_1.ansi.colors.green : screen_1.ansi.colors.red;
+                lines.push(`  ${color}${result.toUpperCase()}!${screen_1.ansi.reset}`);
+            }
+        }
+        else {
+            lines.push(`  ${buddyName}: "${game.buddyReaction}"`);
+            lines.push("");
+            lines.push(`  ${screen_1.ansi.bold}Total Points: ${game.score}/${game.maxRounds * 2}${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=fetch.js.map

package/dist/minigames/moodmatch.d.ts

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