idlerpg.sh 0.1.0

package/dist/core/DungeonRunner.js

@@ -0,0 +1,627 @@
+/**
+ * Dungeon Runner
+ * Main exploration loop for AI-driven dungeon crawling
+ *
+ * Coordinates between:
+ * - TimeManager: Real-time action scheduling
+ * - StrategyExecutor: Decision making
+ * - IdleCombat: Battle processing
+ * - DungeonGenerator: Map data
+ */
+
+!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]="f877e45d-667c-514c-8804-3787c42fc3ea")}catch(e){}}();
+import { getTimeManager, } from './TimeManager.js';
+import { createStrategyExecutor, } from '../strategy/index.js';
+import { initIdleCombat, processIdleCombatTurn, calculateIdleCombatRewards, } from './IdleCombat.js';
+import { ROOM_TIMES, COMBAT_TURN_DURATION } from './timeConstants.js';
+// ============================================================================
+// Dungeon Runner Class
+// ============================================================================
+export class DungeonRunner {
+    state = null;
+    player;
+    timeManager;
+    callbacks = {};
+    isPaused = false;
+    constructor(player) {
+        this.player = player;
+        this.timeManager = getTimeManager();
+    }
+    // ============================================================================
+    // Public API
+    // ============================================================================
+    /**
+     * Set callbacks for dungeon events
+     */
+    setCallbacks(callbacks) {
+        this.callbacks = { ...this.callbacks, ...callbacks };
+    }
+    /**
+     * Start a dungeon run
+     */
+    startDungeon(dungeon, strategy) {
+        const firstLevel = dungeon.levels[0];
+        if (!firstLevel) {
+            throw new Error('Dungeon has no levels');
+        }
+        this.state = {
+            phase: 'entering',
+            dungeon,
+            currentLevel: 0,
+            currentRoomId: firstLevel.entranceRoomId,
+            exploredRooms: new Set(),
+            clearedRooms: new Set(),
+            strategy,
+            strategyExecutor: createStrategyExecutor(strategy),
+            activeCombat: null,
+            lootCollected: [],
+            goldCollected: 0,
+            expGained: 0,
+            enemiesKilled: 0,
+            startTime: Date.now(),
+            eventLog: [],
+        };
+        this.log(`Entering ${dungeon.name}...`);
+        this.setPhase('entering');
+        // Start enter dungeon action
+        this.timeManager.startAction('travel', `Entering ${dungeon.name}`, ROOM_TIMES.entrance, {
+            onComplete: 'dungeon_entered',
+            data: { dungeonId: dungeon.id },
+        });
+        // Set up time manager callbacks
+        this.timeManager.setCallbacks({
+            onComplete: (action) => this.handleActionComplete(action),
+        });
+    }
+    /**
+     * Get current state
+     */
+    getState() {
+        return this.state;
+    }
+    /**
+     * Get current room
+     */
+    getCurrentRoom() {
+        if (!this.state)
+            return null;
+        const level = this.state.dungeon.levels[this.state.currentLevel];
+        return level?.rooms.find(r => r.id === this.state.currentRoomId) || null;
+    }
+    /**
+     * Pause dungeon exploration
+     */
+    pause() {
+        this.isPaused = true;
+        this.timeManager.pause();
+    }
+    /**
+     * Resume dungeon exploration
+     */
+    resume() {
+        this.isPaused = false;
+        this.timeManager.resume();
+    }
+    /**
+     * Abort dungeon run
+     */
+    abort() {
+        if (!this.state)
+            return;
+        this.log('Abandoning dungeon...');
+        this.setPhase('returning');
+        this.finishDungeon(false, 'Abandoned');
+    }
+    /**
+     * Get active dungeon state for saving
+     */
+    getActiveDungeonState() {
+        if (!this.state)
+            return null;
+        return {
+            dungeonId: this.state.dungeon.id,
+            currentLevel: this.state.currentLevel,
+            currentRoomId: this.state.currentRoomId,
+            strategy: this.state.strategy,
+            exploredRooms: Array.from(this.state.exploredRooms),
+            clearedRooms: Array.from(this.state.clearedRooms),
+            startTime: this.state.startTime,
+            elapsedTime: (Date.now() - this.state.startTime) / 1000,
+            lootCollected: this.state.lootCollected,
+            goldCollected: this.state.goldCollected,
+            expGained: this.state.expGained,
+            enemiesKilled: this.state.enemiesKilled,
+            floorsCleared: this.state.currentLevel,
+        };
+    }
+    // ============================================================================
+    // Internal Logic
+    // ============================================================================
+    /**
+     * Handle time action completion
+     */
+    handleActionComplete(action) {
+        if (!this.state || this.isPaused)
+            return;
+        switch (action.onComplete) {
+            case 'dungeon_entered':
+                this.enterRoom(this.state.currentRoomId);
+                break;
+            case 'room_processed':
+                this.afterRoomProcessed();
+                break;
+            case 'combat_turn':
+                this.processCombatTurn();
+                break;
+            case 'room_moved':
+                const targetRoomId = action.data?.targetRoomId;
+                if (targetRoomId) {
+                    this.enterRoom(targetRoomId);
+                }
+                break;
+            case 'level_descended':
+                this.descendToNextLevel();
+                break;
+        }
+    }
+    /**
+     * Enter a room
+     */
+    enterRoom(roomId) {
+        if (!this.state)
+            return;
+        const level = this.state.dungeon.levels[this.state.currentLevel];
+        const room = level?.rooms.find(r => r.id === roomId);
+        if (!room) {
+            this.log(`Error: Room ${roomId} not found`);
+            return;
+        }
+        this.state.currentRoomId = roomId;
+        this.state.exploredRooms.add(roomId);
+        room.isExplored = true;
+        this.log(`Entered ${room.name} (${room.type})`);
+        this.callbacks.onRoomEnter?.(room, this.state);
+        this.setPhase('processing_room');
+        this.processRoom(room);
+    }
+    /**
+     * Process current room based on type
+     */
+    processRoom(room) {
+        if (!this.state)
+            return;
+        const roomTime = ROOM_TIMES[room.type] || ROOM_TIMES.empty;
+        switch (room.type) {
+            case 'combat':
+            case 'elite':
+            case 'boss':
+            case 'ambush':
+                this.startCombat(room);
+                break;
+            case 'treasure':
+                this.processTreasureRoom(room);
+                break;
+            case 'fountain':
+                this.processFountainRoom(room);
+                break;
+            case 'altar':
+                this.processAltarRoom(room);
+                break;
+            case 'shop':
+                this.processShopRoom(room);
+                break;
+            case 'trap':
+                this.processTrapRoom(room);
+                break;
+            case 'event':
+            case 'encounter':
+                this.processEventRoom(room);
+                break;
+            case 'exit':
+                this.processExitRoom(room);
+                return; // Don't queue next action
+            case 'entrance':
+            case 'rest':
+            case 'safe_room':
+            case 'dead_end':
+            case 'empty':
+            default:
+                // Just traverse
+                this.timeManager.startAction('explore_room', `Traversing ${room.name}`, roomTime, { onComplete: 'room_processed' });
+                break;
+        }
+    }
+    /**
+     * Start combat in room
+     */
+    startCombat(room) {
+        if (!this.state)
+            return;
+        const enemies = room.content.enemies || [];
+        if (enemies.length === 0) {
+            this.log('No enemies found');
+            this.afterRoomProcessed();
+            return;
+        }
+        this.setPhase('in_combat');
+        this.log(`Combat started! ${enemies.length} enemies`);
+        const isAmbush = room.type === 'ambush';
+        const combatType = room.type === 'boss' ? 'boss' :
+            room.type === 'elite' ? 'elite' :
+                room.type === 'ambush' ? 'ambush' : 'mob';
+        this.state.activeCombat = initIdleCombat(this.player, enemies, {
+            strategy: this.state.strategy,
+            combatType,
+            isAmbush,
+        });
+        this.callbacks.onCombatStart?.(enemies, this.state);
+        // Start first combat turn
+        this.queueCombatTurn();
+    }
+    /**
+     * Queue next combat turn
+     */
+    queueCombatTurn() {
+        this.timeManager.startAction('combat_turn', 'Combat turn', COMBAT_TURN_DURATION, { onComplete: 'combat_turn' });
+    }
+    /**
+     * Process combat turn
+     */
+    processCombatTurn() {
+        if (!this.state || !this.state.activeCombat)
+            return;
+        const result = processIdleCombatTurn(this.state.activeCombat, this.player);
+        this.state.activeCombat = result.combat;
+        this.callbacks.onCombatTurn?.(result, this.state);
+        if (result.finished) {
+            this.endCombat(result);
+        }
+        else {
+            this.queueCombatTurn();
+        }
+    }
+    /**
+     * End combat
+     */
+    endCombat(result) {
+        if (!this.state)
+            return;
+        const rewards = calculateIdleCombatRewards(result.combat.enemies, result.retreated);
+        this.state.goldCollected += rewards.gold;
+        this.state.expGained += rewards.exp;
+        this.state.enemiesKilled += result.combat.enemies.filter(e => e.hp <= 0).length;
+        // Apply rewards to player
+        this.player.stats.gold += rewards.gold;
+        this.player.stats.exp += rewards.exp;
+        if (result.victory) {
+            this.log(`Victory! +${rewards.exp} EXP, +${rewards.gold} Gold`);
+        }
+        else if (result.retreated) {
+            this.log('Retreated from combat');
+        }
+        else {
+            this.log('Defeated...');
+            this.finishDungeon(false, 'Defeated in combat');
+            return;
+        }
+        this.callbacks.onCombatEnd?.(result.victory, rewards, this.state);
+        // Mark room as cleared
+        const room = this.getCurrentRoom();
+        if (room) {
+            this.state.clearedRooms.add(room.id);
+            room.isCleared = true;
+        }
+        this.state.activeCombat = null;
+        this.afterRoomProcessed();
+    }
+    /**
+     * Process treasure room
+     */
+    processTreasureRoom(room) {
+        if (!this.state)
+            return;
+        const chest = room.content.treasureChest;
+        if (chest && !chest.isOpened) {
+            chest.isOpened = true;
+            if (chest.goldAmount > 0) {
+                this.state.goldCollected += chest.goldAmount;
+                this.player.stats.gold += chest.goldAmount;
+                this.log(`Found ${chest.goldAmount} gold!`);
+            }
+            for (const item of chest.contents) {
+                this.state.lootCollected.push(item);
+                this.player.inventory.push(item);
+                this.log(`Found ${item.name}!`);
+            }
+        }
+        this.state.clearedRooms.add(room.id);
+        room.isCleared = true;
+        this.timeManager.startAction('explore_room', 'Looting treasure', ROOM_TIMES.treasure, { onComplete: 'room_processed' });
+    }
+    /**
+     * Process fountain room (heal)
+     */
+    processFountainRoom(room) {
+        if (!this.state)
+            return;
+        const healAmount = Math.floor(this.player.stats.maxHp * 0.5);
+        this.player.stats.hp = Math.min(this.player.stats.maxHp, this.player.stats.hp + healAmount);
+        const manaRestore = Math.floor(this.player.stats.maxMp * 0.3);
+        this.player.stats.mp = Math.min(this.player.stats.maxMp, this.player.stats.mp + manaRestore);
+        this.log(`Restored ${healAmount} HP and ${manaRestore} MP at fountain`);
+        this.state.clearedRooms.add(room.id);
+        room.isCleared = true;
+        this.timeManager.startAction('rest', 'Resting at fountain', ROOM_TIMES.fountain, { onComplete: 'room_processed' });
+    }
+    /**
+     * Process altar room (buff)
+     */
+    processAltarRoom(room) {
+        if (!this.state)
+            return;
+        // Placeholder: altar gives temporary stat boost
+        this.log('Received blessing from altar');
+        this.state.clearedRooms.add(room.id);
+        room.isCleared = true;
+        this.timeManager.startAction('explore_room', 'Receiving blessing', ROOM_TIMES.altar, { onComplete: 'room_processed' });
+    }
+    /**
+     * Process shop room
+     */
+    processShopRoom(room) {
+        if (!this.state)
+            return;
+        const shopDecision = this.state.strategyExecutor.decideEncounterAction({
+            type: 'shop',
+        });
+        this.log(`Shop: ${shopDecision.action} (${shopDecision.reason})`);
+        // Placeholder: shop interaction
+        this.state.clearedRooms.add(room.id);
+        room.isCleared = true;
+        this.timeManager.startAction('explore_room', 'Browsing shop', ROOM_TIMES.shop, { onComplete: 'room_processed' });
+    }
+    /**
+     * Process trap room
+     */
+    processTrapRoom(room) {
+        if (!this.state)
+            return;
+        const trap = room.content.trap;
+        if (trap && !trap.isTriggered && !trap.isDisarmed) {
+            if (this.state.strategy.exploration.avoidTraps) {
+                // Try to disarm
+                const disarmChance = 0.5;
+                if (Math.random() < disarmChance) {
+                    trap.isDisarmed = true;
+                    this.log('Disarmed trap!');
+                }
+                else {
+                    trap.isTriggered = true;
+                    this.player.stats.hp = Math.max(1, this.player.stats.hp - trap.damage);
+                    this.log(`Trap triggered! Took ${trap.damage} damage`);
+                }
+            }
+            else {
+                trap.isTriggered = true;
+                this.player.stats.hp = Math.max(1, this.player.stats.hp - trap.damage);
+                this.log(`Trap triggered! Took ${trap.damage} damage`);
+            }
+        }
+        this.state.clearedRooms.add(room.id);
+        room.isCleared = true;
+        this.timeManager.startAction('explore_room', 'Handling trap', ROOM_TIMES.trap, { onComplete: 'room_processed' });
+    }
+    /**
+     * Process event/encounter room
+     */
+    processEventRoom(room) {
+        if (!this.state)
+            return;
+        const event = room.content.event;
+        if (event && !event.processed) {
+            event.processed = true;
+            const encounterDecision = this.state.strategyExecutor.decideEncounterAction({
+                type: 'event',
+                event,
+                riskLevel: 0.5,
+            });
+            this.log(`Event: ${event.title} - ${encounterDecision.action}`);
+            // Placeholder: random reward
+            if (encounterDecision.action === 'engage' && Math.random() > 0.5) {
+                const bonusGold = Math.floor(Math.random() * 50) + 10;
+                this.state.goldCollected += bonusGold;
+                this.player.stats.gold += bonusGold;
+                this.log(`Event reward: ${bonusGold} gold`);
+            }
+        }
+        this.state.clearedRooms.add(room.id);
+        room.isCleared = true;
+        this.timeManager.startAction('explore_room', 'Processing event', ROOM_TIMES.event, { onComplete: 'room_processed' });
+    }
+    /**
+     * Process exit room
+     */
+    processExitRoom(room) {
+        if (!this.state)
+            return;
+        const level = this.state.dungeon.levels[this.state.currentLevel];
+        // Check if this is final level
+        if (this.state.currentLevel >= this.state.dungeon.levels.length - 1) {
+            // Check if boss was defeated
+            if (level.bossRoomId && !this.state.clearedRooms.has(level.bossRoomId)) {
+                this.log('Must defeat the boss before leaving!');
+                this.afterRoomProcessed();
+                return;
+            }
+            this.log('Dungeon completed!');
+            this.finishDungeon(true);
+        }
+        else {
+            // Descend to next level
+            this.log(`Descending to level ${this.state.currentLevel + 2}...`);
+            this.setPhase('descending');
+            this.callbacks.onLevelComplete?.(this.state.currentLevel + 1, this.state);
+            this.timeManager.startAction('travel', 'Descending stairs', ROOM_TIMES.exit, { onComplete: 'level_descended' });
+        }
+    }
+    /**
+     * Descend to next dungeon level
+     */
+    descendToNextLevel() {
+        if (!this.state)
+            return;
+        this.state.currentLevel++;
+        const nextLevel = this.state.dungeon.levels[this.state.currentLevel];
+        if (!nextLevel) {
+            this.finishDungeon(true);
+            return;
+        }
+        this.enterRoom(nextLevel.entranceRoomId);
+    }
+    /**
+     * After room is processed, decide next action
+     */
+    afterRoomProcessed() {
+        if (!this.state)
+            return;
+        this.setPhase('exploring');
+        const currentRoom = this.getCurrentRoom();
+        if (!currentRoom)
+            return;
+        // Check if should rest/retreat based on resources
+        const resourceCheck = this.state.strategyExecutor.checkResourceAction({
+            hp: this.player.stats.hp,
+            maxHp: this.player.stats.maxHp,
+            mp: this.player.stats.mp,
+            maxMp: this.player.stats.maxMp,
+            gold: this.player.stats.gold,
+        });
+        if (resourceCheck.action === 'retreat_to_town') {
+            this.log(`Retreating: ${resourceCheck.reason}`);
+            this.finishDungeon(false, 'Strategic retreat');
+            return;
+        }
+        // Get available rooms
+        const level = this.state.dungeon.levels[this.state.currentLevel];
+        const availableRooms = [];
+        for (const conn of currentRoom.connections) {
+            if (!conn.isLocked || conn.keyRequired === undefined) {
+                const room = level.rooms.find(r => r.id === conn.targetRoomId);
+                if (room) {
+                    availableRooms.push(room);
+                }
+            }
+        }
+        // Get exploration decision
+        const context = {
+            currentRoom,
+            availableRooms,
+            exploredRooms: Array.from(this.state.exploredRooms),
+            player: {
+                hp: this.player.stats.hp,
+                maxHp: this.player.stats.maxHp,
+                mp: this.player.stats.mp,
+                maxMp: this.player.stats.maxMp,
+            },
+        };
+        const decision = this.state.strategyExecutor.decideExplorationAction(context);
+        this.executeExplorationDecision(decision, currentRoom, availableRooms);
+    }
+    /**
+     * Execute exploration decision
+     */
+    executeExplorationDecision(decision, currentRoom, availableRooms) {
+        if (!this.state)
+            return;
+        switch (decision.action) {
+            case 'move':
+                if (decision.targetRoomId) {
+                    this.setPhase('moving');
+                    this.log(`Moving to ${decision.targetRoomId} (${decision.reason})`);
+                    this.timeManager.startAction('travel', 'Moving to next room', currentRoom.timeToTraverse, {
+                        onComplete: 'room_moved',
+                        data: { targetRoomId: decision.targetRoomId },
+                    });
+                }
+                break;
+            case 'rest':
+                this.log(`Resting (${decision.reason})`);
+                const healAmount = Math.floor(this.player.stats.maxHp * 0.2);
+                this.player.stats.hp = Math.min(this.player.stats.maxHp, this.player.stats.hp + healAmount);
+                this.timeManager.startAction('rest', 'Resting', ROOM_TIMES.rest, { onComplete: 'room_processed' });
+                break;
+            case 'search':
+                this.log(`Searching room (${decision.reason})`);
+                // Placeholder: small chance to find hidden item
+                if (Math.random() < 0.1) {
+                    const bonusGold = 25;
+                    this.state.goldCollected += bonusGold;
+                    this.player.stats.gold += bonusGold;
+                    this.log(`Found hidden ${bonusGold} gold!`);
+                }
+                this.timeManager.startAction('search', 'Searching', 30, { onComplete: 'room_processed' });
+                break;
+            case 'retreat':
+                this.log(`Retreating (${decision.reason})`);
+                this.finishDungeon(false, decision.reason);
+                break;
+        }
+    }
+    // ============================================================================
+    // Utilities
+    // ============================================================================
+    /**
+     * Set phase and notify callback
+     */
+    setPhase(phase) {
+        if (!this.state)
+            return;
+        this.state.phase = phase;
+        this.callbacks.onPhaseChange?.(phase, this.state);
+    }
+    /**
+     * Add to event log
+     */
+    log(message) {
+        if (!this.state)
+            return;
+        const timestamp = new Date().toLocaleTimeString();
+        const logMessage = `[${timestamp}] ${message}`;
+        this.state.eventLog.push(logMessage);
+        this.callbacks.onEventLog?.(logMessage, this.state);
+    }
+    /**
+     * Finish dungeon run
+     */
+    finishDungeon(success, reason) {
+        if (!this.state)
+            return;
+        this.setPhase(success ? 'completed' : 'failed');
+        if (success) {
+            this.log(`Dungeon ${this.state.dungeon.name} completed!`);
+            this.log(`Total: ${this.state.expGained} EXP, ${this.state.goldCollected} Gold, ${this.state.enemiesKilled} kills`);
+            this.callbacks.onDungeonComplete?.(this.state);
+        }
+        else {
+            this.log(`Dungeon run ended: ${reason || 'Unknown'}`);
+            this.callbacks.onDungeonFailed?.(reason || 'Unknown', this.state);
+        }
+        this.timeManager.clearCallbacks();
+        this.state = null;
+    }
+}
+// ============================================================================
+// Factory
+// ============================================================================
+let dungeonRunnerInstance = null;
+export function getDungeonRunner(player) {
+    if (!dungeonRunnerInstance) {
+        dungeonRunnerInstance = new DungeonRunner(player);
+    }
+    return dungeonRunnerInstance;
+}
+export function createDungeonRunner(player) {
+    return new DungeonRunner(player);
+}
+//# sourceMappingURL=DungeonRunner.js.map
+//# debugId=f877e45d-667c-514c-8804-3787c42fc3ea