idlerpg.sh 0.1.0

package/dist/core/Game.js

@@ -0,0 +1,644 @@
+/**
+ * Main Game class - orchestrates the game loop and state management
+ */
+
+!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]="2cabfb3c-6dcf-5bd3-9b23-de27057ab179")}catch(e){}}();
+import { generateMap } from '../map/MapGenerator.js';
+import { initCombat, processCombatTurn, calculateCombatRewards } from './Combat.js';
+import { addExperience, addGold, healPlayer } from './Player.js';
+const DEFAULT_SETTINGS = {
+    language: 'en',
+    autoSave: true,
+    autoSaveInterval: 60,
+    combatSpeed: 1,
+    soundEnabled: false,
+};
+export class Game {
+    state = null;
+    settings;
+    tickInterval = null;
+    lastTickTime = 0;
+    eventListeners = new Map();
+    // Event cooldown system - minimum 30 seconds between random events
+    lastRandomEventTime = 0;
+    MIN_EVENT_COOLDOWN_MS = 30000; // 30 seconds
+    constructor(settings = {}) {
+        this.settings = { ...DEFAULT_SETTINGS, ...settings };
+    }
+    /**
+     * Initialize a new game
+     */
+    async initialize(playerName) {
+        const player = this.createNewPlayer(playerName);
+        const startMap = this.createStartingMap();
+        const startRoom = startMap.rooms.get(startMap.startRoomId);
+        this.state = {
+            phase: 'exploring',
+            player,
+            currentMap: startMap,
+            currentRoom: startRoom,
+            pendingEvents: [],
+            gameTime: 0,
+            lastUpdateTime: Date.now(),
+            isPaused: false,
+        };
+        // Start the game loop
+        this.startGameLoop();
+        this.emit('game:initialized', { player, map: startMap });
+    }
+    /**
+     * Start the real-time game loop
+     */
+    startGameLoop() {
+        const TICK_RATE = 1000; // 1 second per tick (real-time sync)
+        this.lastTickTime = Date.now();
+        this.tickInterval = setInterval(() => {
+            this.tick();
+        }, TICK_RATE);
+    }
+    /**
+     * Stop the game loop
+     */
+    stopGameLoop() {
+        if (this.tickInterval) {
+            clearInterval(this.tickInterval);
+            this.tickInterval = null;
+        }
+    }
+    /**
+     * Main game tick - called every second
+     */
+    tick() {
+        if (!this.state || this.state.isPaused)
+            return;
+        const now = Date.now();
+        const deltaTime = (now - this.lastTickTime) / 1000; // Seconds
+        this.lastTickTime = now;
+        // Update game time (synced with real time)
+        this.state.gameTime += deltaTime;
+        this.state.lastUpdateTime = now;
+        // Process based on current phase
+        switch (this.state.phase) {
+            case 'traveling':
+                this.processTravelTick(deltaTime);
+                break;
+            case 'combat':
+                this.processCombatTick(deltaTime);
+                break;
+            case 'exploring':
+                this.processExploringTick(deltaTime);
+                break;
+            default:
+                break;
+        }
+        // Process pending events
+        this.processPendingEvents();
+        // Auto-save check
+        if (this.settings.autoSave &&
+            this.state.gameTime % this.settings.autoSaveInterval < deltaTime) {
+            this.save();
+        }
+        this.emit('game:tick', { gameTime: this.state.gameTime, deltaTime });
+    }
+    /**
+     * Process travel state
+     */
+    processTravelTick(deltaTime) {
+        if (!this.state?.travelState)
+            return;
+        const travel = this.state.travelState;
+        const elapsed = (Date.now() - travel.startTime) / 1000;
+        travel.progress = Math.min(elapsed / travel.duration, 1);
+        // Check for random events during travel
+        if (Math.random() < 0.1 * deltaTime) { // 10% chance per second
+            this.generateTravelEvent();
+        }
+        // Check if travel is complete
+        if (travel.progress >= 1) {
+            this.completeTravelArrival();
+        }
+        this.emit('travel:progress', travel);
+    }
+    /**
+     * Process combat state (auto-combat based on strategy)
+     */
+    processCombatTick(deltaTime) {
+        if (!this.state?.combat)
+            return;
+        // Combat processes one turn every 2 seconds (modified by speed setting)
+        const combatDelta = deltaTime * this.settings.combatSpeed;
+        this.combatAccumulator = (this.combatAccumulator || 0) + combatDelta;
+        const turnDuration = 2; // 2 seconds per turn
+        if (this.combatAccumulator >= turnDuration) {
+            this.combatAccumulator = 0;
+            // Process combat turn
+            const result = processCombatTurn(this.state.combat, this.state.player);
+            this.state.combat = result.combat;
+            if (result.finished) {
+                if (result.victory) {
+                    // Calculate rewards
+                    const rewards = calculateCombatRewards(this.state.combat.enemies);
+                    this.state.player = addExperience(this.state.player, rewards.exp);
+                    this.state.player = addGold(this.state.player, rewards.gold);
+                    // Mark room as cleared
+                    this.state.currentRoom.isCleared = true;
+                    this.emit('combat:victory', { rewards });
+                }
+                else {
+                    // Player defeated - respawn at start room
+                    this.respawnPlayer();
+                    this.emit('combat:defeat', {});
+                }
+                this.state.combat = undefined;
+                this.state.phase = 'exploring';
+            }
+        }
+        this.emit('combat:tick', { deltaTime: combatDelta, combat: this.state.combat });
+    }
+    combatAccumulator = 0;
+    /**
+     * Process exploring state
+     */
+    processExploringTick(deltaTime) {
+        // Check for timed quests
+        this.checkQuestTimers();
+        // Random events while exploring (with cooldown to prevent spam)
+        const now = Date.now();
+        const timeSinceLastEvent = now - this.lastRandomEventTime;
+        // Only allow random events if cooldown has passed
+        if (timeSinceLastEvent >= this.MIN_EVENT_COOLDOWN_MS) {
+            if (Math.random() < 0.02 * deltaTime) { // 2% chance per second
+                this.generateRandomEvent();
+                this.lastRandomEventTime = now;
+            }
+        }
+    }
+    /**
+     * Generate a random travel event
+     */
+    generateTravelEvent() {
+        const eventTypes = ['resource_found', 'enemy_encounter', 'npc_sighting', 'nothing'];
+        const weights = [0.3, 0.2, 0.1, 0.4];
+        const roll = Math.random();
+        let cumulative = 0;
+        let selectedType = 'nothing';
+        for (let i = 0; i < eventTypes.length; i++) {
+            cumulative += weights[i];
+            if (roll < cumulative) {
+                selectedType = eventTypes[i];
+                break;
+            }
+        }
+        if (selectedType !== 'nothing') {
+            const event = {
+                id: `event_${Date.now()}`,
+                type: 'travel_event',
+                title: this.getTravelEventTitle(selectedType),
+                description: this.getTravelEventDescription(selectedType),
+                timestamp: Date.now(),
+                processed: false,
+            };
+            this.state.pendingEvents.push(event);
+        }
+    }
+    /**
+     * Complete travel and arrive at destination
+     */
+    completeTravelArrival() {
+        if (!this.state?.travelState)
+            return;
+        const destRoom = this.state.currentMap.rooms.get(this.state.travelState.toRoomId);
+        if (destRoom) {
+            this.state.currentRoom = destRoom;
+            this.state.player.position = { ...destRoom.position };
+            if (!destRoom.isExplored) {
+                destRoom.isExplored = true;
+                if (!this.state.player.discoveredLocations.includes(destRoom.id)) {
+                    this.state.player.discoveredLocations.push(destRoom.id);
+                }
+            }
+            this.emit('travel:arrived', { room: destRoom });
+            // Check for room encounters
+            if (destRoom.enemies && destRoom.enemies.length > 0 && !destRoom.isCleared) {
+                this.startCombat(destRoom.enemies);
+            }
+        }
+        this.state.travelState = undefined;
+        this.state.phase = 'exploring';
+    }
+    /**
+     * Start traveling to a room
+     */
+    travelTo(roomId) {
+        if (!this.state)
+            return false;
+        const targetRoom = this.state.currentMap.rooms.get(roomId);
+        if (!targetRoom)
+            return false;
+        // Check if connected
+        if (!this.state.currentRoom.connections.includes(roomId)) {
+            return false;
+        }
+        // Calculate travel time based on distance
+        const distance = this.calculateDistance(this.state.currentRoom.position, targetRoom.position);
+        const baseDuration = distance * 30; // 30 seconds per unit distance
+        this.state.travelState = {
+            fromRoomId: this.state.currentRoom.id,
+            toRoomId: roomId,
+            startTime: Date.now(),
+            duration: baseDuration,
+            progress: 0,
+            events: [],
+        };
+        this.state.phase = 'traveling';
+        this.emit('travel:started', this.state.travelState);
+        return true;
+    }
+    /**
+     * Cancel current travel and return to origin room
+     */
+    cancelTravel() {
+        if (!this.state?.travelState)
+            return false;
+        // Stay at origin room (don't change currentRoom)
+        this.state.travelState = undefined;
+        this.state.phase = 'exploring';
+        this.emit('travel:cancelled', {});
+        return true;
+    }
+    /**
+     * Start combat with enemies
+     */
+    startCombat(enemies) {
+        if (!this.state)
+            return;
+        // Initialize combat using the Combat module
+        this.state.combat = initCombat(this.state.player, enemies);
+        this.state.phase = 'combat';
+        this.combatAccumulator = 0;
+        this.emit('combat:started', this.state.combat);
+    }
+    /**
+     * Set combat strategy
+     */
+    setCombatStrategy(strategy) {
+        if (this.state?.combat) {
+            this.state.combat.strategy = strategy;
+            this.emit('combat:strategy_changed', { strategy });
+        }
+    }
+    /**
+     * Respawn player at start room with full HP
+     */
+    respawnPlayer() {
+        if (!this.state)
+            return;
+        // Heal player to full HP
+        this.state.player = healPlayer(this.state.player, this.state.player.stats.maxHp);
+        // Move to start room
+        const startRoom = this.state.currentMap.rooms.get('start_room');
+        if (startRoom) {
+            this.state.currentRoom = startRoom;
+            this.state.player.position = { ...startRoom.position };
+        }
+        this.emit('player:respawn', { room: this.state.currentRoom });
+    }
+    /**
+     * Process pending events
+     */
+    processPendingEvents() {
+        if (!this.state)
+            return;
+        const unprocessed = this.state.pendingEvents.filter(e => !e.processed);
+        for (const event of unprocessed) {
+            this.emit('event:new', event);
+            event.processed = true;
+        }
+        // Clean up old processed events to prevent memory leak (keep last 50)
+        if (this.state.pendingEvents.length > 50) {
+            this.state.pendingEvents = this.state.pendingEvents.slice(-50);
+        }
+    }
+    /**
+     * Check quest timers
+     */
+    checkQuestTimers() {
+        if (!this.state)
+            return;
+        for (const quest of this.state.player.activeQuests) {
+            if (quest.timeLimit && quest.startTime) {
+                const elapsed = (Date.now() - quest.startTime) / 1000;
+                if (elapsed >= quest.timeLimit) {
+                    quest.status = 'failed';
+                    this.emit('quest:failed', { quest });
+                }
+            }
+        }
+    }
+    /**
+     * Generate a random exploration event
+     */
+    generateRandomEvent() {
+        if (!this.state)
+            return;
+        const eventTypes = [
+            { type: 'item_found', weight: 30 },
+            { type: 'random_encounter', weight: 20 },
+            { type: 'npc_encounter', weight: 15 },
+            { type: 'quest_hint', weight: 15 },
+            { type: 'nothing', weight: 20 },
+        ];
+        const totalWeight = eventTypes.reduce((sum, e) => sum + e.weight, 0);
+        let roll = Math.random() * totalWeight;
+        let selectedType = 'nothing';
+        for (const et of eventTypes) {
+            roll -= et.weight;
+            if (roll <= 0) {
+                selectedType = et.type;
+                break;
+            }
+        }
+        if (selectedType === 'nothing')
+            return;
+        const eventData = {
+            item_found: {
+                title: 'Discovery!',
+                description: 'You found a small cache of supplies hidden nearby.',
+            },
+            random_encounter: {
+                title: 'Danger!',
+                description: 'Something stirs in the shadows...',
+            },
+            npc_encounter: {
+                title: 'A Stranger Appears',
+                description: 'A mysterious figure approaches you.',
+            },
+            quest_hint: {
+                title: 'Clue Found',
+                description: 'You notice something that might be useful for your quest.',
+            },
+        };
+        const data = eventData[selectedType];
+        if (data) {
+            const event = {
+                id: `event_${Date.now()}`,
+                type: selectedType,
+                title: data.title,
+                description: data.description,
+                timestamp: Date.now(),
+                processed: false,
+            };
+            // Add to pending events - processPendingEvents() will emit and mark as processed
+            this.state.pendingEvents.push(event);
+        }
+    }
+    /**
+     * Create a new player
+     */
+    createNewPlayer(name) {
+        return {
+            id: `player_${Date.now()}`,
+            name,
+            stats: {
+                level: 1,
+                hp: 100,
+                maxHp: 100,
+                mp: 50,
+                maxMp: 50,
+                attack: 10,
+                defense: 5,
+                speed: 10,
+                exp: 0,
+                expToNextLevel: 100,
+                gold: 50,
+            },
+            position: { x: 0, y: 0, floor: 1 },
+            equipment: {
+                weapon: null,
+                armor: null,
+                accessory: null,
+            },
+            inventory: [],
+            activeQuests: [],
+            completedQuests: [],
+            discoveredLocations: [],
+            unlockedAffixes: [],
+            createdAt: Date.now(),
+            playTime: 0,
+            // Character customization (can be filled in by player)
+            character: {
+                backstory: '',
+                appearance: '',
+                personality: '',
+                motivation: '',
+                origin: '',
+                traits: [],
+            },
+        };
+    }
+    /**
+     * Create the starting map using BSP algorithm
+     */
+    createStartingMap() {
+        // Generate a procedural dungeon with BSP
+        const map = generateMap({
+            width: 40,
+            height: 40,
+            floor: 1,
+            minRoomSize: 8,
+            maxRoomSize: 15,
+            roomTypes: [
+                { type: 'combat', weight: 40 },
+                { type: 'shop', weight: 15 },
+                { type: 'treasure', weight: 20 },
+                { type: 'event', weight: 15 },
+                { type: 'rest', weight: 5 },
+                { type: 'boss', weight: 5 },
+            ],
+        });
+        return map;
+    }
+    /**
+     * Calculate distance between two positions
+     */
+    calculateDistance(a, b) {
+        const dx = Math.abs(a.x - b.x);
+        const dy = Math.abs(a.y - b.y);
+        const df = Math.abs(a.floor - b.floor);
+        return dx + dy + df * 2; // Floor changes take longer
+    }
+    /**
+     * Get travel event title
+     */
+    getTravelEventTitle(type) {
+        const titles = {
+            resource_found: 'Discovery!',
+            enemy_encounter: 'Ambush!',
+            npc_sighting: 'A Fellow Traveler',
+        };
+        return titles[type] || 'Something happened...';
+    }
+    /**
+     * Get travel event description
+     */
+    getTravelEventDescription(type) {
+        const descriptions = {
+            resource_found: 'You found something interesting along the way.',
+            enemy_encounter: 'Enemies block your path!',
+            npc_sighting: 'You notice someone in the distance.',
+        };
+        return descriptions[type] || '';
+    }
+    // =========================================================================
+    // Event System
+    // =========================================================================
+    on(event, callback) {
+        if (!this.eventListeners.has(event)) {
+            this.eventListeners.set(event, new Set());
+        }
+        this.eventListeners.get(event).add(callback);
+    }
+    off(event, callback) {
+        this.eventListeners.get(event)?.delete(callback);
+    }
+    emit(event, data) {
+        this.eventListeners.get(event)?.forEach(cb => cb(data));
+    }
+    // =========================================================================
+    // Save/Load
+    // =========================================================================
+    save() {
+        if (!this.state)
+            return null;
+        const saveData = {
+            version: '0.1.0',
+            timestamp: Date.now(),
+            player: this.state.player,
+            currentMapId: this.state.currentMap.id,
+            currentRoomId: this.state.currentRoom.id,
+            discoveredMaps: [this.state.currentMap.id],
+            gameTime: this.state.gameTime,
+            settings: this.settings,
+        };
+        this.emit('game:saved', saveData);
+        return saveData;
+    }
+    // =========================================================================
+    // Getters
+    // =========================================================================
+    getState() {
+        return this.state;
+    }
+    getSettings() {
+        return this.settings;
+    }
+    getPhase() {
+        return this.state?.phase ?? null;
+    }
+    getPlayer() {
+        return this.state?.player ?? null;
+    }
+    getCurrentRoom() {
+        return this.state?.currentRoom ?? null;
+    }
+    getGameTime() {
+        return this.state?.gameTime ?? 0;
+    }
+    /**
+     * Update player name
+     */
+    setPlayerName(name) {
+        if (!this.state?.player)
+            return false;
+        this.state.player.name = name;
+        this.emit('player:name_changed', { name });
+        return true;
+    }
+    /**
+     * Update player character customization
+     */
+    setPlayerCharacter(character) {
+        if (!this.state?.player)
+            return false;
+        // Initialize character if not exists
+        if (!this.state.player.character) {
+            this.state.player.character = {
+                backstory: '',
+                appearance: '',
+                personality: '',
+                motivation: '',
+                origin: '',
+                traits: [],
+            };
+        }
+        // Merge provided fields
+        this.state.player.character = {
+            ...this.state.player.character,
+            ...character,
+        };
+        this.emit('player:character_updated', { character: this.state.player.character });
+        return true;
+    }
+    /**
+     * Get player character customization
+     */
+    getPlayerCharacter() {
+        return this.state?.player?.character;
+    }
+    // =========================================================================
+    // Lifecycle
+    // =========================================================================
+    pause() {
+        if (this.state) {
+            this.state.isPaused = true;
+            this.emit('game:paused', null);
+        }
+    }
+    resume() {
+        if (this.state) {
+            this.state.isPaused = false;
+            this.lastTickTime = Date.now();
+            this.emit('game:resumed', null);
+        }
+    }
+    destroy() {
+        this.stopGameLoop();
+        this.state = null;
+        this.eventListeners.clear();
+        this.emit('game:destroyed', null);
+    }
+    /**
+     * Load game state from save data
+     */
+    loadState(saveData) {
+        if (!this.state)
+            return false;
+        try {
+            // Restore player
+            this.state.player = saveData.player;
+            // Restore game time
+            this.state.gameTime = saveData.gameTime;
+            // Try to restore current room (need to regenerate map with same seed)
+            // For now, just use the current map
+            const room = this.state.currentMap.rooms.get(saveData.currentRoomId);
+            if (room) {
+                this.state.currentRoom = room;
+                this.state.player.position = { ...room.position };
+            }
+            // Reset to exploring state
+            this.state.phase = 'exploring';
+            this.state.combat = undefined;
+            this.state.travelState = undefined;
+            this.state.isPaused = false;
+            this.state.lastUpdateTime = Date.now();
+            this.emit('game:loaded', saveData);
+            return true;
+        }
+        catch (error) {
+            console.error('[Game] Failed to load state:', error);
+            return false;
+        }
+    }
+}
+//# sourceMappingURL=Game.js.map
+//# debugId=2cabfb3c-6dcf-5bd3-9b23-de27057ab179