clibuddy 1.0.0

package/dist/buddy/activities.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startActivity = startActivity;
+exports.applyActivityProgress = applyActivityProgress;
+exports.isActivityBlocked = isActivityBlocked;
+exports.activityTimeRemaining = activityTimeRemaining;
+exports.formatTimeRemaining = formatTimeRemaining;
+const leveling_1 = require("./leveling");
+const ACTIVITY_DEFS = {
+    sleeping: { durationMs: 120_000, statDeltas: { energy: 30 }, xpReward: 0 },
+    eating: { durationMs: 10_000, statDeltas: { hunger: 25 }, xpReward: 5 },
+    playing: { durationMs: 15_000, statDeltas: { happiness: 20, energy: -15 }, xpReward: 10 },
+};
+function clamp(value, min, max) {
+    return Math.max(min, Math.min(max, value));
+}
+/** Build an ActivityState for the given activity type based on current stats */
+/** Build an ActivityState. Pass statOverrides to use custom stat deltas (e.g. from inventory items). */
+function startActivity(state, type, statOverrides) {
+    const def = ACTIVITY_DEFS[type];
+    const deltas = statOverrides ?? def.statDeltas;
+    const baseline = {};
+    const target = {};
+    for (const [key, delta] of Object.entries(deltas)) {
+        baseline[key] = state.stats[key];
+        target[key] = clamp(state.stats[key] + delta, 0, 100);
+    }
+    return {
+        type,
+        startedAt: Date.now(),
+        durationMs: def.durationMs,
+        statBaseline: baseline,
+        statTarget: target,
+    };
+}
+/**
+ * Apply activity progress using linear interpolation.
+ * Returns updated state. Clears activity and awards XP when complete.
+ */
+function applyActivityProgress(state) {
+    if (!state.activity || state.activity.type === "idle")
+        return state;
+    const { activity } = state;
+    const elapsed = Date.now() - activity.startedAt;
+    const progress = clamp(elapsed / activity.durationMs, 0, 1);
+    // Interpolate stats
+    const stats = { ...state.stats };
+    for (const [key, baseVal] of Object.entries(activity.statBaseline)) {
+        const targetVal = activity.statTarget[key] ?? baseVal;
+        stats[key] = clamp(baseVal + (targetVal - baseVal) * progress, 0, 100);
+    }
+    // Activity complete
+    if (progress >= 1) {
+        const def = ACTIVITY_DEFS[activity.type];
+        let completed = {
+            ...state,
+            stats,
+            xp: state.xp + (def?.xpReward ?? 0),
+            activity: undefined,
+        };
+        // Check for level-up from activity XP
+        const { state: leveled } = (0, leveling_1.checkLevelUp)(completed);
+        return leveled;
+    }
+    return { ...state, stats };
+}
+/** Check if the current activity blocks a new action */
+function isActivityBlocked(currentActivity, attempted) {
+    const current = currentActivity ?? "idle";
+    if (current === "idle")
+        return false;
+    // Any active activity blocks new activities
+    return true;
+}
+/** Returns seconds remaining for the current activity */
+function activityTimeRemaining(activity) {
+    const elapsed = Date.now() - activity.startedAt;
+    return Math.max(0, Math.ceil((activity.durationMs - elapsed) / 1000));
+}
+/** Format remaining time as "1:42" or "8s" */
+function formatTimeRemaining(activity) {
+    const seconds = activityTimeRemaining(activity);
+    if (seconds >= 60) {
+        const m = Math.floor(seconds / 60);
+        const s = seconds % 60;
+        return `${m}:${s.toString().padStart(2, "0")}`;
+    }
+    return `${seconds}s`;
+}
+//# sourceMappingURL=activities.js.map

package/dist/buddy/decay.d.ts

@@ -0,0 +1,3 @@
+import { BuddyState } from "./types";
+export declare function applyDecay(state: BuddyState): BuddyState;
+//# sourceMappingURL=decay.d.ts.map

package/dist/buddy/decay.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyDecay = applyDecay;
+/** Stat decay per hour of real time */
+const DECAY_PER_HOUR = {
+    hunger: 3, // gets hungry slowly
+    happiness: 4, // gets bored faster
+    energy: 2, // rests slowly
+    health: 0, // health only decays when other stats are critically low
+};
+/** If hunger or happiness are below this, health starts decaying */
+const CRITICAL_THRESHOLD = 20;
+const HEALTH_DECAY_PER_HOUR = 5;
+function applyDecay(state) {
+    if (!state.alive)
+        return state;
+    // Don't decay while buddy is doing an activity
+    if (state.activity && state.activity.type !== "idle")
+        return state;
+    const now = Date.now();
+    const hoursElapsed = (now - state.lastUpdated) / (1000 * 60 * 60);
+    if (hoursElapsed < 0.01)
+        return state; // less than ~36 seconds, skip
+    const stats = { ...state.stats };
+    // Apply base decay
+    stats.hunger = Math.max(0, stats.hunger - DECAY_PER_HOUR.hunger * hoursElapsed);
+    stats.happiness = Math.max(0, stats.happiness - DECAY_PER_HOUR.happiness * hoursElapsed);
+    stats.energy = Math.max(0, stats.energy - DECAY_PER_HOUR.energy * hoursElapsed);
+    // Health decays if other stats are critical
+    if (stats.hunger < CRITICAL_THRESHOLD || stats.happiness < CRITICAL_THRESHOLD) {
+        stats.health = Math.max(0, stats.health - HEALTH_DECAY_PER_HOUR * hoursElapsed);
+    }
+    // Calculate age in hours
+    const age = (now - state.createdAt) / (1000 * 60 * 60);
+    // Check for death
+    const alive = stats.health > 0;
+    return {
+        ...state,
+        stats,
+        age,
+        alive,
+        lastUpdated: now,
+    };
+}
+//# sourceMappingURL=decay.js.map

package/dist/buddy/leveling.d.ts

@@ -0,0 +1,11 @@
+import { BuddyState } from "./types";
+export declare function xpForLevel(level: number): number;
+/**
+ * Check and apply level-up if XP threshold is met.
+ * Can level up multiple times if enough XP accumulated.
+ */
+export declare function checkLevelUp(state: BuddyState): {
+    state: BuddyState;
+    levelsGained: number;
+};
+//# sourceMappingURL=leveling.d.ts.map

package/dist/buddy/leveling.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.xpForLevel = xpForLevel;
+exports.checkLevelUp = checkLevelUp;
+function xpForLevel(level) {
+    return level * 50;
+}
+/**
+ * Check and apply level-up if XP threshold is met.
+ * Can level up multiple times if enough XP accumulated.
+ */
+function checkLevelUp(state) {
+    let levelsGained = 0;
+    let current = state;
+    while (current.xp >= xpForLevel(current.level)) {
+        current = {
+            ...current,
+            xp: current.xp - xpForLevel(current.level),
+            level: current.level + 1,
+        };
+        levelsGained++;
+    }
+    return { state: current, levelsGained };
+}
+//# sourceMappingURL=leveling.js.map

package/dist/buddy/roll.d.ts

@@ -0,0 +1,4 @@
+import { BuddyState, BuddySpecies } from "./types";
+export declare function rollBuddy(): BuddySpecies;
+export declare function createBuddyState(species: BuddySpecies, name: string): BuddyState;
+//# sourceMappingURL=roll.d.ts.map

package/dist/buddy/roll.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rollBuddy = rollBuddy;
+exports.createBuddyState = createBuddyState;
+const species_1 = require("./species");
+const types_1 = require("../story/types");
+/** Rarity weights — higher = more likely to be rolled */
+const RARITY_WEIGHTS = {
+    common: 50,
+    uncommon: 25,
+    rare: 15,
+    epic: 8,
+    legendary: 2,
+};
+function pickRarity() {
+    const entries = Object.entries(RARITY_WEIGHTS);
+    const totalWeight = entries.reduce((sum, [, w]) => sum + w, 0);
+    let roll = Math.random() * totalWeight;
+    for (const [rarity, weight] of entries) {
+        roll -= weight;
+        if (roll <= 0)
+            return rarity;
+    }
+    return "common";
+}
+function pickSpeciesOfRarity(rarity) {
+    const candidates = species_1.SPECIES.filter((s) => s.rarity === rarity);
+    return candidates[Math.floor(Math.random() * candidates.length)];
+}
+function rollBuddy() {
+    const rarity = pickRarity();
+    return pickSpeciesOfRarity(rarity);
+}
+function createBuddyState(species, name) {
+    return {
+        name,
+        speciesId: species.id,
+        stats: {
+            hunger: 80,
+            happiness: 80,
+            health: 100,
+            energy: 100,
+        },
+        xp: 0,
+        level: 1,
+        age: 0,
+        alive: true,
+        createdAt: Date.now(),
+        lastUpdated: Date.now(),
+        titles: [],
+        actionCounts: { feeds: 0, plays: 0, sleeps: 0, heals: 0, revives: 0, pets: 0, minigamesWon: 0, itemsFound: 0, combosTriggered: 0 },
+        inventory: [],
+        notifications: [],
+        adventureStats: {
+            adventuresCompleted: 0, battlesWon: 0, battlesLost: 0,
+            battlesFled: 0, bossesDefeated: 0, totalDamageDealt: 0, perfectAdventures: 0,
+        },
+        questProgress: (0, types_1.createDefaultQuestProgress)(),
+    };
+}
+//# sourceMappingURL=roll.js.map

package/dist/buddy/species.d.ts

@@ -0,0 +1,4 @@
+import { BuddySpecies } from "./types";
+export declare const SPECIES: BuddySpecies[];
+export declare function getSpecies(id: string): BuddySpecies | undefined;
+//# sourceMappingURL=species.d.ts.map