idlerpg.sh 0.1.0

package/dist/map/DungeonGenerator.js

@@ -0,0 +1,615 @@
+/**
+ * Dungeon Generator - Creates multi-level dungeons for IdleRPG
+ * Builds on BSP algorithm for room generation
+ */
+// ============================================================================
+// Seeded Random
+// ============================================================================
+
+!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]="f9bf2c94-0d0f-5913-8725-ff22ce400a3b")}catch(e){}}();
+class SeededRandom {
+    seed;
+    constructor(seed) {
+        this.seed = seed;
+    }
+    next() {
+        this.seed = (this.seed * 1103515245 + 12345) & 0x7fffffff;
+        return this.seed / 0x7fffffff;
+    }
+    nextInt(min, max) {
+        return Math.floor(this.next() * (max - min + 1)) + min;
+    }
+    pick(array) {
+        return array[Math.floor(this.next() * array.length)];
+    }
+    shuffle(array) {
+        const result = [...array];
+        for (let i = result.length - 1; i > 0; i--) {
+            const j = Math.floor(this.next() * (i + 1));
+            [result[i], result[j]] = [result[j], result[i]];
+        }
+        return result;
+    }
+}
+// ============================================================================
+// Room Type Weights by Difficulty
+// ============================================================================
+const ROOM_TYPE_WEIGHTS = {
+    easy: [
+        { type: 'combat', weight: 35 },
+        { type: 'treasure', weight: 15 },
+        { type: 'fountain', weight: 10 },
+        { type: 'altar', weight: 5 },
+        { type: 'event', weight: 10 },
+        { type: 'safe_room', weight: 10 },
+        { type: 'empty', weight: 10 },
+        { type: 'dead_end', weight: 5 },
+    ],
+    normal: [
+        { type: 'combat', weight: 35 },
+        { type: 'elite', weight: 10 },
+        { type: 'treasure', weight: 12 },
+        { type: 'fountain', weight: 8 },
+        { type: 'altar', weight: 5 },
+        { type: 'event', weight: 10 },
+        { type: 'trap', weight: 5 },
+        { type: 'safe_room', weight: 8 },
+        { type: 'dead_end', weight: 7 },
+    ],
+    hard: [
+        { type: 'combat', weight: 30 },
+        { type: 'elite', weight: 18 },
+        { type: 'ambush', weight: 7 },
+        { type: 'treasure', weight: 10 },
+        { type: 'fountain', weight: 5 },
+        { type: 'altar', weight: 5 },
+        { type: 'event', weight: 8 },
+        { type: 'trap', weight: 10 },
+        { type: 'puzzle', weight: 5 },
+        { type: 'dead_end', weight: 7 },
+    ],
+    nightmare: [
+        { type: 'combat', weight: 25 },
+        { type: 'elite', weight: 22 },
+        { type: 'ambush', weight: 10 },
+        { type: 'treasure', weight: 8 },
+        { type: 'fountain', weight: 3 },
+        { type: 'trap', weight: 15 },
+        { type: 'puzzle', weight: 7 },
+        { type: 'event', weight: 5 },
+        { type: 'dead_end', weight: 5 },
+    ],
+    legendary: [
+        { type: 'elite', weight: 30 },
+        { type: 'combat', weight: 20 },
+        { type: 'ambush', weight: 12 },
+        { type: 'trap', weight: 15 },
+        { type: 'puzzle', weight: 10 },
+        { type: 'treasure', weight: 8 },
+        { type: 'dead_end', weight: 5 },
+    ],
+};
+// ============================================================================
+// Time Constants (in real seconds)
+// Import from centralized time constants
+// ============================================================================
+import { ROOM_TIMES } from '../core/timeConstants.js';
+const ROOM_TRAVERSE_TIMES = {
+    // Special navigation rooms
+    entrance: ROOM_TIMES.entrance,
+    exit: ROOM_TIMES.exit,
+    dead_end: ROOM_TIMES.dead_end,
+    safe_room: ROOM_TIMES.safe_room,
+    // Combat rooms
+    combat: ROOM_TIMES.combat,
+    elite: ROOM_TIMES.elite,
+    boss: ROOM_TIMES.boss,
+    ambush: ROOM_TIMES.ambush,
+    // Reward rooms
+    treasure: ROOM_TIMES.treasure,
+    fountain: ROOM_TIMES.fountain,
+    altar: ROOM_TIMES.altar,
+    shop: ROOM_TIMES.shop,
+    // Event rooms
+    event: ROOM_TIMES.event,
+    encounter: ROOM_TIMES.encounter,
+    trap: ROOM_TIMES.trap,
+    puzzle: ROOM_TIMES.puzzle,
+    // Generic rooms
+    rest: ROOM_TIMES.rest,
+    empty: ROOM_TIMES.empty,
+};
+// ============================================================================
+// Generator Functions
+// ============================================================================
+/**
+ * Generate a complete dungeon with multiple levels
+ */
+export function generateDungeon(config) {
+    const rng = new SeededRandom(config.seed ?? Date.now());
+    const levels = [];
+    // Generate each level
+    for (let levelNum = 1; levelNum <= config.numberOfLevels; levelNum++) {
+        const isLastLevel = levelNum === config.numberOfLevels;
+        const level = generateDungeonLevel(levelNum, config, rng, isLastLevel && config.hasBoss);
+        levels.push(level);
+    }
+    // Calculate estimated clear time
+    const estimatedTime = levels.reduce((total, level) => {
+        return total + level.rooms.reduce((levelTotal, room) => {
+            return levelTotal + room.timeToTraverse;
+        }, 0);
+    }, 0);
+    return {
+        id: config.dungeonId,
+        name: config.name,
+        description: config.description,
+        continentId: config.continentId,
+        nearestTownId: config.nearestTownId,
+        difficulty: config.difficulty,
+        recommendedLevel: config.recommendedLevel,
+        levels,
+        hasBoss: config.hasBoss,
+        bossName: config.bossName,
+        estimatedTime,
+        rewards: generateDungeonRewards(config.difficulty, config.recommendedLevel, rng),
+        travelTimeFromTown: 120, // 2 minutes to reach dungeon
+    };
+}
+/**
+ * Generate a single dungeon level
+ */
+function generateDungeonLevel(levelNumber, config, rng, hasBoss) {
+    const roomCount = rng.nextInt(config.roomsPerLevel.min, config.roomsPerLevel.max);
+    const rooms = [];
+    // Generate entrance room
+    const entranceRoom = createRoom(`${config.dungeonId}_L${levelNumber}_entrance`, 'entrance', levelNumber, config, rng, { x: 0, y: 0 });
+    rooms.push(entranceRoom);
+    // Generate middle rooms
+    const middleRoomCount = roomCount - 2 - (hasBoss ? 1 : 0);
+    const roomTypes = selectRoomTypes(middleRoomCount, config.difficulty, rng);
+    let x = 1;
+    let y = 0;
+    for (let i = 0; i < middleRoomCount; i++) {
+        const roomId = `${config.dungeonId}_L${levelNumber}_R${i}`;
+        const room = createRoom(roomId, roomTypes[i], levelNumber, config, rng, { x, y });
+        rooms.push(room);
+        // Simple branching layout
+        if (rng.next() < 0.3 && i < middleRoomCount - 1) {
+            y += rng.next() < 0.5 ? 1 : -1;
+        }
+        else {
+            x++;
+        }
+    }
+    // Generate boss room if needed
+    let bossRoomId;
+    if (hasBoss) {
+        bossRoomId = `${config.dungeonId}_L${levelNumber}_boss`;
+        const bossRoom = createRoom(bossRoomId, 'boss', levelNumber, config, rng, { x: x + 1, y: 0 });
+        bossRoom.content.enemies = generateBossEnemy(config, rng);
+        rooms.push(bossRoom);
+        x++;
+    }
+    // Generate exit room
+    const exitRoom = createRoom(`${config.dungeonId}_L${levelNumber}_exit`, 'exit', levelNumber, config, rng, { x: x + 1, y: 0 });
+    rooms.push(exitRoom);
+    // Connect rooms
+    connectRooms(rooms, rng);
+    return {
+        levelNumber,
+        name: `${config.name} - Level ${levelNumber}`,
+        rooms,
+        entranceRoomId: entranceRoom.id,
+        exitRoomId: exitRoom.id,
+        bossRoomId,
+        minEnemyLevel: config.recommendedLevel + levelNumber - 1,
+        maxEnemyLevel: config.recommendedLevel + levelNumber + 1,
+    };
+}
+/**
+ * Select room types based on difficulty
+ */
+function selectRoomTypes(count, difficulty, rng) {
+    const weights = ROOM_TYPE_WEIGHTS[difficulty];
+    const totalWeight = weights.reduce((sum, w) => sum + w.weight, 0);
+    const types = [];
+    for (let i = 0; i < count; i++) {
+        let roll = rng.next() * totalWeight;
+        for (const { type, weight } of weights) {
+            roll -= weight;
+            if (roll <= 0) {
+                types.push(type);
+                break;
+            }
+        }
+    }
+    return rng.shuffle(types);
+}
+/**
+ * Create a dungeon room
+ */
+function createRoom(id, type, levelNumber, config, rng, position) {
+    const content = generateRoomContent(type, levelNumber, config, rng);
+    return {
+        id,
+        type,
+        name: generateRoomName(type, rng),
+        description: generateRoomDescription(type, rng),
+        connections: [],
+        content,
+        timeToTraverse: ROOM_TRAVERSE_TIMES[type],
+        isExplored: false,
+        isCleared: type === 'entrance' || type === 'exit' || type === 'empty',
+        position,
+    };
+}
+/**
+ * Generate room content based on type
+ */
+function generateRoomContent(type, levelNumber, config, rng) {
+    const content = {};
+    switch (type) {
+        // Combat rooms
+        case 'combat':
+            content.enemies = generateEnemies(config.recommendedLevel + levelNumber - 1, 1, 3, rng);
+            break;
+        case 'elite':
+            content.enemies = generateEliteEnemies(config.recommendedLevel + levelNumber, rng);
+            break;
+        case 'ambush':
+            // Ambush: enemies attack first, player cannot use items initially
+            content.enemies = generateEnemies(config.recommendedLevel + levelNumber - 1, 2, 4, rng);
+            break;
+        // Reward rooms
+        case 'treasure':
+            content.treasureChest = generateTreasureChest(config.difficulty, rng);
+            break;
+        case 'fountain':
+            // Fountain: heals HP/MP (handled by game logic, no content needed)
+            break;
+        case 'altar':
+            // Altar: provides temporary buff (handled by game logic, no content needed)
+            break;
+        // Event rooms
+        case 'trap':
+            content.trap = generateTrap(config.difficulty, rng);
+            break;
+        case 'event':
+            content.items = rng.next() < 0.5 ? generateRandomItems(1, rng) : undefined;
+            break;
+        // Special rooms
+        case 'dead_end':
+            // Dead ends may have hidden treasure
+            if (rng.next() < 0.3) {
+                content.treasureChest = generateTreasureChest(config.difficulty, rng);
+                content.treasureChest.isLocked = false; // Hidden treasure is unlocked
+            }
+            break;
+        case 'safe_room':
+            // Safe rooms may have a merchant
+            if (rng.next() < 0.2) {
+                content.items = generateRandomItems(2, rng);
+            }
+            break;
+    }
+    return content;
+}
+/**
+ * Generate regular enemies
+ */
+function generateEnemies(baseLevel, minCount, maxCount, rng) {
+    const count = rng.nextInt(minCount, maxCount);
+    const enemies = [];
+    const enemyTypes = [
+        { name: 'Goblin', hpMult: 1, atkMult: 1, defMult: 0.8 },
+        { name: 'Skeleton', hpMult: 0.8, atkMult: 1.1, defMult: 0.9 },
+        { name: 'Slime', hpMult: 1.2, atkMult: 0.8, defMult: 0.5 },
+        { name: 'Orc', hpMult: 1.5, atkMult: 1.2, defMult: 1 },
+        { name: 'Bat Swarm', hpMult: 0.6, atkMult: 0.7, defMult: 0.3 },
+        { name: 'Spider', hpMult: 0.9, atkMult: 1, defMult: 0.6 },
+    ];
+    for (let i = 0; i < count; i++) {
+        const type = rng.pick(enemyTypes);
+        const level = baseLevel + rng.nextInt(-1, 1);
+        enemies.push({
+            id: `enemy_${Date.now()}_${i}_${rng.nextInt(1000, 9999)}`,
+            name: type.name,
+            level,
+            hp: Math.floor(20 * level * type.hpMult),
+            maxHp: Math.floor(20 * level * type.hpMult),
+            attack: Math.floor(5 * level * type.atkMult),
+            defense: Math.floor(3 * level * type.defMult),
+            speed: 5 + level,
+            expReward: 10 * level,
+            goldReward: rng.nextInt(5, 20) * level,
+            dropTable: [
+                { itemId: 'health_potion', chance: 0.2, quantity: { min: 1, max: 1 } },
+            ],
+            isBoss: false,
+        });
+    }
+    return enemies;
+}
+/**
+ * Generate elite enemies
+ */
+function generateEliteEnemies(baseLevel, rng) {
+    const eliteTypes = [
+        { name: 'Orc Warlord', hpMult: 2.5, atkMult: 1.5, defMult: 1.3 },
+        { name: 'Dark Mage', hpMult: 1.5, atkMult: 2, defMult: 0.8 },
+        { name: 'Stone Golem', hpMult: 3, atkMult: 1, defMult: 2 },
+        { name: 'Shadow Assassin', hpMult: 1.2, atkMult: 2.5, defMult: 0.5 },
+    ];
+    const type = rng.pick(eliteTypes);
+    const level = baseLevel + 2;
+    return [{
+            id: `elite_${Date.now()}_${rng.nextInt(1000, 9999)}`,
+            name: type.name,
+            level,
+            hp: Math.floor(30 * level * type.hpMult),
+            maxHp: Math.floor(30 * level * type.hpMult),
+            attack: Math.floor(7 * level * type.atkMult),
+            defense: Math.floor(4 * level * type.defMult),
+            speed: 8 + level,
+            expReward: 30 * level,
+            goldReward: rng.nextInt(20, 50) * level,
+            dropTable: [
+                { itemId: 'health_potion', chance: 0.5, quantity: { min: 1, max: 2 } },
+                { itemId: 'affix_fragment', chance: 0.3, quantity: { min: 1, max: 1 } },
+            ],
+            isBoss: false,
+        }];
+}
+/**
+ * Generate boss enemy
+ */
+function generateBossEnemy(config, rng) {
+    const bossTypes = [
+        { name: 'Goblin King', hpMult: 4, atkMult: 1.8, defMult: 1.5 },
+        { name: 'Ancient Lich', hpMult: 3.5, atkMult: 2.5, defMult: 1 },
+        { name: 'Dragon Whelp', hpMult: 5, atkMult: 2, defMult: 2 },
+        { name: 'Demon Lord', hpMult: 4.5, atkMult: 2.2, defMult: 1.8 },
+    ];
+    const type = config.bossName
+        ? { name: config.bossName, hpMult: 4, atkMult: 2, defMult: 1.5 }
+        : rng.pick(bossTypes);
+    const level = config.recommendedLevel + config.numberOfLevels + 2;
+    return [{
+            id: `boss_${config.dungeonId}_${Date.now()}`,
+            name: type.name,
+            level,
+            hp: Math.floor(50 * level * type.hpMult),
+            maxHp: Math.floor(50 * level * type.hpMult),
+            attack: Math.floor(10 * level * type.atkMult),
+            defense: Math.floor(5 * level * type.defMult),
+            speed: 10 + level,
+            expReward: 100 * level,
+            goldReward: rng.nextInt(100, 300) * level,
+            dropTable: [
+                { itemId: 'health_potion', chance: 1, quantity: { min: 2, max: 3 } },
+                { itemId: 'affix_fragment', chance: 0.8, quantity: { min: 1, max: 2 } },
+                { itemId: 'rare_material', chance: 0.5, quantity: { min: 1, max: 1 } },
+            ],
+            isBoss: true,
+        }];
+}
+/**
+ * Generate treasure chest
+ */
+function generateTreasureChest(difficulty, rng) {
+    const rarityByDifficulty = {
+        easy: ['common', 'common', 'uncommon'],
+        normal: ['common', 'uncommon', 'uncommon', 'rare'],
+        hard: ['uncommon', 'rare', 'rare', 'epic'],
+        nightmare: ['rare', 'epic', 'epic', 'legendary'],
+        legendary: ['epic', 'legendary', 'legendary'],
+    };
+    const rarity = rng.pick(rarityByDifficulty[difficulty]);
+    const goldMultiplier = { common: 1, uncommon: 2, rare: 4, epic: 8, legendary: 20 };
+    return {
+        id: `chest_${Date.now()}_${rng.nextInt(1000, 9999)}`,
+        rarity,
+        isOpened: false,
+        isLocked: rng.next() < 0.3,
+        contents: generateRandomItems(rng.nextInt(1, 3), rng),
+        goldAmount: rng.nextInt(10, 50) * goldMultiplier[rarity],
+    };
+}
+/**
+ * Generate trap
+ */
+function generateTrap(difficulty, rng) {
+    const traps = [
+        { name: 'Spike Trap', damage: 20, effect: 'bleeding' },
+        { name: 'Poison Dart', damage: 10, effect: 'poisoned' },
+        { name: 'Fire Geyser', damage: 30, effect: 'burning' },
+        { name: 'Ice Blast', damage: 15, effect: 'frozen' },
+        { name: 'Pitfall', damage: 25 },
+    ];
+    const trap = rng.pick(traps);
+    const difficultyMod = { easy: 0.5, normal: 1, hard: 1.5, nightmare: 2, legendary: 3 };
+    return {
+        id: `trap_${Date.now()}_${rng.nextInt(1000, 9999)}`,
+        name: trap.name,
+        damage: Math.floor(trap.damage * difficultyMod[difficulty]),
+        effect: trap.effect,
+        disarmDifficulty: rng.nextInt(3, 8),
+        isTriggered: false,
+        isDisarmed: false,
+    };
+}
+/**
+ * Generate random items
+ */
+function generateRandomItems(count, rng) {
+    const items = [];
+    const itemTypes = [
+        { id: 'health_potion', name: 'Health Potion', type: 'consumable' },
+        { id: 'mana_potion', name: 'Mana Potion', type: 'consumable' },
+        { id: 'antidote', name: 'Antidote', type: 'consumable' },
+        { id: 'iron_ore', name: 'Iron Ore', type: 'material' },
+        { id: 'magic_crystal', name: 'Magic Crystal', type: 'material' },
+    ];
+    for (let i = 0; i < count; i++) {
+        const item = rng.pick(itemTypes);
+        items.push({
+            id: `${item.id}_${Date.now()}_${i}`,
+            type: item.type,
+            name: item.name,
+            description: `A ${item.name.toLowerCase()}`,
+            quantity: rng.nextInt(1, 3),
+        });
+    }
+    return items;
+}
+/**
+ * Generate dungeon rewards
+ */
+function generateDungeonRewards(difficulty, level, rng) {
+    const baseExp = level * 100;
+    const baseGold = level * 50;
+    const diffMod = { easy: 1, normal: 1.5, hard: 2, nightmare: 3, legendary: 5 };
+    return [
+        { type: 'exp', value: Math.floor(baseExp * diffMod[difficulty]), chance: 1 },
+        { type: 'gold', value: Math.floor(baseGold * diffMod[difficulty]), chance: 1 },
+        { type: 'item', value: 'affix_fragment', chance: 0.5 },
+    ];
+}
+/**
+ * Connect rooms in a level
+ */
+function connectRooms(rooms, rng) {
+    // Connect rooms linearly first
+    for (let i = 0; i < rooms.length - 1; i++) {
+        const currentRoom = rooms[i];
+        const nextRoom = rooms[i + 1];
+        // Determine direction
+        const dx = nextRoom.position.x - currentRoom.position.x;
+        const dy = nextRoom.position.y - currentRoom.position.y;
+        let direction = 'east';
+        let reverseDir = 'west';
+        if (Math.abs(dy) > Math.abs(dx)) {
+            direction = dy > 0 ? 'south' : 'north';
+            reverseDir = dy > 0 ? 'north' : 'south';
+        }
+        currentRoom.connections.push({
+            targetRoomId: nextRoom.id,
+            direction,
+            isLocked: false,
+            isHidden: false,
+        });
+        nextRoom.connections.push({
+            targetRoomId: currentRoom.id,
+            direction: reverseDir,
+            isLocked: false,
+            isHidden: false,
+        });
+    }
+    // Add some random connections for variety
+    for (let i = 0; i < rooms.length - 2; i++) {
+        if (rng.next() < 0.2) {
+            const j = rng.nextInt(i + 2, Math.min(i + 4, rooms.length - 1));
+            const roomA = rooms[i];
+            const roomB = rooms[j];
+            // Check if already connected
+            if (!roomA.connections.some(c => c.targetRoomId === roomB.id)) {
+                roomA.connections.push({
+                    targetRoomId: roomB.id,
+                    direction: 'east',
+                    isLocked: false,
+                    isHidden: rng.next() < 0.3,
+                });
+                roomB.connections.push({
+                    targetRoomId: roomA.id,
+                    direction: 'west',
+                    isLocked: false,
+                    isHidden: rng.next() < 0.3,
+                });
+            }
+        }
+    }
+}
+/**
+ * Generate room name
+ */
+function generateRoomName(type, rng) {
+    const names = {
+        // Special navigation rooms
+        entrance: ['Dungeon Entrance', 'Gateway', 'Entry Hall'],
+        exit: ['Stairway Down', 'Exit Passage', 'Descent'],
+        dead_end: ['Dead End', 'Blocked Passage', 'Collapsed Tunnel'],
+        safe_room: ['Safe Haven', 'Sanctuary', 'Hidden Refuge'],
+        // Combat rooms
+        combat: ['Monster Den', 'Dark Corridor', 'Infested Hall'],
+        elite: ['Champion\'s Arena', 'Elite Guard Post', 'Proving Grounds'],
+        boss: ['Throne Room', 'Lair of Darkness', 'Final Chamber'],
+        ambush: ['Shadow Corner', 'Ambush Point', 'Treacherous Path'],
+        // Reward rooms
+        treasure: ['Treasure Vault', 'Golden Chamber', 'Loot Room'],
+        fountain: ['Healing Spring', 'Crystal Fountain', 'Sacred Waters'],
+        altar: ['Ancient Altar', 'Blessing Shrine', 'Power Nexus'],
+        shop: ['Merchant\'s Corner', 'Trading Post', 'Hidden Shop'],
+        // Event rooms
+        event: ['Mysterious Shrine', 'Strange Chamber', 'Enigma Room'],
+        encounter: ['Traveler\'s Rest', 'Hidden Camp', 'Meeting Point'],
+        trap: ['Danger Zone', 'Trapped Corridor', 'Perilous Path'],
+        puzzle: ['Riddle Room', 'Puzzle Chamber', 'Mind Trial'],
+        // Generic rooms
+        rest: ['Resting Spot', 'Quiet Corner', 'Peaceful Alcove'],
+        empty: ['Empty Corridor', 'Silent Hall', 'Abandoned Room'],
+    };
+    return rng.pick(names[type]);
+}
+/**
+ * Generate room description
+ */
+function generateRoomDescription(type, rng) {
+    const descriptions = {
+        // Special navigation rooms
+        entrance: ['The entrance to the dungeon. Darkness awaits.'],
+        exit: ['A passage leading deeper into the dungeon.'],
+        dead_end: ['The path ends here. Perhaps there is something hidden...'],
+        safe_room: ['A protected area where you can rest safely.'],
+        // Combat rooms
+        combat: ['Shadows move in the darkness. Enemies lurk here.'],
+        elite: ['A powerful foe guards this area.'],
+        boss: ['An oppressive presence fills the room. The boss awaits.'],
+        ambush: ['Something doesn\'t feel right... Watch your back!'],
+        // Reward rooms
+        treasure: ['Glittering treasures catch your eye.'],
+        fountain: ['Clear water flows from an ancient spring. It looks refreshing.'],
+        altar: ['A mystical altar radiates power. Touch it for a blessing.'],
+        shop: ['A merchant has set up shop here.'],
+        // Event rooms
+        event: ['Strange energy pulses from within.'],
+        encounter: ['Someone has made camp here.'],
+        trap: ['Something feels wrong about this place. Proceed with caution.'],
+        puzzle: ['Ancient mechanisms line the walls. A puzzle awaits.'],
+        // Generic rooms
+        rest: ['A peaceful respite from danger.'],
+        empty: ['An empty room. Nothing of immediate interest.'],
+    };
+    return rng.pick(descriptions[type]);
+}
+/**
+ * Regenerate a dungeon with a new seed
+ */
+export function regenerateDungeon(dungeon, newSeed) {
+    return generateDungeon({
+        dungeonId: dungeon.id,
+        name: dungeon.name,
+        description: dungeon.description,
+        continentId: dungeon.continentId,
+        nearestTownId: dungeon.nearestTownId,
+        difficulty: dungeon.difficulty,
+        recommendedLevel: dungeon.recommendedLevel,
+        numberOfLevels: dungeon.levels.length,
+        roomsPerLevel: { min: 6, max: 10 },
+        hasBoss: dungeon.hasBoss,
+        bossName: dungeon.bossName,
+        seed: newSeed ?? Date.now(),
+    });
+}
+//# sourceMappingURL=DungeonGenerator.js.map
+//# debugId=f9bf2c94-0d0f-5913-8725-ff22ce400a3b