pet-terminal 1.0.0

package/dist/core/pet.js

@@ -0,0 +1,781 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Pet = void 0;
+const pet_1 = require("../types/pet");
+const species_1 = require("../types/species");
+const stats_1 = require("../types/stats");
+const level_system_1 = require("./level-system");
+const time_decay_1 = require("./time-decay");
+const inventory_1 = require("./inventory");
+const items_1 = require("../types/items");
+const shop_1 = require("./shop");
+const git_monitor_1 = require("../monitor/git-monitor");
+const git_1 = require("../types/git");
+const auto_care_1 = require("./auto-care");
+class Pet {
+    constructor(data, db) {
+        this.synced = false;
+        this.data = data;
+        this.db = db;
+        this.timeDecay = new time_decay_1.TimeDecay();
+        this.inventory = new inventory_1.Inventory(data.inventory || []);
+    }
+    static async loadOrCreate(db) {
+        if (db.hasPet()) {
+            const petData = db.getPet();
+            const pet = new Pet(petData, db);
+            // Auto-sync time on load
+            pet.syncTime();
+            return pet;
+        }
+        // Create a default pet
+        const now = new Date().toISOString();
+        const startingInventory = (0, items_1.getStartingInventory)();
+        const defaultData = {
+            id: (0, pet_1.generatePetId)(),
+            name: 'Buddy',
+            species: species_1.PetSpecies.CAT,
+            level: 1,
+            experience: 0,
+            stats: { ...pet_1.DEFAULT_STATS },
+            mood: species_1.MoodState.HAPPY,
+            isSleeping: false,
+            birthDate: now,
+            lastInteraction: now,
+            lastSaveTime: now,
+            lastUpdated: now,
+            totalInteractions: 0,
+            inventory: startingInventory,
+            coins: pet_1.STARTING_COINS,
+            coinHistory: [],
+            // Git tracking fields
+            lastGitCommit: undefined,
+            gitCommitCount: 0,
+            gitStreak: 0,
+            lastGitDate: undefined,
+        };
+        db.savePet(defaultData);
+        return new Pet(defaultData, db);
+    }
+    static createNew(db, name, species) {
+        const now = new Date().toISOString();
+        const startingInventory = (0, items_1.getStartingInventory)();
+        const newPet = {
+            id: (0, pet_1.generatePetId)(),
+            name,
+            species,
+            level: 1,
+            experience: 0,
+            stats: { ...pet_1.DEFAULT_STATS },
+            mood: species_1.MoodState.HAPPY,
+            isSleeping: false,
+            birthDate: now,
+            lastInteraction: now,
+            lastSaveTime: now,
+            lastUpdated: now,
+            totalInteractions: 0,
+            inventory: startingInventory,
+            coins: pet_1.STARTING_COINS,
+            coinHistory: [],
+            // Git tracking fields
+            lastGitCommit: undefined,
+            gitCommitCount: 0,
+            gitStreak: 0,
+            lastGitDate: undefined,
+        };
+        db.savePet(newPet);
+        return newPet;
+    }
+    // ===== ACTIONS =====
+    feed() {
+        if (this.data.isSleeping) {
+            return {
+                success: false,
+                message: `${this.data.name} is sleeping! Wake them up first.`,
+                statChanges: [],
+                xpGained: 0,
+            };
+        }
+        if (this.data.stats.hunger >= 95) {
+            return {
+                success: false,
+                message: `${this.data.name} is too full to eat more!`,
+                statChanges: [],
+                xpGained: 0,
+            };
+        }
+        const changes = [
+            { stat: 'hunger', delta: 25 },
+            { stat: 'happiness', delta: 4 },
+            { stat: 'health', delta: 2 },
+            { stat: 'cleanliness', delta: -4 },
+            { stat: 'energy', delta: -2 },
+        ];
+        return this.performAction(changes, 10, 'fed');
+    }
+    play() {
+        if (this.data.isSleeping) {
+            return {
+                success: false,
+                message: `${this.data.name} is sleeping! Wake them up first.`,
+                statChanges: [],
+                xpGained: 0,
+            };
+        }
+        if (this.data.stats.energy < 15) {
+            return {
+                success: false,
+                message: `${this.data.name} is too tired to play! Let them rest.`,
+                statChanges: [],
+                xpGained: 0,
+            };
+        }
+        const changes = [
+            { stat: 'hunger', delta: -5 },
+            { stat: 'happiness', delta: 23 },
+            { stat: 'health', delta: 1 },
+            { stat: 'cleanliness', delta: -4 },
+            { stat: 'energy', delta: -20 },
+        ];
+        return this.performAction(changes, 15, 'played with');
+    }
+    clean() {
+        if (this.data.isSleeping) {
+            return {
+                success: false,
+                message: `${this.data.name} is sleeping! Wake them up first.`,
+                statChanges: [],
+                xpGained: 0,
+            };
+        }
+        if (this.data.stats.cleanliness >= 95) {
+            return {
+                success: false,
+                message: `${this.data.name} is already very clean!`,
+                statChanges: [],
+                xpGained: 0,
+            };
+        }
+        const changes = [
+            { stat: 'hunger', delta: -2 },
+            { stat: 'happiness', delta: 5 },
+            { stat: 'health', delta: 3 },
+            { stat: 'cleanliness', delta: 35 },
+            { stat: 'energy', delta: -3 },
+        ];
+        return this.performAction(changes, 8, 'cleaned');
+    }
+    sleep() {
+        if (!this.data.isSleeping) {
+            // Going to sleep
+            this.data.isSleeping = true;
+            this.updateInteraction();
+            this.save();
+            return {
+                success: true,
+                message: `${this.data.name} is now sleeping. Shh! 💤`,
+                statChanges: [],
+                xpGained: 5,
+            };
+        }
+        else {
+            // Waking up
+            const changes = [
+                { stat: 'hunger', delta: -5 },
+                { stat: 'happiness', delta: 8 },
+                { stat: 'health', delta: 5 },
+                { stat: 'cleanliness', delta: -2 },
+                { stat: 'energy', delta: 80 },
+            ];
+            this.data.isSleeping = false;
+            const result = this.performAction(changes, 5, 'woke up');
+            result.message = `${this.data.name} woke up refreshed! ☀️`;
+            return result;
+        }
+    }
+    heal() {
+        if (this.data.isSleeping) {
+            return {
+                success: false,
+                message: `${this.data.name} is sleeping! Wake them up first.`,
+                statChanges: [],
+                xpGained: 0,
+            };
+        }
+        if (this.data.stats.health >= 90) {
+            return {
+                success: false,
+                message: `${this.data.name} is already very healthy!`,
+                statChanges: [],
+                xpGained: 0,
+            };
+        }
+        const changes = [
+            { stat: 'hunger', delta: -3 },
+            { stat: 'happiness', delta: 2 },
+            { stat: 'health', delta: 30 },
+            { stat: 'cleanliness', delta: 5 },
+            { stat: 'energy', delta: -5 },
+        ];
+        return this.performAction(changes, 20, 'healed');
+    }
+    // ===== STATE QUERIES =====
+    getData() {
+        return { ...this.data };
+    }
+    getCurrentMood() {
+        return this.calculateMood();
+    }
+    getLevelProgress() {
+        return level_system_1.LevelSystem.getLevelProgress(this.data.level, this.data.experience);
+    }
+    getXPToNextLevel() {
+        return level_system_1.LevelSystem.getXPToNextLevel(this.data.level, this.data.experience);
+    }
+    getLevelTitle() {
+        return level_system_1.LevelSystem.getLevelTitle(this.data.level);
+    }
+    // ===== TIME SYNC =====
+    /**
+     * Sync time and apply stat decay based on elapsed time
+     * Returns the sync result if changes were applied, null if no significant time passed
+     */
+    syncTime() {
+        const now = new Date();
+        const lastUpdated = new Date(this.data.lastUpdated || this.data.lastSaveTime);
+        const hoursPassed = (now.getTime() - lastUpdated.getTime()) / (1000 * 60 * 60);
+        // Skip if less than 1 minute passed
+        if (hoursPassed < 0.017) {
+            return null;
+        }
+        const result = this.timeDecay.calculateDecay(hoursPassed, this.data.stats, this.data.isSleeping);
+        // Apply the decayed stats
+        this.data.stats = result.newStats;
+        this.updateMood();
+        // Update lastUpdated timestamp
+        this.data.lastUpdated = now.toISOString();
+        // Only save if significant changes occurred
+        if (result.statChanges.length > 0) {
+            this.save();
+        }
+        this.synced = true;
+        return result;
+    }
+    /**
+     * Get hours passed since last update
+     */
+    getHoursSinceUpdate() {
+        const now = new Date();
+        const lastUpdated = new Date(this.data.lastUpdated || this.data.lastSaveTime);
+        return (now.getTime() - lastUpdated.getTime()) / (1000 * 60 * 60);
+    }
+    /**
+     * Check if pet needs care (has critical stats)
+     */
+    needsCare() {
+        const { stats } = this.data;
+        return (stats.hunger < 30 ||
+            stats.happiness < 30 ||
+            stats.health < 40 ||
+            stats.cleanliness < 30 ||
+            stats.energy < 20);
+    }
+    // ===== PERSISTENCE =====
+    save() {
+        this.data.lastUpdated = new Date().toISOString();
+        this.data.inventory = this.inventory.serialize();
+        this.db.savePet(this.data);
+    }
+    // ===== INVENTORY =====
+    getInventory() {
+        return this.inventory;
+    }
+    useItem(itemId) {
+        const item = this.inventory.getItemQuantity(itemId);
+        if (item <= 0) {
+            return {
+                success: false,
+                message: `You don't have this item!`,
+                statChanges: [],
+                xpGained: 0,
+            };
+        }
+        // Remove the item
+        this.inventory.removeItem(itemId, 1);
+        // Get item definition and apply effects
+        const itemDef = (0, items_1.getItem)(itemId);
+        if (!itemDef) {
+            return {
+                success: false,
+                message: `Unknown item!`,
+                statChanges: [],
+                xpGained: 0,
+            };
+        }
+        // Convert item effects to stat changes
+        const changes = [];
+        if (itemDef.effect.hunger)
+            changes.push({ stat: 'hunger', delta: itemDef.effect.hunger });
+        if (itemDef.effect.happiness)
+            changes.push({ stat: 'happiness', delta: itemDef.effect.happiness });
+        if (itemDef.effect.health)
+            changes.push({ stat: 'health', delta: itemDef.effect.health });
+        if (itemDef.effect.cleanliness)
+            changes.push({ stat: 'cleanliness', delta: itemDef.effect.cleanliness });
+        if (itemDef.effect.energy)
+            changes.push({ stat: 'energy', delta: itemDef.effect.energy });
+        // Award coins based on item type
+        let coinReason;
+        switch (itemDef.type) {
+            case items_1.ItemType.FOOD:
+                coinReason = shop_1.CoinReason.FEED;
+                break;
+            case items_1.ItemType.TOY:
+                coinReason = shop_1.CoinReason.PLAY;
+                break;
+            case items_1.ItemType.CLEANING:
+                coinReason = shop_1.CoinReason.CLEAN;
+                break;
+            case items_1.ItemType.MEDICINE:
+                coinReason = shop_1.CoinReason.HEAL;
+                break;
+            default:
+                coinReason = shop_1.CoinReason.FEED;
+        }
+        const coinsEarned = shop_1.Shop.getCoinReward(coinReason);
+        if (coinsEarned > 0) {
+            this.earnCoins(coinsEarned, coinReason);
+        }
+        return this.performAction(changes, itemDef.xpReward, `used ${itemDef.name}`);
+    }
+    addItem(itemId, quantity = 1) {
+        this.inventory.addItem(itemId, quantity);
+        this.save();
+    }
+    hasItem(itemId) {
+        return this.inventory.hasItem(itemId);
+    }
+    // ===== COINS =====
+    /**
+     * Get current coin balance
+     */
+    getCoins() {
+        return this.data.coins || 0;
+    }
+    /**
+     * Earn coins from an activity
+     * @param amount - Number of coins earned
+     * @param reason - Source of coins (feed, play, git_commit, etc.)
+     */
+    earnCoins(amount, reason) {
+        // Initialize coins if not present (for backward compatibility)
+        if (typeof this.data.coins !== 'number') {
+            this.data.coins = 0;
+        }
+        if (!Array.isArray(this.data.coinHistory)) {
+            this.data.coinHistory = [];
+        }
+        this.data.coins += amount;
+        // Record the coin entry
+        const entry = {
+            amount,
+            reason,
+            timestamp: new Date().toISOString(),
+        };
+        this.data.coinHistory.push(entry);
+        // Keep only last 100 entries to save space
+        if (this.data.coinHistory.length > 100) {
+            this.data.coinHistory = this.data.coinHistory.slice(-100);
+        }
+        this.save();
+    }
+    /**
+     * Spend coins (returns true if successful)
+     * @param amount - Number of coins to spend
+     */
+    spendCoins(amount) {
+        if (this.getCoins() < amount) {
+            return false;
+        }
+        this.data.coins -= amount;
+        // Initialize coinHistory if needed
+        if (!Array.isArray(this.data.coinHistory)) {
+            this.data.coinHistory = [];
+        }
+        // Record the spending as a negative entry
+        const entry = {
+            amount: -amount,
+            reason: shop_1.CoinReason.GIFT, // Using GIFT as a generic marker for purchases
+            timestamp: new Date().toISOString(),
+        };
+        this.data.coinHistory.push(entry);
+        this.save();
+        return true;
+    }
+    /**
+     * Get coins earned today
+     */
+    getTodayCoins() {
+        if (!Array.isArray(this.data.coinHistory)) {
+            return 0;
+        }
+        const today = new Date().toDateString();
+        return this.data.coinHistory
+            .filter((entry) => {
+            const entryDate = new Date(entry.timestamp).toDateString();
+            return entryDate === today && entry.amount > 0;
+        })
+            .reduce((sum, entry) => sum + entry.amount, 0);
+    }
+    /**
+     * Get total lifetime coins earned
+     */
+    getTotalCoinsEarned() {
+        if (!Array.isArray(this.data.coinHistory)) {
+            return 0;
+        }
+        return this.data.coinHistory
+            .filter((entry) => entry.amount > 0)
+            .reduce((sum, entry) => sum + entry.amount, 0);
+    }
+    // ===== GIT METHODS =====
+    /**
+     * Get current Git streak
+     */
+    getGitStreak() {
+        return this.data.gitStreak || 0;
+    }
+    /**
+     * Get total Git commits rewarded
+     */
+    getGitCommitCount() {
+        return this.data.gitCommitCount || 0;
+    }
+    /**
+     * Get last rewarded commit hash
+     */
+    getLastGitCommit() {
+        return this.data.lastGitCommit;
+    }
+    /**
+     * Check and reward new Git commits
+     * Returns a GitProcessResult with details of what was rewarded
+     */
+    async checkGitCommits() {
+        const monitor = new git_monitor_1.GitMonitor();
+        // Check if Git is available
+        const gitAvailable = await git_monitor_1.GitMonitor.isGitAvailable();
+        if (!gitAvailable) {
+            return {
+                success: false,
+                newCommits: 0,
+                totalCoins: 0,
+                totalXP: 0,
+                streak: this.getGitStreak(),
+                rewards: [],
+                error: 'Git is not installed or not available in PATH',
+            };
+        }
+        // Check if we're in a Git repo
+        if (!monitor.isInGitRepo()) {
+            return {
+                success: false,
+                newCommits: 0,
+                totalCoins: 0,
+                totalXP: 0,
+                streak: this.getGitStreak(),
+                rewards: [],
+                error: 'Not a Git repository. Initialize a repo with: git init',
+            };
+        }
+        let newCommits = [];
+        // Get commits since last rewarded commit
+        if (this.data.lastGitCommit) {
+            newCommits = await monitor.getCommitsSince(this.data.lastGitCommit);
+        }
+        else {
+            // First time checking - get all commits
+            newCommits = await monitor.getAllCommits(50);
+        }
+        // Filter out already rewarded commits (by hash)
+        const lastHash = this.data.lastGitCommit;
+        const trulyNewCommits = lastHash
+            ? newCommits.filter(c => c.hash !== lastHash && c.hash.startsWith(lastHash) === false)
+            : newCommits;
+        if (trulyNewCommits.length === 0) {
+            return {
+                success: true,
+                newCommits: 0,
+                totalCoins: 0,
+                totalXP: 0,
+                streak: this.getGitStreak(),
+                rewards: [],
+            };
+        }
+        // Process each commit and calculate rewards
+        const rewards = [];
+        let totalCoins = 0;
+        let totalXP = 0;
+        // Sort commits by date (oldest first)
+        trulyNewCommits.sort((a, b) => a.date.getTime() - b.date.getTime());
+        for (const commit of trulyNewCommits) {
+            const reward = this.processGitCommit(commit, monitor);
+            rewards.push(reward);
+            totalCoins += reward.coins;
+            totalXP += reward.xp;
+        }
+        // Update streak based on commit dates
+        this.updateGitStreak(trulyNewCommits);
+        // Update last rewarded commit (most recent)
+        const mostRecent = trulyNewCommits[trulyNewCommits.length - 1];
+        this.data.lastGitCommit = mostRecent.shortHash;
+        this.data.gitCommitCount = (this.data.gitCommitCount || 0) + trulyNewCommits.length;
+        // Add streak bonus coins
+        const streakBonus = this.calculateStreakBonus();
+        if (streakBonus > 0) {
+            totalCoins += streakBonus;
+            // Add streak bonus to coin history
+            if (streakBonus >= 50) {
+                this.earnCoins(streakBonus, shop_1.CoinReason.GIT_STREAK_30);
+            }
+            else if (streakBonus >= 10) {
+                this.earnCoins(streakBonus, shop_1.CoinReason.GIT_STREAK_7);
+            }
+            else if (streakBonus > 0) {
+                this.earnCoins(streakBonus, shop_1.CoinReason.GIT_STREAK_DAILY);
+            }
+        }
+        this.save();
+        return {
+            success: true,
+            newCommits: trulyNewCommits.length,
+            totalCoins,
+            totalXP,
+            streak: this.getGitStreak(),
+            rewards,
+        };
+    }
+    /**
+     * Process a single Git commit and return the reward details
+     */
+    processGitCommit(commit, monitor) {
+        const reward = monitor.calculateReward(commit);
+        const bonuses = [];
+        // Determine coin reason based on commit type
+        let coinReason;
+        const baseCoins = reward.baseCoins;
+        const baseXP = reward.baseXP;
+        switch (reward.commitType) {
+            case git_1.GitCommitType.BUG_FIX:
+                coinReason = shop_1.CoinReason.GIT_COMMIT_BUG_FIX;
+                break;
+            case git_1.GitCommitType.FEATURE:
+                coinReason = shop_1.CoinReason.GIT_COMMIT_FEATURE;
+                break;
+            case git_1.GitCommitType.REFACTOR:
+                coinReason = shop_1.CoinReason.GIT_COMMIT_REFACTOR;
+                break;
+            default:
+                coinReason = shop_1.CoinReason.GIT_COMMIT_NORMAL;
+                break;
+        }
+        let totalCoins = baseCoins;
+        let totalXP = baseXP;
+        // Apply night owl bonus (2x coins)
+        if (reward.nightBonus) {
+            totalCoins = baseCoins * 2;
+            bonuses.push('🦉 Night Owl Bonus! 2x coins!');
+        }
+        // Apply large commit bonus
+        if (reward.largeBonus) {
+            totalCoins += 5;
+            totalXP += 10;
+            bonuses.push(`📦 Large Commit Bonus!`);
+            this.earnCoins(5, shop_1.CoinReason.GIT_LARGE_BONUS);
+        }
+        // Award base coins
+        this.earnCoins(totalCoins, coinReason);
+        // Award XP
+        this.addExperience(totalXP);
+        // NEW: Apply stat bonuses from Git commit (陪伴效果 - writing code = being with pet)
+        const statBonus = this.calculateGitStatBonus();
+        this.applyStatDirectly('hunger', statBonus.hunger);
+        this.applyStatDirectly('happiness', statBonus.happiness);
+        // Add friendly message about pet enjoying the company
+        bonuses.push(`💚 ${this.data.name} enjoyed watching you code! (+${statBonus.hunger} hunger, +${statBonus.happiness} happiness)`);
+        return {
+            shortHash: commit.shortHash,
+            message: commit.message,
+            type: reward.commitType,
+            coins: totalCoins,
+            xp: totalXP,
+            bonuses,
+        };
+    }
+    /**
+     * Calculate stat bonuses from Git commits
+     * Philosophy: Writing code = being with your pet
+     */
+    calculateGitStatBonus() {
+        const streak = this.getGitStreak();
+        let hunger = 15; // Base: pet feels fed seeing you work
+        let happiness = 10; // Base: pet is happy you're here
+        // Streak bonus - consistent coding means better care
+        if (streak >= 7) {
+            hunger += 5;
+            happiness += 5;
+        }
+        else if (streak >= 3) {
+            hunger += 2;
+            happiness += 2;
+        }
+        return { hunger, happiness };
+    }
+    /**
+     * Update Git streak based on commit dates
+     */
+    updateGitStreak(commits) {
+        if (!this.data.lastGitDate) {
+            // First commit - start streak
+            const oldestCommit = commits[0];
+            this.data.lastGitDate = this.formatDate(oldestCommit.date);
+            this.data.gitStreak = 1;
+            return;
+        }
+        const lastDate = new Date(this.data.lastGitDate);
+        const oldestCommit = commits[0];
+        const commitDate = new Date(this.formatDate(oldestCommit.date));
+        // Calculate day difference
+        const dayDiff = Math.round((commitDate.getTime() - lastDate.getTime()) / (1000 * 60 * 60 * 24));
+        if (dayDiff === 0) {
+            // Same day - streak continues, don't increment
+            return;
+        }
+        else if (dayDiff === 1) {
+            // Next day - increment streak
+            this.data.gitStreak = (this.data.gitStreak || 0) + 1;
+        }
+        else {
+            // Streak broken - start new streak
+            this.data.gitStreak = 1;
+        }
+        this.data.lastGitDate = this.formatDate(oldestCommit.date);
+    }
+    /**
+     * Calculate streak bonus coins
+     */
+    calculateStreakBonus() {
+        const streak = this.getGitStreak();
+        if (streak >= 30) {
+            return 50; // Major milestone bonus
+        }
+        else if (streak >= 7) {
+            return 10; // Week streak bonus
+        }
+        else if (streak > 1) {
+            return streak; // 1 coin per streak day
+        }
+        return 0;
+    }
+    /**
+     * Format date as YYYY-MM-DD
+     */
+    formatDate(date) {
+        const d = new Date(date);
+        return d.toISOString().split('T')[0];
+    }
+    // ===== AUTO-CARE METHODS =====
+    /**
+     * Get auto-care suggestions based on pet state
+     */
+    getSuggestions() {
+        const autoCare = (0, auto_care_1.createAutoCare)();
+        return autoCare.getSuggestions(this);
+    }
+    /**
+     * Apply stat change directly (for Git commit bonuses, etc.)
+     * This bypasses the normal action flow for internal stat adjustments
+     */
+    applyStatDirectly(stat, value) {
+        this.data.stats[stat] = (0, stats_1.clampStat)(this.data.stats[stat] + value);
+        this.updateMood();
+        this.save();
+    }
+    // ===== PRIVATE METHODS =====
+    performAction(changes, xpGained, actionName) {
+        const oldLevel = this.data.level;
+        this.applyStatChanges(changes);
+        this.addExperience(xpGained);
+        this.updateMood();
+        this.updateInteraction();
+        this.save();
+        const newLevel = this.data.level;
+        const levelUp = newLevel > oldLevel;
+        let message = `${this.data.name} enjoyed being ${actionName}!`;
+        if (levelUp) {
+            message = `Level up! ${this.data.name} is now level ${newLevel}! 🎉`;
+        }
+        return {
+            success: true,
+            message,
+            statChanges: changes,
+            xpGained,
+            levelUp,
+            newLevel,
+        };
+    }
+    applyStatChanges(changes) {
+        for (const change of changes) {
+            const currentValue = this.data.stats[change.stat];
+            this.data.stats[change.stat] = (0, stats_1.clampStat)(currentValue + change.delta);
+        }
+    }
+    addExperience(amount) {
+        this.data.experience += amount;
+        // Check for level up
+        const newLevel = level_system_1.LevelSystem.calculateNewLevel(this.data.level, this.data.experience);
+        if (newLevel > this.data.level) {
+            this.data.level = newLevel;
+            // Bonus stats on level up
+            this.data.stats = {
+                hunger: (0, stats_1.clampStat)(this.data.stats.hunger + 5),
+                happiness: (0, stats_1.clampStat)(this.data.stats.happiness + 5),
+                health: (0, stats_1.clampStat)(this.data.stats.health + 5),
+                cleanliness: (0, stats_1.clampStat)(this.data.stats.cleanliness + 5),
+                energy: (0, stats_1.clampStat)(this.data.stats.energy + 5),
+            };
+            // Award coins on level up
+            const levelUpBonus = shop_1.Shop.getCoinReward(shop_1.CoinReason.LEVEL_UP);
+            this.earnCoins(levelUpBonus, shop_1.CoinReason.LEVEL_UP);
+        }
+    }
+    calculateMood() {
+        if (this.data.isSleeping) {
+            return species_1.MoodState.SLEEPY;
+        }
+        const { stats } = this.data;
+        if (stats.health < 30)
+            return species_1.MoodState.SICK;
+        if (stats.energy < 20)
+            return species_1.MoodState.SLEEPY;
+        if (stats.hunger < 20)
+            return species_1.MoodState.ANGRY;
+        const avgStat = (stats.happiness + stats.hunger + stats.cleanliness) / 3;
+        if (avgStat >= 80 && stats.energy > 60)
+            return species_1.MoodState.EXCITED;
+        if (avgStat >= 60)
+            return species_1.MoodState.HAPPY;
+        if (avgStat >= 40)
+            return species_1.MoodState.SAD;
+        return species_1.MoodState.ANGRY;
+    }
+    updateMood() {
+        this.data.mood = this.calculateMood();
+    }
+    updateInteraction() {
+        this.data.lastInteraction = new Date().toISOString();
+        this.data.totalInteractions++;
+    }
+}
+exports.Pet = Pet;
+//# sourceMappingURL=pet.js.map