idlerpg.sh 0.1.0

package/dist/core/TeamDungeonRunner.js

@@ -0,0 +1,758 @@
+/**
+ * Team Dungeon Runner
+ * Extends DungeonRunner for multi-character team exploration
+ *
+ * Key differences from single-player DungeonRunner:
+ * - Tracks HP/MP for each team member individually
+ * - Uses TeamCombat for multi-character battles
+ * - Experience is distributed among all active members
+ * - Dead actors move to reserve, can be revived in safe areas
+ * - Formation affects damage distribution
+ */
+
+!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]="1f164094-7235-514b-baae-ac9221fc9746")}catch(e){}}();
+import { getTimeManager, } from './TimeManager.js';
+import { createStrategyExecutor, } from '../strategy/index.js';
+import { createTeamCombatState, processCombatTurn, isCombatOver, finalizeCombat, } from './TeamCombat.js';
+import { healActor, reviveActor, isActorAlive, } from './Actor.js';
+import { getActiveActorsForCombat, getActiveMembers, addTeamGold, addItemToTeam, moveToReserve, } from './Team.js';
+import { ROOM_TIMES, COMBAT_TURN_DURATION } from './timeConstants.js';
+// ============================================================================
+// Team Dungeon Runner Class
+// ============================================================================
+export class TeamDungeonRunner {
+    state = null;
+    team;
+    actors;
+    timeManager;
+    callbacks = {};
+    isPaused = false;
+    constructor(team, actors) {
+        this.team = team;
+        this.actors = actors;
+        this.timeManager = getTimeManager();
+    }
+    // ============================================================================
+    // Public API
+    // ============================================================================
+    /**
+     * Set callbacks for dungeon events
+     */
+    setCallbacks(callbacks) {
+        this.callbacks = { ...this.callbacks, ...callbacks };
+    }
+    /**
+     * Start a dungeon run with the team
+     */
+    startDungeon(dungeon, strategy) {
+        const firstLevel = dungeon.levels[0];
+        if (!firstLevel) {
+            throw new Error('Dungeon has no levels');
+        }
+        // Initialize HP/MP tracking from current actor values
+        const actorHp = {};
+        const actorMp = {};
+        for (const actorId of this.team.activeMembers) {
+            const actor = this.actors[actorId];
+            if (actor) {
+                actorHp[actorId] = actor.stats.hp;
+                actorMp[actorId] = actor.stats.mp;
+            }
+        }
+        this.state = {
+            phase: 'entering',
+            dungeon,
+            currentLevel: 0,
+            currentRoomId: firstLevel.entranceRoomId,
+            exploredRooms: new Set(),
+            clearedRooms: new Set(),
+            strategy,
+            strategyExecutor: createStrategyExecutor(strategy),
+            activeCombat: null,
+            actorHp,
+            actorMp,
+            lootCollected: [],
+            goldCollected: 0,
+            expGained: 0,
+            enemiesKilled: 0,
+            startTime: Date.now(),
+            eventLog: [],
+        };
+        this.log(`Team 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('Team 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(`Team 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 'safe_room':
+                this.processSafeRoom(room);
+                break;
+            case 'entrance':
+            case 'rest':
+            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 using TeamCombat
+     */
+    startCombat(room) {
+        if (!this.state)
+            return;
+        const enemies = room.content.enemies || [];
+        if (enemies.length === 0) {
+            this.log('No enemies found');
+            this.afterRoomProcessed();
+            return;
+        }
+        // Check if team can fight
+        const activeActors = getActiveActorsForCombat(this.team, this.actors);
+        if (activeActors.length === 0) {
+            this.log('No team members able to fight!');
+            this.finishDungeon(false, 'Team incapacitated');
+            return;
+        }
+        this.setPhase('in_combat');
+        this.log(`Combat started! ${activeActors.length} fighters vs ${enemies.length} enemies`);
+        const combatType = room.type === 'boss' ? 'boss' :
+            room.type === 'elite' ? 'elite' :
+                room.type === 'ambush' ? 'ambush' : 'mob';
+        // Create team combat state
+        this.state.activeCombat = createTeamCombatState(this.team, this.actors, enemies, combatType);
+        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;
+        // Process the turn
+        processCombatTurn(this.state.activeCombat, this.team, this.actors, {
+            onActorDefeated: (actorId) => {
+                const actor = this.actors[actorId];
+                if (actor) {
+                    this.log(`${actor.name} was knocked out!`);
+                    this.callbacks.onActorDefeated?.(actorId, actor.name, this.state);
+                    // Move to reserve
+                    moveToReserve(this.team, actor);
+                }
+            },
+            onEnemyDefeated: (enemyId) => {
+                const enemy = this.state?.activeCombat?.enemies.find(e => e.id === enemyId);
+                if (enemy) {
+                    this.log(`${enemy.name} was defeated!`);
+                }
+            },
+        });
+        // Sync HP from combat state to tracking
+        for (const actorId of this.team.activeMembers) {
+            this.state.actorHp[actorId] = this.state.activeCombat.actorHp[actorId] ?? 0;
+            this.state.actorMp[actorId] = this.state.activeCombat.actorMp[actorId] ?? this.state.actorMp[actorId];
+        }
+        this.callbacks.onCombatTurn?.(this.state);
+        // Check if combat is over
+        if (isCombatOver(this.state.activeCombat, this.team, this.actors)) {
+            this.endCombat();
+        }
+        else {
+            this.queueCombatTurn();
+        }
+    }
+    /**
+     * End combat and process results
+     */
+    endCombat() {
+        if (!this.state || !this.state.activeCombat)
+            return;
+        const result = finalizeCombat(this.state.activeCombat, this.team, this.actors);
+        this.state.goldCollected += result.rewards.gold;
+        this.state.expGained += result.rewards.exp;
+        this.state.enemiesKilled += this.state.activeCombat.enemies.filter(e => e.hp <= 0).length;
+        // Check for level ups
+        for (const actorId of result.levelUps) {
+            const actor = this.actors[actorId];
+            if (actor) {
+                this.log(`${actor.name} leveled up to Lv${actor.stats.level}!`);
+                this.callbacks.onActorLevelUp?.(actorId, actor.name, actor.stats.level, this.state);
+            }
+        }
+        if (result.victory) {
+            this.log(`Victory! Team gained ${result.rewards.exp} EXP, ${result.rewards.gold} Gold`);
+        }
+        else {
+            this.log('Team was defeated...');
+            this.finishDungeon(false, 'Defeated in combat');
+            return;
+        }
+        this.callbacks.onCombatEnd?.(result, 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;
+                addTeamGold(this.team, chest.goldAmount);
+                this.log(`Team found ${chest.goldAmount} gold!`);
+            }
+            for (const item of chest.contents) {
+                this.state.lootCollected.push(item);
+                addItemToTeam(this.team, item);
+                this.log(`Team 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 all team members)
+     */
+    processFountainRoom(room) {
+        if (!this.state)
+            return;
+        // Heal all active team members
+        for (const actorId of this.team.activeMembers) {
+            const actor = this.actors[actorId];
+            if (actor && isActorAlive(actor)) {
+                const healAmount = Math.floor(actor.stats.maxHp * 0.5);
+                const healed = healActor(actor, healAmount);
+                this.state.actorHp[actorId] = actor.stats.hp;
+                const manaRestore = Math.floor(actor.stats.maxMp * 0.3);
+                actor.stats.mp = Math.min(actor.stats.maxMp, actor.stats.mp + manaRestore);
+                this.state.actorMp[actorId] = actor.stats.mp;
+            }
+        }
+        this.log('Team restored at fountain');
+        this.state.clearedRooms.add(room.id);
+        room.isCleared = true;
+        this.timeManager.startAction('rest', 'Team resting at fountain', ROOM_TIMES.fountain, { onComplete: 'room_processed' });
+    }
+    /**
+     * Process safe room - can revive dead members
+     */
+    processSafeRoom(room) {
+        if (!this.state)
+            return;
+        // Revive any dead team members at 50% HP
+        for (const actorId of this.team.reserveMembers) {
+            const actor = this.actors[actorId];
+            if (actor && actor.status === 'dead') {
+                reviveActor(actor, 0.5);
+                this.state.actorHp[actorId] = actor.stats.hp;
+                this.log(`${actor.name} was revived!`);
+            }
+        }
+        this.state.clearedRooms.add(room.id);
+        room.isCleared = true;
+        this.timeManager.startAction('rest', 'Team resting in safe room', ROOM_TIMES.safe_room, { onComplete: 'room_processed' });
+    }
+    /**
+     * Process altar room (buff)
+     */
+    processAltarRoom(room) {
+        if (!this.state)
+            return;
+        // Placeholder: altar gives temporary stat boost
+        this.log('Team 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})`);
+        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 (damage to frontline)
+     */
+    processTrapRoom(room) {
+        if (!this.state)
+            return;
+        const trap = room.content.trap;
+        if (trap && !trap.isTriggered && !trap.isDisarmed) {
+            if (this.state.strategy.exploration.avoidTraps) {
+                const disarmChance = 0.5;
+                if (Math.random() < disarmChance) {
+                    trap.isDisarmed = true;
+                    this.log('Team disarmed trap!');
+                }
+                else {
+                    trap.isTriggered = true;
+                    // Damage frontline actors
+                    this.applyTrapDamage(trap.damage);
+                }
+            }
+            else {
+                trap.isTriggered = true;
+                this.applyTrapDamage(trap.damage);
+            }
+        }
+        this.state.clearedRooms.add(room.id);
+        room.isCleared = true;
+        this.timeManager.startAction('explore_room', 'Handling trap', ROOM_TIMES.trap, { onComplete: 'room_processed' });
+    }
+    /**
+     * Apply trap damage to team
+     */
+    applyTrapDamage(damage) {
+        if (!this.state)
+            return;
+        // Frontline actors take full damage, backline takes half
+        const { FORMATION_EFFECTS } = require('./types.js');
+        const config = FORMATION_EFFECTS[this.team.formation];
+        for (let i = 0; i < this.team.activeMembers.length; i++) {
+            const actorId = this.team.activeMembers[i];
+            const actor = this.actors[actorId];
+            if (!actor || !isActorAlive(actor))
+                continue;
+            const isFrontline = config.frontline.includes(i);
+            const actualDamage = isFrontline ? damage : Math.floor(damage * 0.5);
+            actor.stats.hp = Math.max(1, actor.stats.hp - actualDamage);
+            this.state.actorHp[actorId] = actor.stats.hp;
+            this.log(`${actor.name} took ${actualDamage} trap damage`);
+        }
+    }
+    /**
+     * 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;
+                addTeamGold(this.team, 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(`Team 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 team's overall resource state
+        const teamHpPercent = this.getTeamHpPercent();
+        const teamMpPercent = this.getTeamMpPercent();
+        // Check if should retreat based on resources
+        const resourceCheck = this.state.strategyExecutor.checkResourceAction({
+            hp: teamHpPercent * 100, // Normalized to 0-100 for existing strategy
+            maxHp: 100,
+            mp: teamMpPercent * 100,
+            maxMp: 100,
+            gold: this.team.sharedGold,
+        });
+        if (resourceCheck.action === 'retreat_to_town') {
+            this.log(`Team 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: teamHpPercent * 100,
+                maxHp: 100,
+                mp: teamMpPercent * 100,
+                maxMp: 100,
+            },
+        };
+        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(`Team 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(`Team resting (${decision.reason})`);
+                // Heal all active members
+                for (const actorId of this.team.activeMembers) {
+                    const actor = this.actors[actorId];
+                    if (actor && isActorAlive(actor)) {
+                        const healAmount = Math.floor(actor.stats.maxHp * 0.2);
+                        healActor(actor, healAmount);
+                        this.state.actorHp[actorId] = actor.stats.hp;
+                    }
+                }
+                this.timeManager.startAction('rest', 'Team resting', ROOM_TIMES.rest, { onComplete: 'room_processed' });
+                break;
+            case 'search':
+                this.log(`Team searching room (${decision.reason})`);
+                if (Math.random() < 0.1) {
+                    const bonusGold = 25;
+                    this.state.goldCollected += bonusGold;
+                    addTeamGold(this.team, bonusGold);
+                    this.log(`Team found hidden ${bonusGold} gold!`);
+                }
+                this.timeManager.startAction('search', 'Searching', 30, { onComplete: 'room_processed' });
+                break;
+            case 'retreat':
+                this.log(`Team retreating (${decision.reason})`);
+                this.finishDungeon(false, decision.reason);
+                break;
+        }
+    }
+    // ============================================================================
+    // Utilities
+    // ============================================================================
+    /**
+     * Get team's average HP percentage
+     */
+    getTeamHpPercent() {
+        const activeActors = getActiveMembers(this.team, this.actors);
+        if (activeActors.length === 0)
+            return 0;
+        let totalHp = 0;
+        let totalMaxHp = 0;
+        for (const actor of activeActors) {
+            totalHp += this.state?.actorHp[actor.id] ?? actor.stats.hp;
+            totalMaxHp += actor.stats.maxHp;
+        }
+        return totalMaxHp > 0 ? totalHp / totalMaxHp : 0;
+    }
+    /**
+     * Get team's average MP percentage
+     */
+    getTeamMpPercent() {
+        const activeActors = getActiveMembers(this.team, this.actors);
+        if (activeActors.length === 0)
+            return 0;
+        let totalMp = 0;
+        let totalMaxMp = 0;
+        for (const actor of activeActors) {
+            totalMp += this.state?.actorMp[actor.id] ?? actor.stats.mp;
+            totalMaxMp += actor.stats.maxMp;
+        }
+        return totalMaxMp > 0 ? totalMp / totalMaxMp : 0;
+    }
+    /**
+     * 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;
+        // Sync final HP/MP back to actors
+        for (const actorId of this.team.activeMembers) {
+            const actor = this.actors[actorId];
+            if (actor) {
+                actor.stats.hp = this.state.actorHp[actorId] ?? actor.stats.hp;
+                actor.stats.mp = this.state.actorMp[actorId] ?? actor.stats.mp;
+            }
+        }
+        this.setPhase(success ? 'completed' : 'failed');
+        if (success) {
+            this.log(`Team completed ${this.state.dungeon.name}!`);
+            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
+// ============================================================================
+export function createTeamDungeonRunner(team, actors) {
+    return new TeamDungeonRunner(team, actors);
+}
+//# sourceMappingURL=TeamDungeonRunner.js.map
+//# debugId=1f164094-7235-514b-baae-ac9221fc9746