idlerpg.sh 0.1.0

package/dist/core/IdleGameManager.js

@@ -0,0 +1,688 @@
+/**
+ * IdleGameManager - Orchestrates the IdleRPG game flow
+ *
+ * Manages the game state machine:
+ * - Town phase: Player is in town, can select facilities/dungeons
+ * - Travel phase: Moving between locations
+ * - Dungeon phase: Auto-exploration via DungeonRunner
+ * - Return phase: Returning to town after dungeon
+ *
+ * Supports both legacy single-player and new team system:
+ * - Legacy: Uses Player directly with DungeonRunner
+ * - Team: Uses Team and Actors with TeamDungeonRunner
+ */
+
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="327a0b71-de3f-5f09-80ce-527e701e88ac")}catch(e){}}();
+import { createDungeonRunner } from './DungeonRunner.js';
+import { createTeamDungeonRunner } from './TeamDungeonRunner.js';
+import { getContinentManager } from '../map/ContinentManager.js';
+import { generateDungeon } from '../map/DungeonGenerator.js';
+import { DEFAULT_STRATEGY } from '../strategy/defaultStrategy.js';
+import { VERDANTIA } from '../data/continents/verdantia.js';
+import { playerToActor } from './Actor.js';
+import { createTeamWithActor, getActiveMembers } from './Team.js';
+import { getTeamLeaderAsPlayer } from './StateAdapter.js';
+// ============================================================================
+// IdleGameManager
+// ============================================================================
+export class IdleGameManager {
+    state = null;
+    callbacks = {};
+    continentManager;
+    tickInterval = null;
+    travelStartTime = 0;
+    constructor() {
+        this.continentManager = getContinentManager();
+        // Load the starting continent
+        this.continentManager.loadContinent(VERDANTIA);
+    }
+    /**
+     * Initialize game with player (legacy single-player mode)
+     */
+    initialize(player) {
+        const startTown = this.continentManager.getTown('willowbrook');
+        if (!startTown) {
+            throw new Error('Starting town not found');
+        }
+        this.state = {
+            phase: 'in_town',
+            player,
+            currentTown: startTown,
+            currentDungeon: null,
+            dungeonRunner: null,
+            strategy: DEFAULT_STRATEGY,
+            travelProgress: 0,
+            travelDuration: 0,
+            eventLog: [],
+            statistics: {
+                dungeonsCleared: 0,
+                dungeonsAttempted: 0,
+                enemiesKilled: 0,
+                goldEarned: 0,
+                deathCount: 0,
+                totalPlayTime: 0,
+            },
+            isTeamMode: false,
+        };
+        this.startTick();
+        this.log(`Welcome to ${startTown.name}!`);
+    }
+    /**
+     * Initialize game with team (new team mode)
+     */
+    initializeWithTeam(team, actors) {
+        const startTown = this.continentManager.getTown('willowbrook');
+        if (!startTown) {
+            throw new Error('Starting town not found');
+        }
+        // Get team leader as the "player" for legacy compatibility
+        const leader = getTeamLeaderAsPlayer(team, actors);
+        if (!leader) {
+            throw new Error('Team has no leader');
+        }
+        this.state = {
+            phase: 'in_town',
+            player: leader,
+            currentTown: startTown,
+            currentDungeon: null,
+            dungeonRunner: null,
+            strategy: team.strategy,
+            travelProgress: 0,
+            travelDuration: 0,
+            eventLog: [],
+            statistics: {
+                dungeonsCleared: 0,
+                dungeonsAttempted: 0,
+                enemiesKilled: 0,
+                goldEarned: 0,
+                deathCount: 0,
+                totalPlayTime: 0,
+            },
+            // Team system fields
+            team,
+            actors,
+            teamDungeonRunner: null,
+            isTeamMode: true,
+        };
+        this.startTick();
+        this.log(`Team ${team.name} arrives at ${startTown.name}!`);
+    }
+    /**
+     * Convert current single-player game to team mode
+     * Useful for migration during gameplay
+     */
+    convertToTeamMode() {
+        if (!this.state || this.state.isTeamMode)
+            return;
+        // Convert player to actor
+        const actor = playerToActor(this.state.player);
+        // Create team with the actor
+        const team = createTeamWithActor(actor, `${actor.name}'s Team`);
+        // Store actors
+        const actors = { [actor.id]: actor };
+        // Update state
+        this.state.team = team;
+        this.state.actors = actors;
+        this.state.isTeamMode = true;
+        this.log('Converted to team mode');
+    }
+    /**
+     * Set callbacks
+     */
+    setCallbacks(callbacks) {
+        this.callbacks = { ...this.callbacks, ...callbacks };
+    }
+    /**
+     * Start game tick
+     */
+    startTick() {
+        if (this.tickInterval)
+            return;
+        this.tickInterval = setInterval(() => {
+            this.tick();
+        }, 1000);
+    }
+    /**
+     * Stop game tick
+     */
+    stopTick() {
+        if (this.tickInterval) {
+            clearInterval(this.tickInterval);
+            this.tickInterval = null;
+        }
+    }
+    /**
+     * Main game tick
+     */
+    tick() {
+        if (!this.state)
+            return;
+        this.state.statistics.totalPlayTime++;
+        switch (this.state.phase) {
+            case 'traveling_to_dungeon':
+            case 'returning_to_town':
+                this.processTravelTick();
+                break;
+            case 'resting':
+                this.processRestTick();
+                break;
+        }
+    }
+    /**
+     * Process travel tick
+     */
+    processTravelTick() {
+        if (!this.state)
+            return;
+        const elapsed = (Date.now() - this.travelStartTime) / 1000;
+        this.state.travelProgress = Math.min(elapsed / this.state.travelDuration, 1);
+        this.callbacks.onTravelProgress?.(this.state.travelProgress, this.state.travelDuration);
+        if (this.state.travelProgress >= 1) {
+            if (this.state.phase === 'traveling_to_dungeon') {
+                this.enterDungeon();
+            }
+            else if (this.state.phase === 'returning_to_town') {
+                this.arriveAtTown();
+            }
+        }
+    }
+    /**
+     * Process rest tick
+     */
+    processRestTick() {
+        if (!this.state)
+            return;
+        // Heal 10% per second
+        const healRate = this.state.player.stats.maxHp * 0.1;
+        this.state.player.stats.hp = Math.min(this.state.player.stats.maxHp, this.state.player.stats.hp + healRate);
+        const manaRate = this.state.player.stats.maxMp * 0.1;
+        this.state.player.stats.mp = Math.min(this.state.player.stats.maxMp, this.state.player.stats.mp + manaRate);
+        this.callbacks.onPlayerUpdate?.(this.state.player);
+        // Check if fully healed
+        if (this.state.player.stats.hp >= this.state.player.stats.maxHp &&
+            this.state.player.stats.mp >= this.state.player.stats.maxMp) {
+            this.state.phase = 'in_town';
+            this.log('You are fully rested!');
+            this.callbacks.onPhaseChange?.(this.state.phase, this.state);
+        }
+    }
+    // ============================================================================
+    // Town Actions
+    // ============================================================================
+    /**
+     * Select a dungeon to enter
+     */
+    selectDungeon(dungeonId) {
+        if (!this.state || this.state.phase !== 'in_town')
+            return false;
+        const dungeonTemplate = this.continentManager.getDungeon(dungeonId);
+        if (!dungeonTemplate) {
+            this.log('Dungeon not found!');
+            return false;
+        }
+        // Convert template to generator config and generate dungeon
+        const config = this.createDungeonConfig(dungeonTemplate);
+        const dungeon = generateDungeon(config);
+        this.state.currentDungeon = dungeon;
+        this.state.statistics.dungeonsAttempted++;
+        // Start travel to dungeon
+        this.state.phase = 'traveling_to_dungeon';
+        this.state.travelDuration = dungeon.travelTimeFromTown;
+        this.state.travelProgress = 0;
+        this.travelStartTime = Date.now();
+        this.log(`Traveling to ${dungeon.name}... (${Math.floor(this.state.travelDuration / 60)} min)`);
+        this.callbacks.onPhaseChange?.(this.state.phase, this.state);
+        return true;
+    }
+    /**
+     * Use a facility
+     */
+    useFacility(facility) {
+        if (!this.state || this.state.phase !== 'in_town')
+            return false;
+        switch (facility.type) {
+            case 'inn':
+                this.state.phase = 'resting';
+                this.log('Resting at the inn...');
+                this.callbacks.onPhaseChange?.(this.state.phase, this.state);
+                return true;
+            case 'shop':
+                this.log('Shop system not yet implemented');
+                return false;
+            case 'blacksmith':
+                this.log('Blacksmith system not yet implemented');
+                return false;
+            default:
+                this.log(`${facility.name} is not available yet`);
+                return false;
+        }
+    }
+    /**
+     * Update strategy
+     */
+    setStrategy(strategy) {
+        if (!this.state)
+            return;
+        this.state.strategy = strategy;
+        this.log('Strategy updated!');
+    }
+    // ============================================================================
+    // Dungeon Phase
+    // ============================================================================
+    /**
+     * Enter dungeon after travel
+     */
+    enterDungeon() {
+        if (!this.state || !this.state.currentDungeon)
+            return;
+        this.state.phase = 'in_dungeon';
+        this.log(`Entered ${this.state.currentDungeon.name}`);
+        // Use team dungeon runner if in team mode
+        if (this.state.isTeamMode && this.state.team && this.state.actors) {
+            this.enterDungeonWithTeam();
+        }
+        else {
+            this.enterDungeonLegacy();
+        }
+        this.callbacks.onPhaseChange?.(this.state.phase, this.state);
+    }
+    /**
+     * Enter dungeon with team (new team mode)
+     */
+    enterDungeonWithTeam() {
+        if (!this.state || !this.state.currentDungeon || !this.state.team || !this.state.actors)
+            return;
+        // Create team dungeon runner
+        const runner = createTeamDungeonRunner(this.state.team, this.state.actors);
+        this.state.teamDungeonRunner = runner;
+        // Set up callbacks
+        runner.setCallbacks({
+            onPhaseChange: (phase, runnerState) => {
+                // Convert TeamDungeonState to DungeonRunnerState for compatibility
+                const compatState = this.convertTeamStateToLegacy(runnerState);
+                this.callbacks.onDungeonProgress?.(compatState, runnerState.activeCombat);
+            },
+            onRoomEnter: (room, runnerState) => {
+                this.log(`Team entered: ${room.name}`);
+                const compatState = this.convertTeamStateToLegacy(runnerState);
+                this.callbacks.onDungeonProgress?.(compatState, null);
+            },
+            onCombatStart: (enemies, runnerState) => {
+                const activeCount = getActiveMembers(this.state.team, this.state.actors).length;
+                this.log(`Combat started! ${activeCount} fighters vs ${enemies.length} enemies`);
+            },
+            onCombatTurn: (runnerState) => {
+                const compatState = this.convertTeamStateToLegacy(runnerState);
+                this.callbacks.onDungeonProgress?.(compatState, runnerState.activeCombat);
+            },
+            onCombatEnd: (result, runnerState) => {
+                if (result.victory) {
+                    this.log(`Victory! Team gained +${result.rewards.exp} EXP, +${result.rewards.gold} Gold`);
+                    this.state.statistics.enemiesKilled += runnerState.enemiesKilled;
+                }
+                const compatState = this.convertTeamStateToLegacy(runnerState);
+                this.callbacks.onDungeonProgress?.(compatState, null);
+            },
+            onActorDefeated: (actorId, actorName, runnerState) => {
+                this.log(`${actorName} was knocked out!`);
+            },
+            onActorLevelUp: (actorId, actorName, newLevel, runnerState) => {
+                this.log(`${actorName} leveled up to Lv${newLevel}!`);
+            },
+            onLevelComplete: (level, runnerState) => {
+                this.log(`Level ${level + 1} cleared!`);
+            },
+            onDungeonComplete: (runnerState) => {
+                this.handleTeamDungeonComplete(true, runnerState);
+            },
+            onDungeonFailed: (reason, runnerState) => {
+                this.log(`Dungeon failed: ${reason}`);
+                this.handleTeamDungeonComplete(false, runnerState);
+            },
+            onEventLog: (message) => {
+                this.log(message);
+            },
+        });
+        // Start the dungeon
+        runner.startDungeon(this.state.currentDungeon, this.state.team.strategy);
+    }
+    /**
+     * Enter dungeon with legacy single player
+     */
+    enterDungeonLegacy() {
+        if (!this.state || !this.state.currentDungeon)
+            return;
+        // Create dungeon runner
+        const runner = createDungeonRunner(this.state.player);
+        this.state.dungeonRunner = runner;
+        // Set up callbacks
+        runner.setCallbacks({
+            onPhaseChange: (phase, runnerState) => {
+                this.callbacks.onDungeonProgress?.(runnerState, runnerState.activeCombat);
+            },
+            onRoomEnter: (room, runnerState) => {
+                this.log(`Entered: ${room.name}`);
+                this.callbacks.onDungeonProgress?.(runnerState, null);
+            },
+            onCombatStart: (enemies, runnerState) => {
+                this.log(`Combat started! ${enemies.length} enemies`);
+            },
+            onCombatTurn: (result, runnerState) => {
+                this.callbacks.onDungeonProgress?.(runnerState, runnerState.activeCombat);
+            },
+            onCombatEnd: (victory, rewards, runnerState) => {
+                if (victory) {
+                    this.log(`Victory! +${rewards.exp} EXP, +${rewards.gold} Gold`);
+                    this.state.statistics.enemiesKilled += runnerState.enemiesKilled;
+                }
+                this.callbacks.onDungeonProgress?.(runnerState, null);
+            },
+            onLevelComplete: (level, runnerState) => {
+                this.log(`Level ${level + 1} cleared!`);
+            },
+            onDungeonComplete: (runnerState) => {
+                this.handleDungeonComplete(true, runnerState);
+            },
+            onDungeonFailed: (reason, runnerState) => {
+                this.log(`Dungeon failed: ${reason}`);
+                this.handleDungeonComplete(false, runnerState);
+            },
+            onEventLog: (message) => {
+                this.log(message);
+            },
+        });
+        // Start the dungeon
+        runner.startDungeon(this.state.currentDungeon, this.state.strategy);
+    }
+    /**
+     * Convert TeamDungeonState to DungeonRunnerState for UI compatibility
+     */
+    convertTeamStateToLegacy(teamState) {
+        return {
+            phase: teamState.phase,
+            dungeon: teamState.dungeon,
+            currentLevel: teamState.currentLevel,
+            currentRoomId: teamState.currentRoomId,
+            exploredRooms: teamState.exploredRooms,
+            clearedRooms: teamState.clearedRooms,
+            strategy: teamState.strategy,
+            strategyExecutor: teamState.strategyExecutor,
+            activeCombat: teamState.activeCombat,
+            lootCollected: teamState.lootCollected,
+            goldCollected: teamState.goldCollected,
+            expGained: teamState.expGained,
+            enemiesKilled: teamState.enemiesKilled,
+            startTime: teamState.startTime,
+            eventLog: teamState.eventLog,
+        };
+    }
+    /**
+     * Handle team dungeon completion
+     */
+    handleTeamDungeonComplete(success, runnerState) {
+        if (!this.state || !this.state.team)
+            return;
+        // Gold is already added to team in TeamDungeonRunner
+        // Update player for UI compatibility
+        this.state.player.stats.gold = this.state.team.sharedGold;
+        const rewards = {
+            gold: runnerState.goldCollected,
+            exp: runnerState.expGained,
+            items: runnerState.lootCollected.map(i => i.name),
+        };
+        if (success) {
+            this.state.statistics.dungeonsCleared++;
+            this.state.statistics.goldEarned += runnerState.goldCollected;
+            this.log(`Dungeon cleared! Rewards: ${rewards.gold} gold, ${rewards.exp} exp`);
+        }
+        // Check for team wipe
+        const aliveActors = this.state.team.activeMembers.filter(id => {
+            const actor = this.state.actors[id];
+            return actor && actor.stats.hp > 0;
+        });
+        if (aliveActors.length === 0) {
+            this.handleTeamDeath();
+            return;
+        }
+        // Convert to legacy DungeonRunnerState for callback
+        const compatState = this.convertTeamStateToLegacy(runnerState);
+        this.callbacks.onDungeonComplete?.(success, rewards);
+        // Start returning to town
+        this.startReturnToTown();
+    }
+    /**
+     * Handle team death (all members knocked out)
+     */
+    handleTeamDeath() {
+        if (!this.state)
+            return;
+        this.state.phase = 'dead';
+        this.state.statistics.deathCount++;
+        this.state.teamDungeonRunner = null;
+        this.state.dungeonRunner = null;
+        this.log('The entire team has been defeated...');
+        this.callbacks.onPlayerDeath?.();
+        this.callbacks.onPhaseChange?.(this.state.phase, this.state);
+    }
+    /**
+     * Handle dungeon completion
+     */
+    handleDungeonComplete(success, runnerState) {
+        if (!this.state)
+            return;
+        // Update player with dungeon results (HP is updated via combat callbacks)
+        this.state.player.stats.gold += runnerState.goldCollected;
+        const rewards = {
+            gold: runnerState.goldCollected,
+            exp: runnerState.expGained,
+            items: runnerState.lootCollected.map(i => i.name),
+        };
+        if (success) {
+            this.state.statistics.dungeonsCleared++;
+            this.state.statistics.goldEarned += runnerState.goldCollected;
+            this.log(`Dungeon cleared! Rewards: ${rewards.gold} gold, ${rewards.exp} exp`);
+        }
+        // Check for death
+        if (this.state.player.stats.hp <= 0) {
+            this.handlePlayerDeath();
+            return;
+        }
+        this.callbacks.onDungeonComplete?.(success, rewards);
+        // Start returning to town
+        this.startReturnToTown();
+    }
+    /**
+     * Abort current dungeon run
+     */
+    abortDungeon() {
+        if (!this.state || this.state.phase !== 'in_dungeon')
+            return;
+        this.state.dungeonRunner?.abort();
+        this.log('Retreating from dungeon...');
+        this.startReturnToTown();
+    }
+    /**
+     * Cancel current travel and return to town immediately
+     */
+    cancelTravel() {
+        if (!this.state)
+            return false;
+        if (this.state.phase !== 'traveling_to_dungeon' && this.state.phase !== 'returning_to_town') {
+            return false;
+        }
+        // Reset to town state
+        this.state.phase = 'in_town';
+        this.state.travelProgress = 0;
+        this.state.travelDuration = 0;
+        this.state.currentDungeon = null;
+        this.travelStartTime = 0;
+        this.log('Travel cancelled. Returned to town.');
+        this.callbacks.onPhaseChange?.(this.state.phase, this.state);
+        return true;
+    }
+    /**
+     * Pause dungeon exploration
+     */
+    pauseDungeon() {
+        this.state?.dungeonRunner?.pause();
+    }
+    /**
+     * Resume dungeon exploration
+     */
+    resumeDungeon() {
+        this.state?.dungeonRunner?.resume();
+    }
+    // ============================================================================
+    // Return Phase
+    // ============================================================================
+    /**
+     * Start returning to town
+     */
+    startReturnToTown() {
+        if (!this.state)
+            return;
+        this.state.phase = 'returning_to_town';
+        this.state.dungeonRunner = null;
+        this.state.travelDuration = 120; // 2 minutes base return time
+        this.state.travelProgress = 0;
+        this.travelStartTime = Date.now();
+        this.log('Returning to town...');
+        this.callbacks.onPhaseChange?.(this.state.phase, this.state);
+    }
+    /**
+     * Arrive at town
+     */
+    arriveAtTown() {
+        if (!this.state)
+            return;
+        this.state.phase = 'in_town';
+        this.state.currentDungeon = null;
+        this.log(`Arrived at ${this.state.currentTown.name}`);
+        this.callbacks.onPhaseChange?.(this.state.phase, this.state);
+        this.callbacks.onPlayerUpdate?.(this.state.player);
+    }
+    // ============================================================================
+    // Death Handling
+    // ============================================================================
+    /**
+     * Handle player death
+     */
+    handlePlayerDeath() {
+        if (!this.state)
+            return;
+        this.state.phase = 'dead';
+        this.state.statistics.deathCount++;
+        this.state.dungeonRunner = null;
+        this.log('You have been defeated...');
+        this.callbacks.onPlayerDeath?.();
+        this.callbacks.onPhaseChange?.(this.state.phase, this.state);
+    }
+    /**
+     * Respawn player
+     */
+    respawn() {
+        if (!this.state || this.state.phase !== 'dead')
+            return;
+        // Restore HP to 50%, lose 10% gold
+        this.state.player.stats.hp = Math.floor(this.state.player.stats.maxHp * 0.5);
+        this.state.player.stats.mp = this.state.player.stats.maxMp;
+        const goldLost = Math.floor(this.state.player.stats.gold * 0.1);
+        this.state.player.stats.gold -= goldLost;
+        this.state.phase = 'in_town';
+        this.state.currentDungeon = null;
+        this.log(`Respawned at ${this.state.currentTown.name}. Lost ${goldLost} gold.`);
+        this.callbacks.onPhaseChange?.(this.state.phase, this.state);
+        this.callbacks.onPlayerUpdate?.(this.state.player);
+    }
+    // ============================================================================
+    // Utilities
+    // ============================================================================
+    /**
+     * Create dungeon generator config from template
+     */
+    createDungeonConfig(template) {
+        // Determine number of levels based on difficulty
+        const levelsByDifficulty = {
+            easy: 3,
+            normal: 5,
+            hard: 7,
+            nightmare: 10,
+            legendary: 15,
+        };
+        const roomsByDifficulty = {
+            easy: { min: 4, max: 6 },
+            normal: { min: 5, max: 8 },
+            hard: { min: 6, max: 10 },
+            nightmare: { min: 8, max: 12 },
+            legendary: { min: 10, max: 15 },
+        };
+        return {
+            dungeonId: template.id,
+            name: template.name,
+            description: template.description,
+            continentId: template.continentId,
+            nearestTownId: template.nearestTownId,
+            difficulty: template.difficulty,
+            recommendedLevel: template.recommendedLevel,
+            numberOfLevels: levelsByDifficulty[template.difficulty] || 5,
+            roomsPerLevel: roomsByDifficulty[template.difficulty] || { min: 5, max: 8 },
+            hasBoss: template.hasBoss,
+            bossName: template.bossName,
+            seed: Date.now(),
+        };
+    }
+    /**
+     * Log an event
+     */
+    log(message) {
+        if (!this.state)
+            return;
+        const timestamp = new Date().toLocaleTimeString('en-US', { hour12: false });
+        const logMessage = `[${timestamp}] ${message}`;
+        this.state.eventLog.push(logMessage);
+        if (this.state.eventLog.length > 100) {
+            this.state.eventLog.shift();
+        }
+        this.callbacks.onEventLog?.(logMessage);
+    }
+    /**
+     * Get current state
+     */
+    getState() {
+        return this.state;
+    }
+    /**
+     * Get available dungeons from current town
+     */
+    getAvailableDungeons() {
+        if (!this.state)
+            return [];
+        return this.continentManager.getDungeonsFromTown(this.state.currentTown.id);
+    }
+    /**
+     * Get dungeon runner for UI updates
+     */
+    getDungeonRunner() {
+        return this.state?.dungeonRunner ?? null;
+    }
+    /**
+     * Destroy manager
+     */
+    destroy() {
+        this.stopTick();
+        this.state?.dungeonRunner?.abort();
+        this.state = null;
+    }
+}
+// ============================================================================
+// Singleton
+// ============================================================================
+let managerInstance = null;
+export function getIdleGameManager() {
+    if (!managerInstance) {
+        managerInstance = new IdleGameManager();
+    }
+    return managerInstance;
+}
+//# sourceMappingURL=IdleGameManager.js.map
+//# debugId=327a0b71-de3f-5f09-80ce-527e701e88ac