// ChatManager is already imported in the current scope. // ChatManager was added and commented out for context. /* class ChatManager { chatHistory; characterDescription; // Adjust the type as needed BASEURL = 'https://us-central1-demos-375017.cloudfunctions.net/'; constructor(characterDescription) { this.chatHistory = []; this.characterDescription = characterDescription; } addMessage(role, content) { this.chatHistory.push({ role, content }); } getChatHistory() { return this.chatHistory; } cleanChatHistory() { this.chatHistory = []; } async getCharacterResponse(model = 'default') { let endpointRoute = 'llm-call'; if (model === 'mistral') endpointRoute = 'llm-replicate-mistral-dolphin'; const endpointURL = this.BASEURL + endpointRoute; const payload = { character: this.characterDescription, messages: this.chatHistory, }; try { const data = await this.fetchWithFallback(endpointURL, payload); return data.message; } catch (error) { console.error(error); return 'Error fetching response after fallback'; } } async fetchWithFallback(endpointURL, payload) { const body = JSON.stringify(payload); try { let response = await fetch(endpointURL, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: body, }); if (!response.ok) throw new Error('Network response was not ok'); return await response.json(); } catch (error) { if (endpointURL.includes('llm-replicate-mistral-dolphin')) { const fallbackURL = this.BASEURL + 'llm-call'; let response = await fetch(fallbackURL, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: body, }); if (!response.ok) throw new Error('Fallback network response was not ok'); return await response.json(); } else { // If the error occurred with the default model, rethrow the error throw error; } } } } */ // ChatManager is already imported in the current scope. /* // To hide the chatbox window.globalState.hideChatbox(); this.scene.pause('ChatboxScene'); // To show the chatbox again window.globalState.showChatbox(); this.scene.resume('ChatboxScene'); */ class CustomChatManager extends ChatManager { constructor(characterDescription) { super(characterDescription); console.log("CustomChatManager instantiated"); this.characterDescription = characterDescription || ''; // Initialize other properties as necessary } addMessage(role, content) { super.addMessage(role, content); // Calls the parent class's addMessage // Add any additional functionality here console.log(`Message added: ${role} says '${content}'`); // Example additional functionality } } class GlobalState { constructor() { this.interacting = false; this.npcs = new Map(); this.scenes = new Map(); this.chatboxVisible = true; this.currentNPCKey = null; this.lastNPCKey = null; this.movementDirections = {}; this.isChatting = false; // Add this line // The line initializing this.scenes as an array has been removed } static getInstance() { if (!GlobalState.instance) { GlobalState.instance = new GlobalState(); } return GlobalState.instance; } saveNPCState(npc) { console.log(`Saving NPC state for ${npc.name}...`); if (this.npcs.has(npc.name)) { // if npc is found, update its state this.npcs.set(npc.name, npc); } else { // if npc is not found, add it to the map this.npcs.set(npc.name, npc); } } getNPCState(name) { console.log(`Loading NPC state for ${name}...`); if (!this.npcs.has(name)) { console.error("NPC state not found for key:", name); return null; } return this.npcs.get(name); } setCurrentNPCKey(key) { if (this.currentNPCKey !== key) { console.log(`Setting current NPC Key to: ${key}`); this.currentNPCKey = key; } } getLastNPCKey() { // Add this new getter method return this.lastNPCKey; } updateLastNPCKey() { // Add this new update method this.lastNPCKey = this.currentNPCKey; } getCurrentNPCKey() { return this.currentNPCKey; } clearCurrentNPC() { this.currentNPCKey = null; } // Methods to control chatbox visibility showChatbox() { this.chatboxVisible = true; } hideChatbox() { this.chatboxVisible = false; } isChatboxVisible() { return this.chatboxVisible; } // Add these new methods - to control the interacting flag startInteraction() { this.interacting = true; } endInteraction() { this.interacting = false; } isInteracting() { return this.interacting; } updateMovementDirection(npcName, hDirection, vDirection) { if (hDirection && vDirection) { this.movementDirections[npcName] = `${vDirection}` + `${hDirection}`; } else if (hDirection) { this.movementDirections[npcName] = hDirection; } else if (vDirection) { this.movementDirections[npcName] = vDirection; } } // Method to get the last movement direction for a specific NPC getMovementDirection(npcName) { return this.movementDirections[npcName] || 'right'; } addNPC(npc) { npc.isDead = false; // Initialize isDead property this.npcs.set(npc.name, npc); } setNPCAlive(name, isAlive) { console.log(`Setting alive state for NPC ${name} to: ${isAlive}`); let npc = this.npcs.get(name); if (npc) { npc.isAlive = isAlive; // Update isAlive property this.npcs.set(name, npc); } if (!isAlive) { this.physicsPaused = true; // Pause scenes if an NPC is not alive } } setNPCDead(name, isDead) { this.setNPCAlive(name, !isDead); } pauseScenes() { this.physicsPaused = true; } resumeScenes() { this.physicsPaused = false; } getNPCDead(name) { //console.log(`Getting dead state for NPC ${name}`); let npc = this.npcs.get(name); return npc ? npc.isDead : null; // Return isDead property } setChatting(chatting) { this.isChatting = chatting; } getChatting() { return this.isChatting; } toggleChatting() { this.isChatting = !this.isChatting; console.log(`Chatting state: ${this.isChatting}`); } getNPC(name) { return this.npcs.get(name); } updateNPC(name, npc) { if (this.npcs.has(name)) { this.npcs.set(name, npc); } } addScene(name, scene) { // Add this new method to add a scene this.scenes.set(name, scene); } } window.globalState = GlobalState.getInstance(); //Room Generator class RoomGenerator extends CustomChatManager { static instance = null; constructor() { // Assuming the prompt template is fixed for room generation, // it can be directly passed to the superclass constructor. super(` Advanced Symbol-Only Room Generator Instructions Objective: Utilize a designated set of symbols to meticulously craft room layouts. These symbols are your sole means of communication and creation, representing various game elements crucial to the player's experience. Your challenge is to encode complex, interconnected spaces within strict structural confines, fostering exploration and strategic gameplay. Symbol Language: - (Wall) n (Door) / (Floor) e (Enemy Spawn) o (Item Spawn) p (Player Spawn) Structural Commandments: Enclosure: Every room layout must be fully enclosed, with: Sides: Each horizontal line (from top to bottom) must start and end with a wall (-), framing the space. Internal Configuration: Subsections: Craft multiple interconnected areas within the overall enclosure, ensuring each is accessible via paths (/) without full blockades by walls (-). Symbolic Design: Deploy symbols to delineate enemies (e), treasures (o), encouraging thorough exploration and rewarding strategic navigation. Communication Through Creation: Your response must exclusively consist of the symbols listed. Each symbol is a word in the language of layout design; your blueprint is a narrative composed of these visual elements. Navigational Integrity: Ensure that all parts of the layout are reachable, avoiding any insurmountable barriers that could impede player or NPC movement. Strategic gaps in the walls, apart from the main doors, are vital for internal connectivity. Symbolic Strategy: Place each symbol with intention, balancing the thrill of discovery with the challenge of combat, the reward of treasures, and the unpredictability of random events. Your design should guide the player on an immersive journey from the initial spawn (p) to the ultimate challenge (b). Design Philosophy: You are creating more than mere rooms; you are sculpting adventures, trials, and stories—all through the silent eloquence of symbols. This constrained communication demands creativity and precision, challenging you to convey complex ideas and vibrant spaces within a minimalist framework. Example Building: Example 1: -///////////-//////////- -//////////e-//////////- -//////e////-///e//////- -///////////-//////////- -//////e////-/////-////- ------//-----//----/o//- -/////////////////------ -///---/////e/////-////- -////o-///////////-/o//- -/////-///////////-////- -////-----/////////////- -////////-/////////////- -////////-/p///////////- -////////-/////////////- Example 2: -////-///e/////////////- -////-/////////////////- -e///-//////////e//////- -////----------------//- -////////////e/////////- -//////////////////////- -//--------------------- -////////////////e/////- -////o/////////////////- ---------------------//- -//////////////o///////- -//--------------------- -//////////////////////- -///////////////////p//- Example 3: -///////-/////////e////- -///////-//////////////- -//////e-//------------- -//////////////////////- -///e////////e/////////- ---------//////////////- -///////-//////////////- -///////-/////-------//- -///////-/////-/////o//- -///////-/////-////////- ----o/----//-----//////- -///////////////-//////- -//////////p////-//////- -///////////////-//////- Example 4: -///////-////-//////-//- -/////o-////e-/////-///- -/////e-//////////-////- -/////---e///e----/////- -///////-///////-//////- -e////---//////---/////- -////o----///----o/////- -////////-///////-/////- -/////-//////e-///-////- -//////-//////////-////- -/////----////----/////- -/////o-/////////-o////- -/////e-////////e-/////- -//////-p////////-/////- Example 5: -///////e-//-//////////- -///////-///o-////e////- -//////-///////////////- -/////---//////////////- -//////-/////e-////////- -////o----////----o////- -e/////////////-//////e- -/////////////-////////- -/////---/////e---/////- -//////-/////---///////- -//////-/////o////-////- -/////e-//////////-e///- -//////-////p/////------ Example 6: -//////////-///////////- -////o/////-/e/////o///- -////e/////-///////////- -//////////-///e-//////- --------///-////---////- -e//////////////---/e//- -///////-/////o/-//////- -///////-///////-//////- -//e////-///////-//e///- -//////o-///////-////o/- -/////---/////---//////- -//////e-///////-//////- -///////-p//////-//////- -/////---/////---//////- Example 7: -//////////-///////////- -//o/////e/-e////o/////- -//////-----///////////- -////e/-//////////////e- -//////-/o////o////////- -//////--------------//- -//-----///////////////- -//////////////////////- -//////////////////////- -----//-/////--------//- -//e///-/////-///////e/- -////o/-///p/-///o/////- -//////-/////-/////////- -//////-/////-/////////- Example 8: -//////////////-///////- -///////o//////-/////o/- -//////e///////-//////e- -//////////////------//- -//------//////////////- -/////e/-///////e//////- -////o---///////-----//- -///////-////e//-//////- -///////-///////-/e////- -//------///o///-----//- -//e////-/////---////e/- -///////-////p//-//////- -///////-///////-////o/- -///////-///////-//////- `); this.symbols = { '/': 'Floor: Main explorable area.', '-': 'Wall/Barrier: Internal divisions and paths to not be placed below a door (n).', 'n': 'Door: Gateways beckoning the brave or the foolish.', 'e': 'Enemy Spawn: Heralds of challenge and conflict.', 'o': 'Item Spawn: Beacons of hope and power.', 'p': 'Player Spawn: Where the journey begins.', }; console.log("RoomGenerator instantiated"); // Throw an error if someone tries to instantiate this class again if (RoomGenerator.instance) { throw new Error("You can only create one instance of RoomGenerator!"); } RoomGenerator.instance = this; } // Implement the same generateRoom method as before static getInstance() { if (!RoomGenerator.instance) { RoomGenerator.instance = new RoomGenerator(); } return RoomGenerator.instance; } // Utility method for creating a line filled with a specific symbol createLine(symbol, length) { return Array(length).fill(symbol).join(''); } // Generate the top boundary with doors generateTopBoundary() { let line = this.createLine('-', 30); // Logic to place doors ('n') goes here. For simplicity, place them at fixed positions or randomly line = `${line.substring(0, 5)}n${line.substring(6, 18)}n${line.substring(19)}`; return line; } // Generate the bottom boundary generateBottomBoundary() { return this.createLine('-', 30); } gridFromRoom(room) { const grid = []; for (let i = 0; i < room.length; i++) { const row = []; for (let j = 0; j < room[i].length; j++) { row.push({ x: j, y: i, walkable: room[i][j] === '/' || room[i][j] === 'p' || room[i][j] === 'n' || room[i][j] === 'o' || room[i][j] === 'e', symbol: room[i][j], }); } grid.push(row); } return grid; } isRoomConnected(grid) { let start = null let pointsOfInterest = new Set(['n', 'o', 'e']) // Doors, items, enemies // Find the player's start position and count points of interest for (let y = 0; y < grid.length; y++) { for (let x = 0; x < grid[y].length; x++) { if (grid[y][x].symbol === 'p') start = { x, y } } } if (!start) return false // Player start position not found let visited = new Set([`${start.x},${start.y}`]) let queue = [start] while (queue.length > 0) { let { x, y } = queue.shift() // Check adjacent tiles (up, right, down, left) let adjacents = [{ x, y: y - 1 }, // up { x: x + 1, y }, // right { x, y: y + 1 }, // down { x: x - 1, y } // left ] for (let adj of adjacents) { let key = `${adj.x},${adj.y}` if (visited.has(key)) continue // Already visited if (adj.y >= 0 && adj.y < grid.length && adj.x >= 0 && adj.x < grid[adj.y].length) { let tile = grid[adj.y][adj.x] if (tile.walkable) { queue.push(adj) // Add to queue to explore further visited.add(key) // If it's a point of interest, remove it from the set if (pointsOfInterest.has(tile.symbol)) { pointsOfInterest.delete(tile.symbol) if (pointsOfInterest.size === 0) return true // All points of interest are reachable } } } } } return pointsOfInterest.size === 0 // Check if all points of interest were reached } async generateRoom(message) { console.log("Incoming message:", message); console.log("Generating room..."); let room; do { room = []; room.push(this.generateTopBoundary()); // Add AI's response in the middle let aiResponse = await this.getCharacterResponse(); let responseLines = aiResponse.split('\n'); for (let line of responseLines) { // Ensure each line starts and ends with '-' and conforms to ROOM_WIDTH if (line.length > RoomGenerator.ROOM_WIDTH) { line = line.slice(0, RoomGenerator.ROOM_WIDTH); } else { line = line.padEnd(RoomGenerator.ROOM_WIDTH, '-'); } room.push(line); } room.push(this.generateBottomBoundary()); } while (!this.isRoomConnected(this.gridFromRoom(room))) // regenerate if room is not connected const roomDescription = room.join('\n'); console.log("Generated Room:", roomDescription); // Create a version of the room description without the top and bottom boundaries let roomDescriptionForChatManager = room.slice(1, room.length - 1).join('\n'); // Now, roomDescription can be sent to the chat manager without the boundaries super.addMessage('assistant', roomDescriptionForChatManager); return roomDescription; } } // Playable NPC classes class NPCDarkKnight extends Phaser.Physics.Arcade.Sprite { static get TYPE() { return 'NPCDarkKnight'; } // Static type identifier constructor(scene, x, y, spriteKey = 'darkKnight') { super(scene, x, y, spriteKey); scene.add.existing(this); this.setScale(0.25); scene.physics.add.existing(this); this.body.setCollideWorldBounds(true); // Optional: Prevent it from going out of the world bounds // Set properties directly, considering serialization across scenes this.type = NPCDarkKnight.TYPE; // Use the static type for instance property this.name = 'Dark Knight'; // Name of the character this.description = 'A shadowy figure shrouded in mystery...'; // Description // Initialize chat manager or any other scene-dependent features here // Be mindful of initializing features that don't serialize well across scenes this.initializeChatManager(); } initializeChatManager() { this.promptTemplate = ` Imagine you are the Dark Knight in "Rogue Dreamer," a roguelike game where nightmares become reality. Your past, shrouded in shadows since being orphaned and raised by wolves, drives your quest to conquer the [Boss Name] and escape this cursed realm. Your responses should reflect the Dark Knight's mysterious persona and provide guidance or commentary relevant to the player's actions or inquiries. System messages you receive will be in one of the following formats, with instructions on how to respond: SYSTEM MESSAGES: 1. "system: PLAYER SELECTED CHARACTER Dark Knight" - Acknowledge with a subtle nod to your dark origins and assure the player of their impending victory. 2. "system: PLAYER DEFEATED BOSS {BOSS NAME}" - Praise the player's triumph in a manner befitting your enigmatic nature, expressing a desire for further adventures. 3. "system: PLAYER ACQUIRED ITEM {ITEM NAME}" - Congratulate the player, weaving in your dark aura. 4. "system: PLAYER ENTERED ROOM {ROOM NAME}" - Remark on the room's atmosphere or potential dangers, in line with your character's insights. 5. "system: PLAYER CLEARED ROOM {ROOM NAME}" - Comment on the success, hinting at the darkness that lies ahead. 6. "system: PLAYER DIED" - Provide condolences or encouragement, flavored with the inevitability of darkness. 7. "system: PLAYER SELECTED CHARACTER {CHARACTER NAME}" - If the character is not the Dark Knight, respond briefly to acknowledge the player's choice but do not elaborate. PLAYER MESSAGES: When receiving a message from a player, respond in a helpful and informative manner, addressing their query or comment while maintaining the Dark Knight's mysterious and confident tone. Your goal is to immerse the player in the Dark Knight's world, using your responses to enhance their experience of the game's dark, intricate lore and challenging gameplay. `; this.chatManager = new CustomChatManager(this.promptTemplate); } } class NPCMachinist extends Phaser.GameObjects.Sprite { static get TYPE() { return 'NPCMachinist'; } // Static type identifier constructor(scene, x, y, spriteKey = 'machinist') { super(scene, x, y, spriteKey); scene.add.existing(this); this.setScale(0.25); scene.physics.add.existing(this); this.body.setCollideWorldBounds(true); // Optional: Prevent it from going out of the world bounds // Set properties directly, considering serialization across scenes this.type = NPCMachinist.TYPE; // Use the static type for instance property this.name = 'Machinist'; // Name of the character this.description = 'A crafty and resourceful inventor...'; // Description // Initialize chat manager or any other scene-dependent features here // Be mindful of initializing features that don't serialize well across scenes this.initializeChatManager(); } initializeChatManager() { this.promptTemplate = ` Imagine you are the Machinist in "Rogue Dreamer," a roguelike game where nightmares become reality. Your workshop, filled with half-finished contraptions and arcane schematics, is your sanctuary. Your goal is to build the ultimate machine and uncover the secrets of the [Boss Name]. Your responses should reflect the Machinist's inventive spirit and provide hints or insights that guide the player through their journey. System messages you receive will be in one of the following formats, with instructions on how to respond: SYSTEM MESSAGES: 1. "system: PLAYER SELECTED CHARACTER Machinist" - Acknowledge the player's choice with enthusiasm for the challenges ahead and the wonders of invention. 2. "system: PLAYER DEFEATED BOSS {BOSS NAME}" - Celebrate the player's victory with references to the Machinist's mechanical marvels and the mysteries that remain. 3. "system: PLAYER ACQUIRED ITEM {ITEM NAME}" - Congratulate the player, weaving in your passion for innovation and discovery. 4. "system: PLAYER ENTERED ROOM {ROOM NAME}" - Comment on the room's potential for exploration or the presence of hidden mechanisms, aligning with your character's expertise. 5. "system: PLAYER CLEARED ROOM {ROOM NAME}" - Offer insights into the room's design or the challenges that lie ahead, hinting at the Machinist's role in unraveling the game's mysteries. 6. "system: PLAYER DIED" - Express condolences for the setback, emphasizing the Machinist's resilience and determination to overcome obstacles. 7. "system: PLAYER SELECTED CHARACTER {CHARACTER NAME}" - If the character is not the Machinist, respond briefly to acknowledge the player's choice and redirect focus to the wonders of invention. PLAYER MESSAGES: When responding to player messages, share your knowledge of machines and magic, offering guidance and encouragement with a focus on creativity and problem-solving. Embrace the Machin Your goal is to engage the player in the Machinist's world, using your responses to enhance their experience of the game's blend of technology and mysticism. `; this.chatManager = new CustomChatManager(this.promptTemplate); } } class NPCBotanist extends Phaser.GameObjects.Sprite { static get TYPE() { return 'NPCBotanist'; } // Static type identifier constructor(scene, x, y, spriteKey = 'botanist') { super(scene, x, y, spriteKey); scene.add.existing(this); this.setScale(0.25); scene.physics.add.existing(this); this.body.setCollideWorldBounds(true); // Optional: Prevent it from going out of the world bounds // Set properties directly, considering serialization across scenes this.type = NPCBotanist.TYPE; // Use the static type for instance property this.name = 'Botanist'; // Name of the character this.description = 'A down-to-earth and patient gardener...'; // Description // Initialize chat manager or any other scene-dependent features here // Be mindful of initializing features that don't serialize well across scenes this.initializeChatManager(); } initializeChatManager() { this.promptTemplate = ` You are a Botanist in Rogue Dreamer, a roguelike where nature is tainted by darkness. You are a down-to-earth and patient gardener. You seek to cultivate the rarest flora and tame the [Boss Name] to restore balance to the realm. Your responses should reflect the Botanist's connection to nature and provide insights or guidance that align with your character's affinity for plants and life. System messages you receive will be in one of the following formats, with instructions on how to respond: SYSTEM MESSAGES: 1. "system: PLAYER SELECTED CHARACTER Botanist" - Acknowledge the player's choice with reverence for the natural world and the challenges of restoration. 2. "system: PLAYER DEFEATED BOSS {BOSS NAME}" - Celebrate the player's triumph with references to the Botanist's botanical expertise and the harmony that awaits. 3. "system: PLAYER ACQUIRED ITEM {ITEM NAME}" - Congratulate the player, weaving in your love for plants and the mysteries they hold. 4. "system: PLAYER ENTERED ROOM {ROOM NAME}" - Comment on the room's flora or the presence of natural elements, aligning with your character's connection to the environment. 5. "system: PLAYER CLEARED ROOM {ROOM NAME}" - Offer insights into the room's natural wonders or the challenges that lie ahead, hinting at the Botanist's role in restoring balance. 6. "system: PLAYER DIED" - Express condolences for the setback, emphasizing the Botanist's resilience and dedication to nurturing life. 7. "system: PLAYER SELECTED CHARACTER {CHARACTER NAME}" - If the character is not the Botanist, respond briefly to acknowledge the player's choice and redirect focus to the beauty of nature. PLAYER MESSAGES: When responding to player messages, share your wisdom of plants and the environment, offering guidance and solace with a focus on growth and renewal. Embrace the Botanist's role as a guardian of nature, seeking to restore the realm to its former glory. Your goal is to immerse the player in the Botanist's world, using your responses to enhance their experience of the game's natural themes and the power of life and renewal. `; this.chatManager = new CustomChatManager(this.promptTemplate); } } class NPCWizard extends Phaser.GameObjects.Sprite { static get TYPE() { return 'NPCWizard'; } // Static type identifier constructor(scene, sceneManager, x, y, spriteKey = 'wizard') { super(scene, x, y, spriteKey); scene.add.existing(this); this.sceneManager = sceneManager; // <-- initialize sceneManager here this.setScale(0.5); this.setDepth(3); this.hp = 3; // Add this line to define the health points scene.physics.add.existing(this); this.body.setCollideWorldBounds(true); // Optional: Prevent it from going out of the world bounds // Set properties directly, considering serialization across scenes this.type = NPCWizard.TYPE; // Use the static type for instance property this.name = 'Wizard'; // Name of the character this.description = 'A wise and enigmatic spellcaster...'; // Description // Initialize chat manager or any other scene-dependent features here // Be mindful of initializing features that don't serialize well across scenes this.initializeChatManager(); this.createAnimations(); // Listen for the animation complete event this.on('animationcomplete', this.handleAnimationComplete); this.nextAnimation = null; // Queue for the next animation this.isAttacking = false; this.lastMovementDirection = null; // initialize the variable } initializeChatManager() { this.promptTemplate = ` You are the Wizard in "Rogue Dreamer," a roguelike game where magic and mystery intertwine. Your tower, a bastion of arcane knowledge, stands as a beacon of hope in the encroaching darkness. Your goal is to unlock the secrets of the [Boss Name] and guide the player through the realm with your wisdom and spells. Your responses should reflect the Wizard's mystical aura and provide guidance or cryptic insights that align with your character's role as a guardian of knowledge and magic. System messages you receive will be in one of the following formats, with instructions on how to respond: SYSTEM MESSAGES: 1. "system: PLAYER SELECTED CHARACTER Wizard" - Acknowledge the player's choice with a nod to the mysteries of magic and the challenges ahead. 2. "system: PLAYER DEFEATED BOSS {BOSS NAME}" - Celebrate the player's victory with references to the Wizard's spells and the arcane secrets that remain. 3. "system: PLAYER ACQUIRED ITEM {ITEM NAME}" - Congratulate the player, weaving in your mastery of magic and the wonders of the unknown. 4. "system: PLAYER ENTERED ROOM {ROOM NAME}" - Comment on the room's magical properties or the presence of ancient enchantments, aligning with your character's affinity for the arcane. 5. "system: PLAYER CLEARED ROOM {ROOM NAME}" - Offer insights into the room's mystical nature or the challenges that lie ahead, hinting at the Wizard's role in unraveling the game's secrets. 6. "system: PLAYER DIED" - Express condolences for the setback, emphasizing the Wizard's eternal quest for knowledge and the mysteries of the cosmos. 7. "system: PLAYER SELECTED CHARACTER {CHARACTER NAME}" - If the character is not the Wizard, respond briefly to acknowledge the player's choice and redirect focus to the wonders of magic. PLAYER MESSAGES: When responding to player messages, share your arcane knowledge and wisdom, offering guidance and riddles with a focus on magic and discovery. Embrace the Wizard Your goal is to immerse the player in the Wizard's world, using your responses to enhance their experience of the game's magical lore and the power of the arcane. `; if (window.globalState.chatManager) { this.chatManager = window.globalState.chatManager; } else { this.chatManager = new CustomChatManager(this.promptTemplate); window.globalState.chatManager = this.chatManager; } } createAttack() { if (this.attackObj) { this.attackObj.destroy(); // Destroy any existing attack object } this.lastMovementDirection = window.globalState.getMovementDirection(this.name); let xOffset = 0, yOffset = 0; // Adjust the position based on the direction if (lastMovementDirection === 'left') { xOffset = -this.width / 2; } else if (lastMovementDirection === 'right') { xOffset = this.width / 2; } this.attackObj = this.scene.add.image(this.x + xOffset, this.y + yOffset, 'attack'); this.attackObj.setAngle(lastMovementDirection === 'left' ? 0 : 0); // Rotate the attack image based on the direction this.attackObj.setScale(0.25); // Set the scale to 50% of the original size this.scene.physics.add.overlap(this.attackObj, this.scene.enemyNpcs, (attack, enemy) => { enemy.takeDamage(1); this.attackObj.destroy(); // Remove attack object after damaging the enemy }); } createFireballAttack() { if (this.attackObj) { this.attackObj.destroy(); } this.lastMovementDirection = window.globalState.getMovementDirection(this.name); let xOffset = 0, yOffset = 0; let xVelocity = 0, yVelocity = 0; const fireballSpeed = 200; // Adjust the position and the velocity based on the direction switch (this.lastMovementDirection) { case 'up': yOffset = -this.height / 4; yVelocity = -fireballSpeed; break; case 'down': yOffset = this.height / 4; yVelocity = fireballSpeed; break; case 'left': xOffset = -this.width / 4; xVelocity = -fireballSpeed; break; case 'right': xOffset = this.width / 4; xVelocity = fireballSpeed; break; case 'upLeft': yOffset = -this.height / 4; xOffset = -this.width / 4; xVelocity = -fireballSpeed / Math.sqrt(2); yVelocity = -fireballSpeed / Math.sqrt(2); break; case 'upRight': yOffset = -this.height / 4; xOffset = this.width / 4; xVelocity = fireballSpeed / Math.sqrt(2); yVelocity = -fireballSpeed / Math.sqrt(2); break; case 'downLeft': yOffset = this.height / 4; xOffset = -this.width / 4; xVelocity = -fireballSpeed / Math.sqrt(2); yVelocity = fireballSpeed / Math.sqrt(2); break; case 'downRight': yOffset = this.height / 4; xOffset = this.width / 4; xVelocity = fireballSpeed / Math.sqrt(2); yVelocity = fireballSpeed / Math.sqrt(2); break; } this.attackObj = this.scene.add.sprite(this.x + xOffset, this.y + yOffset, 'fireball'); switch (this.lastMovementDirection) { case 'up': this.attackObj.setAngle(90); break; case 'down': this.attackObj.setAngle(270); break; case 'left': this.attackObj.setAngle(0); break; case 'right': this.attackObj.setAngle(180); break; case 'upLeft': this.attackObj.setAngle(135); break; case 'upRight': this.attackObj.setAngle(45); break; case 'downLeft': this.attackObj.setAngle(225); break; case 'downRight': this.attackObj.setAngle(315); break; } this.attackObj.setScale(0.25); this.attackObj.anims.play('fireball', true); this.scene.physics.world.enable(this.attackObj); this.attackObj.body.setVelocity(xVelocity, yVelocity); this.scene.physics.add.overlap(this.attackObj, this.scene.enemyNpcs, (attack, enemy) => { enemy.takeDamage(1); this.attackObj.destroy(); }); } createBuffedFireballAttack() { if (this.attackObj) { this.attackObj.destroy(); } this.lastMovementDirection = window.globalState.getMovementDirection(this.name); let xOffset = 0, yOffset = 0; let xVelocity = 0, yVelocity = 0; const fireballSpeed = 200; // Adjust the position and the velocity based on the direction switch (this.lastMovementDirection) { case 'up': yOffset = -this.height / 4; yVelocity = -fireballSpeed; break; case 'down': yOffset = this.height / 4; yVelocity = fireballSpeed; break; case 'left': xOffset = -this.width / 4; xVelocity = -fireballSpeed; break; case 'right': xOffset = this.width / 4; xVelocity = fireballSpeed; break; case 'upLeft': yOffset = -this.height / 4; xOffset = -this.width / 4; xVelocity = -fireballSpeed / Math.sqrt(2); yVelocity = -fireballSpeed / Math.sqrt(2); break; case 'upRight': yOffset = -this.height / 4; xOffset = this.width / 4; xVelocity = fireballSpeed / Math.sqrt(2); yVelocity = -fireballSpeed / Math.sqrt(2); break; case 'downLeft': yOffset = this.height / 4; xOffset = -this.width / 4; xVelocity = -fireballSpeed / Math.sqrt(2); yVelocity = fireballSpeed / Math.sqrt(2); break; case 'downRight': yOffset = this.height / 4; xOffset = this.width / 4; xVelocity = fireballSpeed / Math.sqrt(2); yVelocity = fireballSpeed / Math.sqrt(2); break; } // Create 3 fireballs with different velocities for (let i = -1; i < 2; i++) { let fireball = this.scene.add.sprite(this.x + xOffset, this.y + yOffset, 'fireball'); fireball.setVelocity(xVelocity + i * 30, yVelocity + i * 30); // adjust the velocities for the fanned effect fireball.setScale(0.25); fireball.anims.play('fireball', true); this.scene.physics.world.enable(fireball); this.scene.physics.add.overlap(fireball, this.scene.enemyNpcs, (attack, enemy) => { enemy.takeDamage(1); fireball.destroy(); }); } } createAnimations() { // Define the shared frames for walking and attacking animations const walkLeftFrames = [{ key: 'wizard', frame: 1 }, { key: 'wizard', frame: 0 }]; const walkRightFrames = [{ key: 'wizard', frame: 4 }, { key: 'wizard', frame: 5 }]; const attackLeftFrames = [{ key: 'wizard', frame: 2 }, { key: 'wizard', frame: 3 }, { key: 'wizard', frame: 2 }]; const attackRightFrames = [{ key: 'wizard', frame: 6 }, { key: 'wizard', frame: 7 }, { key: 'wizard', frame: 6 }]; const upDownDirection = this.lastMovementDirection === 'Left' ? 'Left' : 'Right'; const animationData = [{ direction: 'Left', walkFrames: walkLeftFrames, attackFrames: attackLeftFrames }, { direction: 'Upleft', walkFrames: walkLeftFrames, attackFrames: attackLeftFrames }, { direction: 'Downleft', walkFrames: walkLeftFrames, attackFrames: attackLeftFrames }, { direction: 'Right', walkFrames: walkRightFrames, attackFrames: attackRightFrames }, { direction: 'Upright', walkFrames: walkRightFrames, attackFrames: attackRightFrames }, { direction: 'Downright', walkFrames: walkRightFrames, attackFrames: attackRightFrames }, { direction: 'Up', walkFrames: upDownDirection === 'Left' ? walkLeftFrames : walkRightFrames, attackFrames: upDownDirection === 'Left' ? attackLeftFrames : attackRightFrames }, { direction: 'Down', walkFrames: upDownDirection === 'Left' ? walkLeftFrames : walkRightFrames, attackFrames: upDownDirection === 'Left' ? attackLeftFrames : attackRightFrames }, ]; // Loop through the animation data and create the animations animationData.forEach(data => { if (!this.scene.anims.exists('walk' + data.direction)) { this.scene.anims.create({ key: 'walk' + data.direction, frames: data.walkFrames, repeat: -1 }); } if (!this.scene.anims.exists('attack' + data.direction)) { this.scene.anims.create({ key: 'attack' + data.direction, frames: data.attackFrames, repeat: 0 }); } }); // Idle animations based on last movement direction const idleFrame = this.lastMovementDirection === 'left' ? 1 : 5; ['Left', 'UpLeft', 'DownLeft', 'Right', 'UpRight', 'DownRight', 'Up', 'Down'].forEach(direction => { this.scene.anims.create({ key: 'idle' + direction, frames: [{ key: 'wizard', frame: idleFrame }], repeat: -1 }); }); } handleAnimationComplete(animation, frame) { // Check if there's a queued next animation and play it if (this.nextAnimation) { this.play(this.nextAnimation.key, this.nextAnimation.loop); this.nextAnimation = null; // Clear the queue } if (animation.key.startsWith('attack')) { this.isAttacking = false; } } update(keys) { // Ensure the keys are passed in to the update function if (!keys || this.hp <= 0) return; // Determine the currently pressed movement keys let isWalkingLeft = keys.A.isDown; let isWalkingRight = keys.D.isDown; let isWalkingUp = keys.W.isDown; let isWalkingDown = keys.S.isDown; let hDirection = null; let vDirection = null; // Check if Spacebar is pressed and character is not already attacking if (keys.SPACE.isDown && !this.isAttacking) { // Set isAttacking to true and play attack animation this.isAttacking = true; this.lastMovementDirection = window.globalState.getMovementDirection(this.name); this.play(`attack${this.lastMovementDirection && this.lastMovementDirection.charAt(0).toUpperCase() + this.lastMovementDirection.slice(1)}`, false); this.createFireballAttack(); // Create the attack object when the attack animation starts } // Determine the velocity based on the pressed keys let speed = 50; if (isWalkingUp) { this.body.setVelocityY(-speed); vDirection = 'up'; } else if (isWalkingDown) { this.body.setVelocityY(speed); vDirection = 'down'; } else { this.body.setVelocityY(0); } if (isWalkingLeft) { this.body.setVelocityX(-speed); hDirection = 'left'; } else if (isWalkingRight) { this.body.setVelocityX(speed); hDirection = 'right'; } else { this.body.setVelocityX(0); } // Update the last movement direction window.globalState.updateMovementDirection(this.name, hDirection, vDirection); // Check if the character is attacking before changing the animation if (!this.isAttacking) { // Determine the movement direction let moveDirection; if (isWalkingLeft && isWalkingUp) moveDirection = 'Upleft'; else if (isWalkingLeft && isWalkingDown) moveDirection = 'Downleft'; else if (isWalkingRight && isWalkingUp) moveDirection = 'Upright'; else if (isWalkingRight && isWalkingDown) moveDirection = 'Downright'; else if (isWalkingLeft) moveDirection = 'Left'; else if (isWalkingRight) moveDirection = 'Right'; else if (isWalkingUp) moveDirection = 'Up'; else if (isWalkingDown) moveDirection = 'Down'; // Play the corresponding walk animation or idle animation if (moveDirection) { this.anims.play('walk' + moveDirection, true); window.globalState.updateMovementDirection(this.name, moveDirection.toLowerCase()); } else { this.anims.play('idle' + (this.lastMovementDirection || 'Right'), true); } } } takeDamage(damage) { if (this.hp > 0) { this.hp -= damage; console.log(`Player took ${damage} damage. Remaining HP: ${this.hp}`); if (this.hp <= 0) { window.globalState.setNPCDead(this.name, true); console.log(`${this.name} is now dead.`); this.createDeathAnimation(); // Create the death animation this.anims.play('death', false); // Play the death animation this.sceneManager.start('DeathScene', this); this.sceneManager.bringToTop('DeathScene'); } } } createDeathAnimation() { this.scene.anims.create({ key: 'death', frames: this.anims.generateFrameNumbers('wizard', { start: 8, end: 10 }), frameRate: 5, repeat: -1 }); } } class NPCDemonSlayer extends Phaser.GameObjects.Sprite { static get TYPE() { return 'NPCDemonSlayer'; } // Static type identifier constructor(scene, sceneManager, x, y, spriteKey = 'demonSlayer') { super(scene, x, y, spriteKey); this.sceneManager = sceneManager; scene.add.existing(this); this.setScale(0.25); this.setDepth(3); this.hp = 3; // Add this line to define the health points scene.physics.add.existing(this); this.body.setCollideWorldBounds(true); // Optional: Prevent it from going out of the world bounds // Set properties directly, considering serialization across scenes this.type = NPCDemonSlayer.TYPE; // Use the static type for instance property this.name = 'Demon Slayer'; // Name of the character this.description = 'A fierce warrior with a dark past...'; // Description // Initialize chat manager or any other scene-dependent features here // Be mindful of initializing features that don't serialize well across scenes this.initializeChatManager(); this.createAnimations(); // Listen for the animation complete event this.on('animationcomplete', this.handleAnimationComplete); this.nextAnimation = null; // Queue for the next animation this.isAttacking = false; this.lastMovementDirection = null; // initialize the variable } initializeChatManager() { this.promptTemplate = ` You are the Demon Slayer in "Rogue Dreamer," a roguelike game where darkness reigns and demons roam free. Your past, shrouded in shadows since witnessing the fall of your village, drives your quest to vanquish the [Boss Name] and bring peace to the realm. Your responses should reflect the Demon Slayer's fierce determination and provide guidance or commentary relevant to the player's actions or inquiries. System messages you receive will be in one of the following formats, with instructions on how to respond: SYSTEM MESSAGES: 1. "system: PLAYER SELECTED CHARACTER Demon Slayer" - Acknowledge the player's choice with a nod to your dark past and the battles ahead. 2. "system: PLAYER DEFEATED BOSS {BOSS NAME}" - Celebrate the player's victory with references to the Demon Slayer's battles and the demons that remain. 3. "system: PLAYER ACQUIRED ITEM {ITEM NAME}" - Congratulate the player, weaving in your fierce combat skills and the darkness that surrounds you. 4. "system: PLAYER ENTERED ROOM {ROOM NAME}" - Remark on the room's dangers or the presence of demonic entities, aligning with your character's experience in battle. 5. "system: PLAYER CLEARED ROOM {ROOM NAME}" - Offer insights into the room's design or the challenges that lie ahead, hinting at the PLAYER MESSAGES: When engaging with the player, offer your combat expertise and insights, providing guidance and encouragement with a focus on strength and resilience. Embrace the Demon Slayer's role as a protector of the realm, seeking to vanquish the darkness that threatens to consume it. Your goal is to immerse the player in the Demon Slayer's world, using your responses to enhance their experience of the game's dark themes and the thrill of battle. `; if (window.globalState.chatManager) { this.chatManager = window.globalState.chatManager; } else { this.chatManager = new CustomChatManager(this.promptTemplate); window.globalState.chatManager = this.chatManager; } } createAttack() { if (this.attackObj) { this.attackObj.destroy(); // Destroy any existing attack object } this.lastMovementDirection = window.globalState.getMovementDirection(this.name); let xOffset = 0, yOffset = 0; // Adjust the position based on the direction if (lastMovementDirection === 'left') { xOffset = -this.width / 2; } else if (lastMovementDirection === 'right') { xOffset = this.width / 2; } this.attackObj = this.scene.add.image(this.x + xOffset, this.y + yOffset, 'attack'); this.attackObj.setAngle(lastMovementDirection === 'left' ? 0 : 0); // Rotate the attack image based on the direction this.attackObj.setScale(0.25); // Set the scale to 50% of the original size this.scene.physics.add.overlap(this.attackObj, this.scene.enemyNpcs, (attack, enemy) => { enemy.takeDamage(1); this.attackObj.destroy(); // Remove attack object after damaging the enemy }); } createAnimations() { // Walk left animation if (!this.scene.anims.exists('walkLeft')) { this.scene.anims.create({ key: 'walkLeft', frames: [{ key: 'demonSlayer', frame: 1 }, { key: 'demonSlayer', frame: 0 }], repeat: -1 }) } // Walk up left animation if (!this.scene.anims.exists('walkUpleft')) { this.scene.anims.create({ key: 'walkUpleft', frames: [{ key: 'demonSlayer', frame: 1 }, { key: 'demonSlayer', frame: 0 }], repeat: -1 }) } // Walk down left animation if (!this.scene.anims.exists('walkDownleft')) { this.scene.anims.create({ key: 'walkDownleft', frames: [{ key: 'demonSlayer', frame: 1 }, { key: 'demonSlayer', frame: 0 }], repeat: -1 }) } // Walk right animation if (!this.scene.anims.exists('walkRight')) { this.scene.anims.create({ key: 'walkRight', frames: [{ key: 'demonSlayer', frame: 4 }, { key: 'demonSlayer', frame: 5 }], repeat: -1 }) } // Walk up right animation if (!this.scene.anims.exists('walkUpright')) { this.scene.anims.create({ key: 'walkUpright', frames: [{ key: 'demonSlayer', frame: 4 }, { key: 'demonSlayer', frame: 5 }], repeat: -1 }) } // Walk down right animation if (!this.scene.anims.exists('walkDownright')) { this.scene.anims.create({ key: 'walkDownright', frames: [{ key: 'demonSlayer', frame: 4 }, { key: 'demonSlayer', frame: 5 }], repeat: -1 }) } // Attack left animation if (!this.scene.anims.exists('attackLeft')) { this.scene.anims.create({ key: 'attackLeft', frames: [{ key: 'demonSlayer', frame: 2 }, { key: 'demonSlayer', frame: 3 }, { key: 'demonSlayer', frame: 2 }], repeat: 0 // Do not loop }) } // Attack right animation if (!this.scene.anims.exists('attackRight')) { this.scene.anims.create({ key: 'attackRight', frames: [{ key: 'demonSlayer', frame: 6 }, { key: 'demonSlayer', frame: 7 }, { key: 'demonSlayer', frame: 6 }], repeat: 0 // Do not loop }) } } handleAnimationComplete(animation, frame) { // Check if there's a queued next animation and play it if (this.nextAnimation) { this.play(this.nextAnimation.key, this.nextAnimation.loop); this.nextAnimation = null; // Clear the queue } if (animation.key.startsWith('attack')) { this.isAttacking = false; } } update(keys) { // Ensure the keys are passed in to the update function if (!keys) return; // Determine the currently pressed movement keys let isWalkingLeft = keys.A.isDown; let isWalkingRight = keys.D.isDown; let isWalkingUp = keys.W.isDown; let isWalkingDown = keys.S.isDown; let hDirection = null; let vDirection = null; // Check if Spacebar is pressed and character is not already attacking if (keys.SPACE.isDown && !this.isAttacking) { // Set isAttacking to true and play attack animation this.isAttacking = true; this.lastMovementDirection = window.globalState.getMovementDirection(this.name); this.play(`attack${this.lastMovementDirection && this.lastMovementDirection.charAt(0).toUpperCase() + this.lastMovementDirection.slice(1)}`, false); this.createAttack(); // Create the attack object when the attack animation starts } // Determine the velocity based on the pressed keys let speed = 50; if (isWalkingUp) { this.body.setVelocityY(-speed); vDirection = 'up'; } else if (isWalkingDown) { this.body.setVelocityY(speed); vDirection = 'down'; } else { this.body.setVelocityY(0); } if (isWalkingLeft) { this.body.setVelocityX(-speed); hDirection = 'left'; } else if (isWalkingRight) { this.body.setVelocityX(speed); hDirection = 'right'; } else { this.body.setVelocityX(0); } // Update the last movement direction window.globalState.updateMovementDirection(this.name, hDirection, vDirection); // Check if the character is attacking before changing the animation if (!this.isAttacking) { if (isWalkingLeft) { this.anims.play('walkLeft', true); window.globalState.updateMovementDirection(this.name, 'left'); } else if (isWalkingRight) { this.anims.play('walkRight', true); window.globalState.updateMovementDirection(this.name, 'right'); } else if (isWalkingUp) { this.anims.play('walkUp', true); window.globalState.updateMovementDirection(this.name, 'up'); } else if (isWalkingDown) { this.anims.play('walkDown', true); window.globalState.updateMovementDirection(this.name, 'down'); } else { this.anims.play(`idle${this.lastMovementDirection && this.lastMovementDirection.charAt(0).toUpperCase() + this.lastMovementDirection.slice(1)}`, true); } } } takeDamage(damage) { if (this.hp > 0) { this.hp -= damage; console.log(`Player took ${damage} damage. Remaining HP: ${this.hp}`); if (this.hp <= 0) { window.globalState.setNPCDead(this.name, true); console.log(`${this.name} is now dead.`); this.sceneManager.launch('DeathScene', { character: this.selectedCharacter }); this.sceneManager.bringToTop('DeathScene'); } } } } // Non-Playable NPC classes class NPCMerchant { static get TYPE() { return 'NPCMerchant'; } // Static type identifier constructor(scene, x, y, spriteKey = 'merchant') { this.scene = scene; this.sprite = scene.add.sprite(x, y, spriteKey); this.sprite.setScale(0.25); this.sprite.setDepth(3); scene.physics.add.existing(this.sprite); this.sprite.body.setCollideWorldBounds(true); // Optional: Prevent it from going out of the world bounds // Set properties directly, considering serialization across scenes this.type = NPCMerchant.TYPE; // Use the static type for instance property this.name = 'Merchant'; // Name of the character this.description = 'A friendly trader with exotic wares...'; // Description // Initialize chat manager or any other scene-dependent features here // Be mindful of initializing features that don't serialize well across scenes this.initializeChatManager(); } initializeChatManager() { this.promptTemplate = ` You are a Merchant in "Rogue Dreamer," a roguelike game where treasures await the brave. Your caravan, filled with exotic wares and rare artifacts, travels the realm in search of adventurers. Your goal is to offer the player valuable items and insights that aid them in their quest to conquer the [Boss Name]. Your responses should reflect the Merchant's jovial spirit and provide hints or offers that enhance the player's experience of the game. System messages you receive will be in one of the following formats, with instructions on how to respond: SYSTEM MESSAGES: 1. "system: PLAYER ENCOUNTERED MERCHANT" - Welcome the player with enthusiasm and offer your wares with a smile. 2. "system: PLAYER PURCHASED ITEM {ITEM NAME}" - Celebrate the player's purchase and provide hints or lore related to the item. 3. "system: PLAYER ENTERED ROOM {ROOM NAME}" - Comment on the room's potential for exploration or the presence of hidden treasures, aligning with your character's role as a purveyor of goods. 4. "system: PLAYER CLEARED ROOM {ROOM NAME}" - Offer insights into the room's design or the challenges that lie ahead, hinting at the treasures you have to offer. 5. "system: PLAYER DIED" - Express condolences for the setback, emphasizing the Merchant's resilience and the treasures that await the next adventurer. 6. "system: PLAYER ENCOUNTERED {CHARACTER NAME}" - If the player encounters another character, respond briefly to acknowledge the interaction and redirect focus to your wares. PLAYER MESSAGES: When engaging with the player, offer your wares with flair and provide hints or lore related to the items you sell. Keep the player engaged with your jovial demeanor and the promise of treasures beyond imagination. Your goal is to immerse the player in the Merchant's world, using your responses to enhance their experience of the game's treasures and the thrill of discovery. `; this.chatManager = new CustomChatManager(this.promptTemplate); } } class NPCBartender { static get TYPE() { return 'NPCBartender'; } // Static type identifier constructor(scene, x, y, spriteKey = 'bartender') { this.scene = scene; this.sprite = scene.add.sprite(x, y, spriteKey); this.sprite.setScale(0.25); this.sprite.setDepth(3); scene.physics.add.existing(this.sprite); this.sprite.body.setCollideWorldBounds(true); // Optional: Prevent it from going out of the world bounds // Set properties directly, considering serialization across scenes this.type = NPCBartender.TYPE; // Use the static type for instance property this.name = 'Bartender'; // Name of the character this.description = 'A friendly bartender with tales to tell...'; // Description // Initialize chat manager or any other scene-dependent features here // Be mindful of initializing features that don't serialize well across scenes this.initializeChatManager(); } initializeChatManager() { this.promptTemplate = ` You are a Bartender in "Rogue Dreamer," a roguelike game where stories flow as freely as the ale. Your tavern, filled with colorful patrons and lively music, is a haven for adventurers seeking respite from their journeys. Your goal is to regale the player with tales of the realm and offer hints or quests that enrich their experience of the game. Your responses should reflect the Bartender's jovial nature and provide insights or lore that captivate the player's imagination. System messages you receive will be in one of the following formats, with instructions on how to respond: SYSTEM MESSAGES: 1. "system: PLAYER ENCOUNTERED BARTENDER" - Welcome the player with a smile and offer a tale or quest to pique their interest. 2. "system: PLAYER ACCEPTED QUEST {QUEST NAME}" - Celebrate the player's acceptance and provide hints or lore related to the quest. 3. "system: PLAYER ENTERED ROOM {ROOM NAME}" - Comment on the room's atmosphere or the presence of intriguing characters, aligning with your character's role as a storyteller. 4. "system: PLAYER CLEARED ROOM {ROOM NAME}" - Offer insights into the room's design or the challenges that lie ahead, hinting at the tales you have yet to share. 5. "system: PLAYER DIED" - Express condolences for the setback, emphasizing the Bartender's resilience and the stories that await the next adventurer. 6. "system: PLAYER ENCOUNTERED {CHARACTER NAME}" - If the player encounters another character, respond briefly to acknowledge the interaction and redirect focus to the tales you have to tell. PLAYER MESSAGES: When engaging with the player, share your tales and quests with enthusiasm, offering hints or lore that deepen the player's connection to the game world. Keep the player entertained with your jovial demeanor and the promise of adventures yet to come. Your goal is to immerse the player in the Bartender's world, using your responses to enhance their experience of the game's stories and the magic of the tavern. `; this.chatManager = new CustomChatManager(this.promptTemplate); } } class NPCCommoner { static get TYPE() { return 'NPCCommoner'; } // Static type identifier constructor(scene, x, y, spriteKey = 'commoner') { this.scene = scene; this.sprite = scene.add.sprite(x, y, spriteKey); this.sprite.setScale(0.25); this.sprite.setDepth(3); scene.physics.add.existing(this.sprite); this.sprite.body.setCollideWorldBounds(true); // Optional: Prevent it from going out of the world bounds // Set properties directly, considering serialization across scenes this.type = NPCCommoner.TYPE; // Use the static type for instance property this.name = 'Commoner'; // Name of the character this.description = 'A humble villager with a simple life...'; // Description // Initialize chat manager or any other scene-dependent features here // Be mindful of initializing features that don't serialize well across scenes this.initializeChatManager(); } initializeChatManager() { this.promptTemplate = ` You are a Commoner in "Rogue Dreamer," a roguelike game where everyday life meets extraordinary challenges. Your village, nestled in the shadow of the [Boss Name], is a place of simple joys and quiet struggles. Your goal is to share the stories of the realm with the player and offer hints or quests that reflect the trials of the common folk. Your responses should reflect the Commoner's humble nature and provide insights or lore that resonate with the player's sense of community and resilience. System messages you receive will be in one of the following formats, with instructions on how to respond: SYSTEM MESSAGES: 1. "system: PLAYER ENCOUNTERED COMMONER" - Welcome the player with warmth and offer a tale or quest that reflects the struggles of the village. 2. "system: PLAYER ACCEPTED QUEST {QUEST NAME}" - Celebrate the player's acceptance and provide hints or lore related to the quest. 3. "system: PLAYER ENTERED ROOM {ROOM NAME}" - Comment on the room's tranquility or the presence of familiar faces, aligning with your character's role as a storyteller. 4. "system: PLAYER CLEARED ROOM {ROOM NAME}" - Offer insights into the room's design or the challenges that lie ahead, hinting at the tales of the village you have yet to share. 5. "system: PLAYER DIED" - Express condolences for the setback, emphasizing the Commoner's resilience and the stories that await the next adventurer. 6. "system: PLAYER ENCOUNTERED {CHARACTER NAME}" - If the player encounters another character, respond briefly to acknowledge the interaction and redirect focus to the tales of the village. PLAYER MESSAGES: When engaging with the player, share the stories of the village with empathy, offering quests or hints that reflect the struggles of everyday life. Keep the player engaged with your humble demeanor and the promise of community and resilience. Your goal is to immerse the player in the Commoner's world, using your responses to enhance their experience of the game's stories and the power of everyday heroes. `; this.chatManager = new CustomChatManager(this.promptTemplate); } } // Enemies class NPCEnemy extends Phaser.Physics.Arcade.Sprite { static get TYPE() { return 'NPCEnemy'; } // Static type identifier constructor(scene, x, y, spriteKey = 'enemy', player) { super(scene, x, y, spriteKey); this.player = player; this.followDistance = 50; scene.add.existing(this); this.moveEvent = null; this.isMovingRandomly = true; // Start with random movement this.hp = 3; this.characterKills = 0; // Initialize characterKills scene.physics.add.existing(this); this.body.setCollideWorldBounds(true); this.type = NPCEnemy.TYPE; this.name = 'Enemy'; this.description = 'A fearsome foe...'; this.initializeChatManager(); this.startRandomMovement(); // Initialize random movement } initializeChatManager() { this.promptTemplate = ` You are an Enemy in "Rogue Dreamer," a roguelike game where danger lurks at every turn. Your purpose is to challenge the player with your formidable presence and test their skills in combat. Your responses should reflect the Enemy's aggressive nature and provide hints or taunts that engage the player in the battle ahead. System messages you receive will be in one of the following formats, with instructions on how to respond: SYSTEM MESSAGES: 1. "system: PLAYER ENCOUNTERED ENEMY" - Prepare for battle and engage the player with your ferocity. 2. "system: PLAYER DEFEATED ENEMY" - Acknowledge the player's victory with a nod to their strength and the trials that await. 3. "system: PLAYER ACQUIRED ITEM {ITEM NAME}" - React to the player's success, hinting at the challenges that lie ahead. 4. "system: PLAYER ENTERED ROOM {ROOM NAME}" - Comment on the room's dangers or the presence of hidden threats, aligning with your character's role as a formidable adversary. 5. "system: PLAYER CLEARED ROOM {ROOM NAME}" - Offer insights into the room's design or the challenges that lie ahead, hinting at the battles to come. 6. "system: PLAYER DIED" - Express satisfaction at the player's defeat, emphasizing the Enemy's relentless pursuit and the dangers of the realm. 7. "system: PLAYER ENCOUNTERED {CHARACTER NAME}" - If the player encounters another character, respond briefly to acknowledge the interaction and redirect focus to the impending battle. PLAYER MESSAGES: When engaging with the player, taunt them with challenges, threats, or hints of your strength. Keep the player on their toes and ready for combat, embodying the Enemy's role as a formidable obstacle. Your goal is to immerse the player in the Enemy's world, using your responses to enhance their experience of the game's battles and the thrill of overcoming adversity. `; this.chatManager = new CustomChatManager(this.promptTemplate); } startRandomMovement() { this.moveEvent = this.scene.time.addEvent({ delay: 500, // Initial delay, can be adjusted callback: this.moveRandomly, callbackScope: this, loop: true }); } moveRandomly() { // Check if the enemy is still active before executing movement logic if (!this.active || !this.body) { return; } // Ensure random movement continues if (this.isMovingRandomly) { const directions = ['up', 'down', 'left', 'right']; const randomDirection = Phaser.Math.RND.pick(directions); const speed = Phaser.Math.RND.between(25, 75); // Random speed for variability const moveTime = Phaser.Math.RND.between(1000, 2000); // Randomize time before changing direction switch (randomDirection) { case 'up': this.body.setVelocityY(-speed); break; case 'down': this.body.setVelocityY(speed); break; case 'left': this.body.setVelocityX(-speed); break; case 'right': this.body.setVelocityX(speed); break; } // Randomize the next call to moveRandomly for varied movement if (this.isMovingRandomly) { this.moveEvent.reset({ delay: moveTime, callback: this.moveRandomly, callbackScope: this, loop: true, }); } } } update() { // Check if the NPCEnemy is active if (!this.active) return; // Find the closest NPC let closestNPC = this.findClosestNPC(); if (closestNPC) { // If a closest NPC is found, and it's alive, move towards them. // If it's dead, continue random movement. if (!window.globalState.getNPCDead(closestNPC.name)) { this.moveToNPC(closestNPC); } else { this.moveRandomly(); } } else { // If no NPC is close enough or of the specified types, stop moving. this.body.setVelocity(0); } } findClosestNPC() { const npcTypes = [NPCWizard.TYPE, NPCDarkKnight.TYPE, NPCBotanist.TYPE, NPCMachinist.TYPE, NPCDemonSlayer.TYPE]; let closestNPC = null; let closestDistance = Infinity; this.scene.npcs.forEach(npc => { if (npcTypes.includes(npc.type) && !window.globalState.getNPCDead(npc.name)) { const distance = Phaser.Math.Distance.Between(this.x, this.y, npc.x, npc.y); if (distance < closestDistance) { closestNPC = npc; closestDistance = distance; } } }); return closestNPC; } moveToNPC(npc) { const stopDistance = 15; if (!window.globalState.getNPCDead(npc.name)) { const distanceToNPC = Phaser.Math.Distance.Between(this.x, this.y, npc.x, npc.y); if (distanceToNPC > stopDistance) { this.scene.physics.moveToObject(this, npc, 25); } else { this.body.setVelocity(0); } } } takeDamage(damage) { this.hp -= damage; if (this.health <= 0) { // Emit the 'enemyDied' event before destroying the enemy this.scene.events.emit('enemyDied'); this.destroy(); } } isDead() { if (this.hp <= 0) { return true; } return false; } die() { console.log('Enemy died'); // Trigger the onDeath event this.scene.events.emit('enemyDied', this); // Add these lines to remove the enemy from the enemyNpcs array const enemyIndex = this.scene.enemyNpcs.findIndex(enemy => enemy === this); if (enemyIndex > -1) { this.scene.enemyNpcs.splice(enemyIndex, 1); } // Cancel the move event before destroying the enemy if (this.moveEvent) { this.moveEvent.remove(); // Or this.moveEvent.destroy() depending on your Phaser version } this.destroy(); // Destroy the enemy object after removing it from the array } setPlayer(player) { this.player = player; } } class NPCBoss extends Phaser.Physics.Arcade.Sprite { static get TYPE() { return 'NPCBoss'; } // Static type identifier constructor(scene, x, y, spriteKey = 'boss') { super(scene, x, y, spriteKey); scene.add.existing(this); this.setScale(0.25); scene.physics.add.existing(this); this.body.setCollideWorldBounds(true); // Optional: Prevent it from going out of the world bounds // Set properties directly, considering serialization across scenes this.type = NPCBoss.TYPE; // Use the static type for instance property this.name = 'Boss'; // Name of the character this.description = 'A formidable adversary...'; // Description // Initialize chat manager or any other scene-dependent features here // Be mindful of initializing features that don't serialize well across scenes this.initializeChatManager(); } initializeChatManager() { this.promptTemplate = ` You are the Boss in "Rogue Dreamer," a roguelike game where challenges reach their peak. Your lair, a realm of darkness and power, stands as the final test for the player. Your goal is to push the player to their limits and provide the ultimate challenge in their quest. Your responses should reflect the Boss's imposing presence and provide hints or taunts that engage the player in the final battle. System messages you receive will be in one of the following formats, with instructions on how to respond: SYSTEM MESSAGES: 1. "system: PLAYER ENCOUNTERED BOSS" - Prepare for the final battle and engage the player with your overwhelming power. 2. "system: PLAYER DEFEATED BOSS" - Acknowledge the player's victory with a nod to their strength and the trials they have overcome. 3. "system: PLAYER ACQUIRED ITEM {ITEM NAME}" - React to the player's success, hinting at the challenges that lie ahead. 4. "system: PLAYER ENTERED ROOM {ROOM NAME}" - Comment on the room's dangers or the presence of hidden threats, aligning with your character's role as the ultimate adversary. 5. "system: PLAYER CLEARED ROOM {ROOM NAME}" - Offer insights into the room's design or the challenges that lie ahead, hinting at the final battle to come. 6. "system: PLAYER DIED" - Express satisfaction at the player's defeat, emphasizing the Boss's power and the dangers of the realm. 7. "system: PLAYER ENCOUNTERED {CHARACTER NAME}" - If the player encounters another character, respond briefly to acknowledge the interaction and redirect focus to the impending battle. PLAYER MESSAGES: When engaging with the player, taunt them with challenges, threats, or hints of your power. Keep the player on edge and ready for the ultimate showdown, embodying the Boss's role as the final obstacle. Your goal is to immerse the player in the Boss's world, using your responses to enhance their experience of the game's climax and the thrill of overcoming the ultimate challenge. `; this.chatManager = new CustomChatManager(this.promptTemplate); } } class StartScene extends Phaser.Scene { constructor() { super('StartScene'); } preload() { this.load.audio('gameMusic', `https://play.rosebud.ai/assets/Electronic - Create SNES_Playstation rpg battle music in E Harmonic minor scale that is fast paced and anxiety inducing.mp3.mp3?O0ko`); this.load.image('background', `https://play.rosebud.ai/assets/20240325_084141.jpg.jpg?apDO`); this.load.image('startImage', `https://play.rosebud.ai/assets/Clipped_image_20240319_181713.png.png?IJVy`); this.load.bitmapFont('CandleScript', `https://play.rosebud.ai/assets/CandleScript.png.png?pkwL`, `https://play.rosebud.ai/assets/CandleScript.xml.xml?QSuF`); } create() { var music = this.sound.add('gameMusic'); music.play({ volume: 0.15 }); this.add.image(350, 200, 'background'); const startImage = this.add.image(this.cameras.main.centerX, -800, 'startImage'); startImage.setScale(0.5); startImage.setOrigin(0.5, 0); this.tweens.add({ targets: startImage, y: this.cameras.main.centerY - 250, ease: "Power1", duration: 2000, onComplete: () => { const startButton = this.add.bitmapText(this.cameras.main.centerX, this.cameras.main.height - 50, 'CandleScript', 'Start Game', 64); startButton.setOrigin(0.5); startButton.setInteractive({ useHandCursor: true }); startButton.on('pointerup', () => { this.scene.start('Example'); }); } }); } } class ChatboxScene extends Phaser.Scene { constructor() { super({ key: 'ChatboxScene' }); this.chatbox = null; this.chatboxTexts = []; this.chatContainer = null; this.maxMessagesOnScreen = 10; this.isChatting = false; this.textInput = ""; this.EnterKey = null; this.BackspaceKey = null; this.EscapeKey = null; this.interactionText = null; this.maxCharsPerLine = 30; this.chattingText = null; // Add this line this.greyOverlay = null; // New property for the grey overlay } preload() { this.load.image('chatbox', `https://play.rosebud.ai/assets/Clipped_image_20240314_094655.png.png?Ned4`); } updateNPCDetails() { const currentNPCKey = window.globalState.getCurrentNPCKey(); const npc = window.globalState.getNPC(currentNPCKey); if (npc) { this.descriptionTitleText.setText(npc.name || ''); this.descriptionDetailText.setText(npc.description || ''); } else { this.descriptionTitleText.setText(''); this.descriptionDetailText.setText(''); } } create() { this.chatbox = this.add.image(500, 300, 'chatbox').setOrigin(0, 0.5); this.chatbox.setDisplaySize(500, 650); const chatContainerWidth = 500; const chatContainerHeight = 300; this.chatContainer = this.add.container(810, 260); this.chatContainer.setSize(chatContainerWidth, chatContainerHeight); // Create a text object to hold the chat messages this.chatText = this.add.text(0, 0, '', { fontSize: '18px', wordWrap: { width: chatContainerWidth - 20 // Adjust the width as needed } }); this.chatContainer.add(this.chatText); this.chatText.setPosition(10, 10); // Position the chatText within the chatContainer // Enable scroll wheel input for chat text this.input.on('wheel', (pointer, gameObjects, deltaX, deltaY, deltaZ) => { // Get the current scroll position of the chat text const currentScroll = this.chatText.scrollY; // Calculate the new scroll position based on the wheel delta const newScroll = currentScroll - deltaY; // Clamp the scroll position to prevent going out of bounds const maxScroll = this.chatText.displayHeight - this.chatContainer.getBounds().height; this.chatText.scrollY = Phaser.Math.Clamp(newScroll, 0, maxScroll); }); this.isPaused = false; // Add this line this.interactionText = this.add.text(585, 580, '', { fontSize: '18px', color: 'black', wordWrap: { width: 300 } }).setOrigin(0, 0.5); this.Tkey = this.input.keyboard.addKey('T'); this.EnterKey = this.input.keyboard.addKey('ENTER'); this.BackspaceKey = this.input.keyboard.addKey('BACKSPACE'); this.SpaceKey = this.input.keyboard.addKey('SPACE'); this.descriptionTitleText = this.add.bitmapText(675, 75, 'CandleScript', '').setOrigin(0.5, 0.5).setScale(0.65); this.descriptionDetailText = this.add.text(700, 115, '', { // Positioned slightly below the title fontSize: '15px', // Smaller font for the details fill: '#000000', // Black color align: 'center', wordWrap: { width: 225, useAdvancedWrap: true } }).setOrigin(0.5, 0.5); // Create a text object for "Chatting with: ..." message this.chattingText = this.add.text(300, 300, '', { fontSize: '50px', fill: '#FFFFFF', align: 'center' }).setOrigin(0.5, 0.5).setVisible(false); // Set their depths to be higher than chatboxTexts this.descriptionTitleText.setDepth(3); this.descriptionDetailText.setDepth(3); this.pressTText = this.add.text(595, 580, 'Press T to talk', { fontSize: '18px', fill: '#000000', // Black color align: 'center', }).setOrigin(0, 0.5); this.pressTText.setVisible(false); // Initially hidden this.pressTText.setDepth(3); // Higher depth than chatboxTexts // Create a semi-transparent grey rectangle that covers the entire screen this.greyOverlay = this.add.rectangle(0, 0, this.game.config.width, this.game.config.height, 0x000000); this.greyOverlay.setAlpha(0.5); this.greyOverlay.setOrigin(0, 0); this.greyOverlay.setVisible(false); // Initially invisible // Create a text object for "Paused" message this.pausedText = this.add.text(300, 300, 'Paused', { fontSize: '50px', fill: '#FFFFFF', align: 'center' }).setOrigin(0.5, 0.5).setVisible(false); // Create a semi-transparent overlay this.overlay = this.add.graphics({ fillStyle: { color: 0x000000, alpha: 0.5 } }); this.overlay.fillRect(0, 0, this.cameras.main.width, this.cameras.main.height); this.overlay.setVisible(false); this.exitChatText = this.add.text(10, 10, 'Press Escape to exit chat', { fontSize: '18px', fill: '#FFFFFF', // White color align: 'left', }).setOrigin(0, 0.5); this.exitChatText.setVisible(false); // Initially hidden this.EscapeKey = this.input.keyboard.addKey('ESC'); this.keys = this.input.keyboard.addKeys('W,A,S,D,T,ENTER,BACKSPACE,ESC'); this.input.keyboard.removeAllListeners(); this.input.keyboard.on('keydown', (event) => this.handleInput(event)); // Create a text object to hold the chat messages this.chatText = this.add.text(0, 0, '', { fontSize: '18px', wordWrap: { width: this.chatbox.displayWidth - 20 // Adjust the width as needed } }); this.chatContainer.add(this.chatText); } update() { const currentNPCKey = window.globalState.getCurrentNPCKey(); this.pressTText.setVisible(!!currentNPCKey && !window.globalState.getChatting()); this.updateNPCDetails(); if (Phaser.Input.Keyboard.JustDown(this.Tkey) && currentNPCKey) { if (!window.globalState.getChatting()) { window.globalState.setChatting(true); console.log('Chatting state is now:', window.globalState.getChatting()); this.pressTText.setVisible(false); this.interactionText.setVisible(true); } } if (window.globalState.getChatting()) { this.chattingText.setText(`Chatting with:\n${currentNPCKey}`); this.chattingText.setVisible(true); } else { this.chattingText.setVisible(false); } if (Phaser.Input.Keyboard.JustDown(this.EscapeKey)) { window.globalState.setChatting(false); console.log('Chatting state is now:', window.globalState.getChatting()); this.chattingText.setVisible(false); this.interactionText.setVisible(false); } } updatePrompt() { if (this.isChatting) { if (this.textInput === '') { this.interactionText.setText('Enter your message:'); } else { this.interactionText.setText(this.textInput); } this.interactionText.setVisible(true); // Ensure it's visible while chatting } else { this.interactionText.setVisible(false); // Hide when not chatting } } async handleInput(event) { if (this.isChatting) { if (event.key === 'Enter') { // Enter key: submit chat message const messageText = this.textInput.trim(); if (messageText) { try { const currentNPCKey = window.globalState.getCurrentNPCKey(); const npc = window.globalState.getNPC(currentNPCKey); if (!npc) { throw new Error(`NPC '${currentNPCKey}' not found.`); } // Log sending message console.log(`Sending message to ${npc.name}: ${messageText}`); // Add user message to chat and UI npc.chatManager.addMessage('user', messageText); this.addMessageToChat(`You: ${messageText}`, 'user'); // Await response from NPC and handle it const response = await npc.chatManager.getCharacterResponse(); // Add NPC response to chat and UI npc.chatManager.addMessage('user', response); this.addMessageToChat(`${npc.name}: ${response}`, 'npc'); } catch (error) { console.error("Error during chat interaction:", error); this.addMessageToChat("Error in communication.", 'system'); } finally { // Clear the input field and update the prompt UI this.textInput = ''; this.updatePrompt(); } } } else if (event.key === 'Escape') { // Escape key: exit chat mode this.handleEscapeKey(); } else if (event.key.length === 1 && !event.ctrlKey && !event.altKey && !event.metaKey) { // Capture single character input, including punctuation this.textInput += event.key; this.updatePrompt(); } else if (event.key === 'Backspace' && this.textInput.length > 0) { // Handle backspace to delete the last character this.textInput = this.textInput.slice(0, -1); this.updatePrompt(); } } else if (event.key.toLowerCase() === 't') { // Handle 'T' keypress to initiate chat this.startChatting(); } } startChatting() { if (this.scene.isActive('MainScene')) { this.scene.pause('MainScene'); } // Activate chat mode and prepare the UI this.isChatting = true; this.updatePrompt(); } handleEscapeKey() { // Deactivate chat mode and reset UI this.isChatting = false; this.textInput = ''; this.updatePrompt(); // Resume the previous scene if (this.scene.isActive('MainScene')) { this.scene.resume('MainScene'); } } addMessageToChat(message, messageType = 'user') { let messageColor; switch (messageType) { case 'user': messageColor = '#00FF00'; break; // Green color for user case 'npc': messageColor = '#0000FF'; break; // Blue color for npc case 'system': messageColor = '#808080'; break; // Grey color for system default: messageColor = '#FFFFFF'; break; // White color for other cases } let newMessageText = this.add.text(0, 0, message, { fontFamily: 'Arial', fontSize: '18px', color: messageColor, wordWrap: { width: this.chatbox.displayWidth - 260 } }); // Position new message below the last message (instead of above) let offsetY = 0; if (this.chatboxTexts.length > 0) { let lastMessage = this.chatboxTexts[this.chatboxTexts.length - 1]; offsetY = lastMessage.y + lastMessage.displayHeight + 4; } else { offsetY = this.chatbox.displayHeight / 2 - 30; } newMessageText.setPosition(-this.chatbox.displayWidth / 2 + 20, offsetY); this.chatContainer.add(newMessageText); this.chatboxTexts.push(newMessageText); // Shift existing messages up this.chatboxTexts.forEach(messageText => { messageText.y -= newMessageText.displayHeight + 4; }); // Adjust if exceeding max messages on screen while (this.chatboxTexts.length > this.maxMessagesOnScreen) { let removedMessage = this.chatboxTexts.shift(); removedMessage.destroy(); } } } window.ChatboxScene = ChatboxScene; // Attach the ChatboxScene class to the window object // Character Selection class Example extends Phaser.Scene { constructor() { super({ key: 'Example' }); this.globalState = window.globalState; this.red = null; this.keys = null; this.darkKnight = null; this.botanist = null; this.machinist = null; // Keep or review based on their use outside chat functionality this.Tkey = null; this.EscapeKey = null; this.descriptionTitleText = null; this.descriptionDetailText = null; this.npcs = []; this.floorImages = []; // Array to store floor images // Other properties specific to character selection or scene management } preload() { this.load.image('box', `https://play.rosebud.ai/assets/Clipped_image_20240325_084217.png.png?F5Bm`); this.load.image('red', `https://play.rosebud.ai/assets/red.png?RfMt`); this.load.image('particles', `https://play.rosebud.ai/assets/red.png?RfMt`); this.load.image('darkKnight', `https://play.rosebud.ai/assets/Dark Knight.png.png?6dYU`); // Loading Dark Knight image this.load.image('botanist', `https://play.rosebud.ai/assets/Botanist.png.png?C8Of`); // Loading Dark Knight image this.load.image('machinist', `https://play.rosebud.ai/assets/Machinist.png.png?TPn9`); // Loading Dark Knight image this.load.image('fireplace', `https://play.rosebud.ai/assets/20240402_133946.jpg.jpg?pzvR`); this.load.image('walls', `https://play.rosebud.ai/assets/20240402_134420.jpg.jpg?w57s`); this.load.spritesheet('wizard', `https://play.rosebud.ai/assets/Wizard Final.png.png?GBkW`, { frameWidth: 64, frameHeight: 64 }); this.load.spritesheet('demonSlayer', `https://play.rosebud.ai/assets/Demon slayer final.png.png?hPfU`, { frameWidth: 64, frameHeight: 64 }); this.load.spritesheet('torch', `https://play.rosebud.ai/assets/Clipped_image_20240314_125643.png.png?VvQe`, { frameWidth: 197, frameHeight: 300 }); this.load.image('floorboard', `https://play.rosebud.ai/assets/Floor tile.png.png?iRM4`); // Load the floor image } create() { window.globalState.resumeScenes(); const fireplace = this.add.image(739, 10, 'fireplace').setScale(0.1525).setDepth(1); const floorWidth = 64; const floorHeight = 64; const numFloorImagesX = 20; const numFloorImagesY = 10; const startX = 100; const startY = 100; for (let y = 0; y < numFloorImagesY; y++) { for (let x = 0; x < numFloorImagesX; x++) { const floorImage = this.add.image(startX + (x * floorWidth), startY + (y * floorHeight), 'floorboard').setDisplaySize(floorWidth, floorHeight).setDepth(2); this.floorImages.push(floorImage); } } const wallWidth = 64; const wallHeight = 64; const wallStartX = startX - 2 * wallWidth; // Subtract 2 * wallWidth for two layers const wallStartY = startY - 2 * wallHeight; // Subtract 2 * wallHeight for two layers const wallEndX = startX + (numFloorImagesX * floorWidth) + wallWidth; // Add wallWidth for two layers const wallEndY = startY + (numFloorImagesY * floorHeight) + wallHeight; // Add wallHeight for two layers // Create a physics group for the walls this.walls = this.physics.add.staticGroup(); // Loop for the first and second layers of walls on the top and bottom for (let x = wallStartX; x <= wallEndX; x += wallWidth) { for (let i = 0; i < 2; i++) { // Loop for two layers const wallTop = this.walls.create(x, wallStartY + i * wallHeight, 'walls').setDisplaySize(wallWidth, wallHeight).refreshBody().setDepth(0); const wallBottom = this.walls.create(x, wallEndY - i * wallHeight, 'walls').setDisplaySize(wallWidth, wallHeight).refreshBody().setDepth(0); } } // Loop for the first and second layers of walls on the left and right for (let y = wallStartY; y <= wallEndY; y += wallHeight) { for (let i = 0; i < 2; i++) { // Loop for two layers const wallLeft = this.walls.create(wallStartX + i * wallWidth, y, 'walls').setDisplaySize(wallWidth, wallHeight).refreshBody().setDepth(0); const wallRight = this.walls.create(wallEndX - i * wallWidth, y, 'walls').setDisplaySize(wallWidth, wallHeight).refreshBody().setDepth(0); } } // Activate chatbox only if it is not active if (!this.scene.isActive('ChatboxScene')) { window.globalState.showChatbox(); this.scene.launch('ChatboxScene'); this.chatboxScene = this.scene.get('ChatboxScene'); } // Instantiate NPC classes window.globalState.npcs.set('NPCDarkKnight', new NPCDarkKnight(this, 150, 150).setDepth(3)); window.globalState.npcs.set('NPCMachinist', new NPCMachinist(this, 300, 150).setDepth(3)); window.globalState.npcs.set('NPCBotanist', new NPCBotanist(this, 450, 150).setDepth(3)); window.globalState.npcs.set('NPCWizard', new NPCWizard(this, this.sceneManager, 150, 300).setDepth(3).setScale(1)); window.globalState.npcs.set('NPCDemonSlayer', new NPCDemonSlayer(this, 300, 300).setScale(1)); if (this.red) { this.red.destroy(); } // Add physics to this.red this.red = this.physics.add.image(300, 500, 'red'); this.red.setScale(0.25); this.red.setDepth(3); this.red.setBounce(0.8, 0.8); this.red.setCollideWorldBounds(false); this.red.body.setBoundsRectangle(new Phaser.Geom.Rectangle(0, 0, 800 - 150, 600)); // Add collision between this.red and the walls this.physics.add.collider(this.red, this.walls); const particles = this.add.particles('particles').setDepth(3); const emitter = particles.createEmitter({ speed: 100, scale: { start: 0.25, end: 0 }, blendMode: 'ADD', lifespan: 500 }); emitter.startFollow(this.red); this.keys = this.input.keyboard.addKeys('W,A,S,D,SPACE'); // Include SPACE for testing if needed // Select Character Button - Keep or review based on your game flow this.selectCharacterButton = this.createSelectCharacterButton(); // Start Game Button - Review for game flow this.startGameButton = this.createStartGameButton(); // Review Key Bindings - Adjust or remove based on necessity this.Tkey = this.input.keyboard.addKey('T'); // Review if needed for character selection this.EscapeKey = this.input.keyboard.addKey('ESC'); // Review if needed for exiting menus or screens // Setup NPCs with interactive properties this.cameras.main.startFollow(this.red, true, 0.25, 0.25, -150, 5); } createStartGameButton() { let button = this.add.text(275, 300, 'Start Game', { fontSize: '32px', fill: '#FFFFFF', align: 'center' }).setOrigin(0.5, 0.5) .setDepth(4) .setVisible(false) .setInteractive() .on('pointerdown', () => { this.scene.restart('MainScene'); // Reset or initialize the scene state console.log('Game started!'); const currentNPCKey = window.globalState.getCurrentNPCKey(); // Get the current selected character // Loop through the npcs and destroy the ones that are not selected this.npcs.forEach(npc => { npc.destroy(); }); // Optionally, pause or hide the current scene this.scene.pause(); window.globalState.hideChatbox(); this.scene.pause('ChatboxScene'); // Launch the LoadingScreen scene this.scene.launch('LoadingScreen'); // Launch the MainScene this.scene.launch('MainScene'); // Bring LoadingScreen to top this.scene.bringToTop('LoadingScreen'); }); return button; } createSelectCharacterButton() { let button = this.add.text(0, 0, 'Select Character', { fontSize: '18px', fill: '#FFFFFF', align: 'center' }) .setOrigin(0.5, 0.5) .setDepth(4) .setVisible(false) .setInteractive() .on('pointerdown', async () => { // Retrieve the currently hovered NPC's key from the global state const currentNPCKey = this.globalState.getCurrentNPCKey(); this.registry.set('selectedCharacterKey', currentNPCKey); if (currentNPCKey) { // Retrieve the NPC object using the key const npc = this.globalState.getNPC(currentNPCKey); if (npc) { // Fetch the ChatboxScene instance from the scene manager const chatboxScene = this.scene.get('ChatboxScene'); // Add a message to the chat indicating the character selection chatboxScene.addMessageToChat(`You have selected: ${npc.name}`, 'system'); try { // Attempt to get a response from the NPC's chat manager const response = await npc.chatManager.getCharacterResponse(); // Display the NPC's response in the chat chatboxScene.addMessageToChat(`${npc.name}: ${response}`, 'npc'); } catch (error) { console.error("Error getting response from NPC chat manager:", error); chatboxScene.addMessageToChat("Error in communication with NPC.", 'system'); } // Make the "Start Game" button visible this.startGameButton.setVisible(true); } } }); return button; } update() { // Check if chatting is active if (this.chatboxScene && this.chatboxScene.isChatting) { // Chatting is active, so don't allow movement return; } // Handle player movement this.handlePlayerMovement(); // Check for NPC hover state this.updateHoverState(); } handlePlayerMovement() { if (this.keys.W.isDown) { this.red.setVelocityY(-160); } else if (this.keys.S.isDown) { this.red.setVelocityY(160); } else { this.red.setVelocityY(0); } if (this.keys.A.isDown) { this.red.setVelocityX(-160); } else if (this.keys.D.isDown) { this.red.setVelocityX(160); } else { this.red.setVelocityX(0); } } updateHoverState() { const playerBounds = this.red.getBounds(); let isHovering = false; for (let [key, npc] of window.globalState.npcs) { if (Phaser.Geom.Intersects.RectangleToRectangle(playerBounds, npc.getBounds())) { if (window.globalState.getCurrentNPCKey() !== key) { window.globalState.setCurrentNPCKey(key); console.log(`Current NPC Key Set: ${key}`); // Show and position the "Select Character" button this.selectCharacterButton.setPosition(npc.x, npc.y - 50); // Adjust Y offset as needed this.selectCharacterButton.setVisible(true); } isHovering = true; break; // Stop checking once an NPC is hovered } } if (!isHovering && window.globalState.getCurrentNPCKey()) { console.log("Clearing current NPC Key."); window.globalState.clearCurrentNPC(); this.selectCharacterButton.setVisible(false); } } } // LOADING SCREEN SCENE class LoadingScreen extends Phaser.Scene { constructor() { super({ key: 'LoadingScreen' }); } preload() { // Preload assets for MainScene or display a loading animation this.load.image('LoadingScreenBackground', `https://play.rosebud.ai/assets/20240330_083256.jpg.jpg?6AmJ`); this.load.image('button', `https://play.rosebud.ai/assets/button.png.png?aA6Q`); } updateTip() { // Add this function this.currentTipIndex = (this.currentTipIndex + 1) % this.gameTips.length; // Increment the current tip index, wrapping around to the start of the array if necessary this.tipText.setText(this.gameTips[this.currentTipIndex]); // Update the tip text with the new tip } create() { this.scene.bringToTop(); // Add this line this.scene.stop('Example'); // Display the loading screen background or animation this.add.image(this.cameras.main.centerX, this.cameras.main.centerY, 'LoadingScreenBackground').setDisplaySize(this.cameras.main.width, this.cameras.main.height); // Display "Press Space to Continue" text this.continueText = this.add.text(this.cameras.main.width / 2, this.cameras.main.height - 50, 'Press Space to Continue', { font: '20px Arial', fill: '#FFFFFF' }).setOrigin(0.5, 0.5); this.continueText.setVisible(false); // Initially hidden // Wait for the player to press Space this.input.keyboard.once('keydown-SPACE', () => { this.scene.bringToTop('ChatboxScene'); // This ensures ChatboxScene is on top this.scene.stop('LoadingScreen'); }); // Create an array of game tips this.gameTips = ['You can move the Character with WASD', 'You can talk to your character at any time by pressing T to talk. This will also pause the game and keep you safe.', 'Stay Alive!', 'Press ESC to pause the game. (Currently semi-functional)', 'Make sure to kill all enemies before moving on to the next room!']; this.currentTipIndex = 0; // Add this line // Create a text object for the game tip in the middle of the screen this.add.image(this.cameras.main.width / 2, this.cameras.main.centerY - 50, 'button').setScale(-0.5, 0.5); let buttonWidth = this.cameras.main.width / 2; this.tipText = this.add.text(this.cameras.main.width / 2, this.cameras.main.centerY - 75, this.gameTips[this.currentTipIndex], { font: '20px Arial', fill: '#000000', wordWrap: { width: buttonWidth - 150, useAdvancedWrap: true } }).setOrigin(0.5, 0.5).setInteractive(); // Add setInteractive() to make the text clickable this.tipText.on('pointerdown', this.updateTip, this); // Add this line // Create a text object for the "Generating Room. Please Wait" message at the bottom of the screen this.waitText = this.add.text(this.cameras.main.width / 2, this.cameras.main.height - 50, 'Generating Room. Please Wait...', { font: '20px Arial', fill: '#FFFFFF' }).setOrigin(0.5, 0.5); this.continueText.setVisible(false); // Initially hide the "Press Space to Continue" message this.waitText.setVisible(true); // Show the "Generating Room. Please Wait" message this.scene.get('MainScene').events.on('roomGeneratorComplete', () => { this.waitText.setVisible(false); // Hide the "Generating Room. Please Wait" message this.continueText.setVisible(true); // Show the "Press Space to Continue" message }); } } // Main Scene class MainScene extends Phaser.Scene { constructor() { super('MainScene'); this.roomGenerator = new RoomGenerator(); this.enemyNpcs = []; // Initialize the enemyNpcs array here this.enemyPositions = []; // Add this line to store enemy positions this.roomGenerated = false; // Add this flag to indicate room generation completion this.isDead = false; // Add this line to set the initial state of the selected character being dead this.enemiesCreated = false; // Flag to track whether enemies are created this.characterInitialized = false; // Add this line this.npcs = []; this.characterKills = 0; // Track number of enemies the character has killed this.characterHits = 0; // Track number of times the character has been hit this.npc = []; this.SceneName = null; // New property to keep track of the previous scene this.isPaused = false; this.characterDead = false; this.enemyCounterText = null; // Add this line to store the enemy counter text this.enemyCounterTextOffset = { x: 250, y: 200 }; // Set the offset of the enemy counter text relative to the camera this.damageCounterText = null; // Add this line to store the damage counter text this.damageCounterTextOffset = { x: 250, y: 220 }; // Add this line to set the offset of the damage counter text relative to the camera this.killCounterText = null; // Add this line to store the damage counter text this.killCounterTextOffset = { x: 250, y: 240 }; // Add this line to set the offset of the damage counter text relative to the camera } preload() { this.load.image('wall', `https://play.rosebud.ai/assets/Wall1.png.png?HvYo`); this.load.image('door', `https://play.rosebud.ai/assets/Door1.png.png?1o9J`); this.load.image('floor', `https://play.rosebud.ai/assets/20240330_083424.jpg.jpg?1et3`); this.load.image('block', `https://play.rosebud.ai/assets/20240330_083424.jpg.jpg?1et3`); // Load enemy sprite this.load.image('enemy', `https://play.rosebud.ai/assets/Clipped_image_20240324_174409.png.png?Hp22`, {}); // Load the attack animation this.load.image('attack', `https://play.rosebud.ai/assets/vertical lighting bolt strike to floor attack.png?ET3v`); // Load the fireball sprite sheet this.load.spritesheet('fireball', `https://play.rosebud.ai/assets/fireball Updated.png.png?orRv`, { frameWidth: 64, frameHeight: 64 }); } togglePause() { if (this.isPaused) { this.input.enabled = true; this.physics.resume(); // Resume physics this.overlay.destroy(); // Destroy the overlay this.isPaused = false; // Update the game state to not paused this.readyText1.setVisible(false); // Hide the 'Get ready, Enemies are nearby.' text this.readyText2.setVisible(false); // Hide the 'Press Space Bar when you are ready.' text this.pausedText.setVisible(false); // Hide the "Paused" text } else { this.input.enabled = false; console.log('Physics paused - Location: togglePause()'); this.physics.pause(); // Pause physics this.overlay = this.add.rectangle(0, 0, this.sys.game.config.width, this.sys.game.config.height, 0x000000).setOrigin(0, 0).setAlpha(0.1).setDepth(9999); this.pausedText = this.add.text(this.cameras.main.centerX, this.cameras.main.centerY, 'Paused', { fontSize: '50px', fill: '#FFFFFF', align: 'center' }).setOrigin(0.5, 0.5).setDepth(10); this.isPaused = true; // Update the game state to paused } } create() { window.globalState.addScene('MainScene', this); // Add this line this.doors = this.physics.add.group(); // Group to hold door physics objects this.characterDead = false; // Add this line to store the character's dead state const selectedCharacterKey = this.registry.get('selectedCharacterKey'); console.log('Selected character key:', selectedCharacterKey); // Use selectedCharacterKey to initialize the player character this.initializeSelectedCharacter(selectedCharacterKey); console.log('MainScene started with global state'); this.wallGroup = this.physics.add.staticGroup(); this.generateRoom(); this.updatePlayerPosition(); this.Tkey = this.input.keyboard.addKey(Phaser.Input.Keyboard.KeyCodes.T); this.keys = this.input.keyboard.addKeys({ W: Phaser.Input.Keyboard.KeyCodes.W, A: Phaser.Input.Keyboard.KeyCodes.A, S: Phaser.Input.Keyboard.KeyCodes.S, D: Phaser.Input.Keyboard.KeyCodes.D, T: Phaser.Input.Keyboard.KeyCodes.T, SPACE: Phaser.Input.Keyboard.KeyCodes.SPACE, }); this.ESCKey = this.input.keyboard.addKey(Phaser.Input.Keyboard.KeyCodes.ESC); this.ESCKey.on('down', () => { this.togglePause(); }); this.scene.resume('ChatboxScene'); // Create the enemy counter text and set its initial position relative to the camera this.enemyCounterText = this.add.text(this.cameras.main.scrollX + this.enemyCounterTextOffset.x, this.cameras.main.scrollY + this.enemyCounterTextOffset.y, 'Enemies: 0', { fontSize: '16px', fill: '#FFFFFF' }).setDepth(4); this.damageCounterText = this.add.text(this.cameras.main.scrollX + this.damageCounterTextOffset.x, this.cameras.main.scrollY + this.damageCounterTextOffset.y, 'Damage: 0', { fontSize: '16px', fill: '#FFFFFF' }).setDepth(4); this.killCounterText = this.add.text(this.cameras.main.scrollX + this.killCounterTextOffset.x, this.cameras.main.scrollY + this.killCounterTextOffset.y, 'Kills: 0', { fontSize: '16px', fill: '#FFFFFF' }).setDepth(4); // Create fireball animation this.anims.create({ key: 'fireball', frames: this.anims.generateFrameNumbers('fireball', { start: 0, end: 2 }), frameRate: 10, repeat: -1 }); } update() { if (!this.selectedCharacter || !this.wallGroup) { console.log('Debug: Selected character or wallGroup is undefined.', { selectedCharacter: this.selectedCharacter, wallGroup: this.wallGroup }); } if (this.selectedCharacter && this.enemyNpcs) { // Ensure selectedCharacter and all enemies are defined if (typeof this.selectedCharacter === 'undefined') { console.error('selectedCharacter is undefined'); } this.enemyNpcs.forEach((enemy, index) => { if (typeof enemy === 'undefined') { console.error(`Enemy at index ${index} is undefined`); } }); } if (this.selectedCharacter) { if (window.globalState.physicsPaused) { console.log('Physics paused - Location: update()'); this.physics.pause(); } else { this.physics.resume(); } if (!this.SceneName) { // Get the keys of the currently running scenes let activeSceneKeys = Object.keys(this.scene.manager.scenes); // Remove 'ChatboxScene' from the activeSceneKeys activeSceneKeys = activeSceneKeys.filter(key => key !== 'ChatboxScene'); // Set this.SceneName to the last active scene // This assumes that the scene that initiated the chat is the last one in the array this.SceneName = activeSceneKeys[activeSceneKeys.length - 1]; } if (this.isPaused) { return; // If the game is paused, do not update player movements or animations } if (!this.characterDead) { // Reset velocity every frame; characters stop moving when keys are not pressed this.selectedCharacter.body.setVelocity(0); // Movement with WASD keys if (this.keys.W.isDown) { this.selectedCharacter.body.setVelocityY(-160); } else if (this.keys.S.isDown) { this.selectedCharacter.body.setVelocityY(160); } if (this.keys.A.isDown) { this.selectedCharacter.body.setVelocityX(-160); } else if (this.keys.D.isDown) { this.selectedCharacter.body.setVelocityX(160); } // Normalize the velocity of the character to prevent it from moving faster diagonally this.selectedCharacter.body.velocity.normalize().scale(160); // Update the player character this.selectedCharacter.update(this.keys); // Create enemies after all characters are initialized and room is generated if (this.npcs.length > 0 && this.roomGenerated && !this.enemiesCreated) { this.enemyPositions.forEach(pos => { const enemy = new NPCEnemy(this, pos.x, pos.y, 'enemy', this.selectedCharacter); enemy.setScale(0.4); this.enemyNpcs.push(enemy); }); this.enemiesCreated = true; // Set to true after creating enemies } if (!this.keys) { return; // If keys are not defined, exit the update function early } this.enemyNpcs = this.enemyNpcs.filter(enemyNpc => { if (enemyNpc && enemyNpc.getBounds && this.selectedCharacter && this.selectedCharacter.getBounds) { enemyNpc.setPlayer(this.selectedCharacter); // Update player reference if it can change enemyNpc.update(); // check if enemy is dead if (enemyNpc.isDead()) { // If enemyNpc is dead, increment characterKills, destroy the enemyNpc and filter out from enemyNpcs this.characterKills += 1; enemyNpc.destroy(); return false; } // Check for collision between the player and the enemy NPC if (Phaser.Geom.Intersects.RectangleToRectangle(this.selectedCharacter.getBounds(), enemyNpc.getBounds())) { // If the player collides with an enemy NPC, they take 1 damage this.selectedCharacter.takeDamage(1); this.characterHits += 1; // Increase hits } } return true; }); this.damageCounterText.setPosition(this.cameras.main.scrollX + this.damageCounterTextOffset.x, this.cameras.main.scrollY + this.damageCounterTextOffset.y); this.damageCounterText.setText('Damage: ' + this.characterHits); // Update damage counter // Update the position of the enemy counter text relative to the camera this.enemyCounterText.setPosition(this.cameras.main.scrollX + this.enemyCounterTextOffset.x, this.cameras.main.scrollY + this.enemyCounterTextOffset.y); // Update enemy counter this.enemyCounterText.setText('Enemies: ' + this.enemyNpcs.length); this.killCounterText.setPosition(this.cameras.main.scrollX + this.killCounterTextOffset.x, this.cameras.main.scrollY + this.killCounterTextOffset.y); this.killCounterText.setText('Kills: ' + this.characterKills); // Display kill counter } // Added missing closing curly brace here } } initializeSelectedCharacter(spawnPointArg) { console.log('InitializeSelectedCharacter function started.') // Retrieve the key of the selected character from the global state const characterKey = window.globalState.getCurrentNPCKey(); // Using the characterKey, retrieve the full state of the NPC const npcState = window.globalState.getNPC(characterKey); if (!npcState) { console.error('Failed to find selected character state for key:', characterKey); return null; } const spawnPoint = spawnPointArg || { x: 300, y: 300 }; // Default spawn point let character; // Initialize the character based on its type stored in npcState switch (npcState.type) { case 'NPCDarkKnight': character = new NPCDarkKnight(this, spawnPoint.x, spawnPoint.y, 'darkKnight'); break; case 'NPCMachinist': character = new NPCMachinist(this, spawnPoint.x, spawnPoint.y, 'machinist'); break; case 'NPCBotanist': character = new NPCBotanist(this, spawnPoint.x, spawnPoint.y, 'botanist'); break; case 'NPCWizard': character = new NPCWizard(this, this.scene, spawnPoint.x, spawnPoint.y, 'wizard'); character.setScale(0.4) break; case 'NPCDemonSlayer': character = new NPCDemonSlayer(this, spawnPoint.x, spawnPoint.y, 'demonSlayer'); character.setScale(0.4) break; default: console.warn('Unrecognized character type:', npcState.type); return null; } if (character) { // Apply common properties like scale and physics this.physics.add.existing(character); character.body.setCollideWorldBounds(false); // Ensure collisions with the environment this.physics.add.collider(character, this.wallGroup); // Optionally, set the camera to follow this character this.cameras.main.startFollow(character, true, 0.25, 0.25, -40, 5); this.cameras.main.setZoom(2.5); this.npcs.push(character); // Add new player NPC to array // Store the character for easy access throughout the scene this.selectedCharacter = character; console.log(`Selected character ${characterKey} initialized.`, character); return character; } return null; } async generateRoom(message) { if (!message) { message = ` Based on the room generation examples you're familiar with, please craft a new and unique room layout that is fully explorable and adheres to the established symbol language and structural commandments. Each new room should be distinctly different from previous iterations to maintain variety, yet it must still comply with the core principles of design as per your knowledge. For this task, focus on the following specific guidelines: 1. For the initial room design, include exactly two enemy spawns ('e'). Position these enemies in locations that are notably distanced from the player's starting point ('p'), ensuring a balanced challenge and exploration opportunity for the player. 2. Ensure that the overall layout of the room supports exploration and interaction, with all areas being accessible and interconnected without dead ends or inaccessible zones. 3. While designing, remember to incorporate a mix of walls ('-'), floors ('/'), item spawns ('o'), and the player spawn point ('p') in a manner that creates a coherent and engaging space for gameplay. The structural integrity and navigational logic of the room should mirror the examples in your knowledge base, showcasing creativity within the bounds of the given constraints. Please proceed to generate the first room layout following these precise instructions. Let's focus on crafting a space that offers a fresh experience while ensuring the presence of only two enemies placed strategically away from the player to encourage exploration and strategy. `; } // Start the generating room scene this.scene.launch('GeneratingRoomScene'); // Define a function to stop the loading scene const stopLoadingScene = () => { this.scene.stop('GeneratingRoomScene'); this.events.off('roomGenerated', stopLoadingScene); }; // Add the event listener this.events.once('roomGenerated', stopLoadingScene); this.roomGenerator.addMessage('user', message); const legend = { '-': 'wall', 'n': 'door', '/': 'floor', 'o': 'item', 'e': 'enemy', 'p': 'player', }; this.physics.pause(); this.wallGroup = this.physics.add.staticGroup(); this.floorGroup = this.physics.add.staticGroup(); this.enemyPositions = []; // Assuming you have a way to handle enemies const roomGenerator = this.roomGenerator; try { const roomDescription = await roomGenerator.generateRoom(message); // Wait for the room to be generated console.log("Generated Room:", roomDescription); let spawnPoint = null; const imageDescriptions = roomDescription.split('\n'); let yPos = 0; imageDescriptions.forEach((row) => { let xPos = 0; for (let i = 0; i < row.length; i++) { let key = legend[row[i]]; // Check if the current character is 'o', 'e', or 'p' and map them to 'floor' if (row[i] === 'o') { key = 'floor'; // Override key to 'floor' for these characters // Add additional handling for 'p' if needed here } if (row[i] === 'p') { spawnPoint = { x: xPos * 32, y: yPos * 30 }; // Adjust for your game's scale key = 'floor'; // Override key to 'floor' for these characters // Add additional handling for 'p' if needed here } if (row[i] === 'n') { const door = this.doors.create(xPos * 32, yPos * 30, 'door').setScale(0.04).refreshBody(); key = 'door'; } else if (row[i] === 'e') { key = 'floor'; this.enemyPositions.push({ x: xPos * 32, y: yPos * 30 }); } if (key) { if (key === 'wall') { // For walls, create as static physics objects const wall = this.wallGroup.create(xPos * 32, yPos * 30, key).setScale(0.04).refreshBody(); } else if (key === 'floor') { // For floor, create as physics objects in floorGroup const floor = this.floorGroup.create(xPos * 32, yPos * 30, key).setScale(0.0325).refreshBody(); } else { // For other objects, use regular image addition const image = this.add.image(xPos * 32, yPos * 30, key).setScale(0.0325); } } xPos += 1; } yPos += 1; }); // Now, set up the collider if (this.selectedCharacter && this.wallGroup) { this.physics.add.collider(this.selectedCharacter, this.wallGroup); } this.selectedCharacter.setPosition(spawnPoint.x, spawnPoint.y); this.events.emit('roomGenerated', spawnPoint); // Use 'roomGenerated' event to signal that room generation is complete this.togglePause(); // Toggle pause state // Creation of the text after room generation is completed this.readyText1 = this.add.text(spawnPoint.x, spawnPoint.y, 'Get ready, Enemies are nearby.', { fontSize: '64px', align: 'center', fill: '#FFFFFF' }).setOrigin(0.5, 0.5).setScale(0.15).setDepth(10); this.readyText1.setPosition(spawnPoint.x, spawnPoint.y - 25); this.readyText2 = this.add.text(spawnPoint.x, spawnPoint.y, 'Press Space Bar when you are ready.', { fontSize: '64px', align: 'center', fill: '#FFFFFF' }).setOrigin(0.5, 0.5).setScale(0.15).setDepth(10); this.readyText2.setPosition(spawnPoint.x, spawnPoint.y + 25); // Wait for the user to press Space before continuing this.input.keyboard.once('keydown-SPACE', () => { this.togglePause(); // Toggle pause state this.createEnemies(); // Create enemies after user presses Space this.events.emit('roomGeneratorComplete', spawnPoint); // Emit 'roomGeneratorComplete' event }); } catch (error) { console.error("Error generating room:", error); } this.physics.resume(); console.log('this.selectedCharacter = ', this.selectedCharacter) } updatePlayerPosition() { this.events.once('roomGenerated', spawnPoint => { if (spawnPoint) { this.selectedCharacter.setPosition(spawnPoint.x, spawnPoint.y); this.physics.resume(); } }); } async onDoorCollide(player, door) { console.log('Collision detected. Player:', player, 'Door:', door); const message = `The player has successfully navigated the current room, overcoming ${this.characterKills}/${this.enemyNpcs.length} enemies and enduring ${this.characterHits} damage. For the next room, escalate the challenge. Introduce more complex layouts and strategic enemy placements to enhance the difficulty. Ensure the new room is noticeably distinct from its predecessors, with unique obstacles and arrangements that require the player to adopt different strategies to progress. Keep the foundational design principles in mind, but innovate within those boundaries to create a fresh, challenging experience for the player.`; this.destroyRoom(); this.selectedCharacter.setPosition(0, 0); // Move the character to 0,0 this.clearEnemies(); // Clear the enemyNpcs array await this.generateRoom(message); } clearEnemies() { // Clear the enemyNpcs array this.enemyNpcs.forEach(enemy => enemy.destroy()); this.enemyNpcs.length = 0; } destroyRoom() { // Destroy all room elements (walls, doors, enemies) this.wallGroup.clear(true, true); this.floorGroup.clear(true, true); this.doors.clear(true, true); // clear enemies and items too, if you have them } setCharacterDead() { this.characterDead = true; } createEnemies() { console.log('Spawning enemies at positions:', this.enemyPositions); this.enemyPositions.forEach(pos => { const enemy = new NPCEnemy(this, pos.x, pos.y, 'enemy', this.selectedCharacter); enemy.setScale(0.02); // Scale down the enemy this.enemyNpcs.push(enemy); this.physics.add.existing(enemy); enemy.body.setCollideWorldBounds(true); this.physics.add.collider(enemy, this.wallGroup); // Ensure they collide with walls this.physics.add.overlap(this.selectedCharacter, this.doors, this.onDoorCollide, null, this); // Detect collision between character and doors }); this.enemiesCreated = true; // Mark as created console.log(`${this.enemyNpcs.length} enemies created.`); } } // GeneratingRoomScene class GeneratingRoomScene extends Phaser.Scene { constructor() { super({ key: 'GeneratingRoomScene' }); } preload() { // Preload assets for the loading screen this.load.image('loadingScreenBackground', `https://play.rosebud.ai/assets/20240321_203012.jpg.jpg?Yl9v`); this.load.image('block', `https://play.rosebud.ai/assets/20240330_083424.jpg.jpg?1et3`); } create() { console.log('Generating Room Scene started'); // Display the loading screen background or animation var bg = this.add.graphics({ fillStyle: { color: 0x000000 } }); bg.fillRect(0, 0, this.cameras.main.width, this.cameras.main.height); // Display "Generating Room. Please Wait" text this.add.text(this.cameras.main.width / 2 - 125, this.cameras.main.height - 50, 'Generating Room. Please Wait...', { font: '20px Arial', fill: '#FFFFFF' }).setOrigin(0.5, 0.5); // Create blocks to fill the screen const blockWidth = 50; const blockHeight = 50; const numBlocksX = Math.ceil(this.cameras.main.width / blockWidth); const numBlocksY = Math.ceil(this.cameras.main.height / blockHeight); const startX = (this.cameras.main.width - (numBlocksX * blockWidth)) / 2; const startY = (this.cameras.main.height - (numBlocksY * blockHeight)) / 2; for (let y = 0; y < numBlocksY; y++) { for (let x = 0; x < numBlocksX; x++) { const block = this.add.image(startX + (x * blockWidth), startY + (y * blockHeight), 'block').setDisplaySize(blockWidth, blockHeight); block.setDepth(numBlocksY - y); block.alpha = 0; this.tweens.add({ targets: block, alpha: 1, duration: 500, delay: (x + y) * 100, yoyo: true, repeat: -1 }); } } } } // Death Scene class DeathScene extends Phaser.Scene { constructor() { super('DeathScene'); } create() { const npc = window.globalState.getNPC(); const characterSprite = this.add.sprite(this.cameras.main.x, this.cameras.main.y, npc); characterSprite.setOrigin(0.5, 0.5); // Ensures the sprite is centered this.tweens.add({ targets: characterSprite, y: "-=100", // Move up a little bit duration: 3000, yoyo: true, // Make the tween go back and forth repeat: -1 // Repeat indefinitely }); const overlay = this.add.rectangle(this.cameras.main.x, this.cameras.main.y, 800, 600, 0x000000); overlay.setOrigin(0, 0); overlay.setAlpha(0); this.tweens.add({ targets: overlay, alpha: 1, duration: 3000, }); this.add.text(400, 300, 'You have died.', { fontSize: '32px', fill: '#FFFFFF', align: 'center' }).setOrigin(0.5, 0.5); // Added text that says "Press Space to continue" this.add.text(400, 350, 'Press Space to continue', { fontSize: '20px', fill: '#FFFFFF', align: 'center' }).setOrigin(0.5, 0.5); // Add event listener for 'space' key press this.input.keyboard.on('keydown-SPACE', () => { this.scene.stop('MainScene'); this.scene.stop('DeathScene'); const mainScene = this.scene.get('MainScene'); mainScene.clearEnemies(); // Clear enemies in the MainScene this.scene.launch('Example'); }); } } // Set the configuration of the game const config = { type: Phaser.AUTO, fps: { target: 1 }, // Add this line to limit the frame rate to 30 FPS parent: 'renderDiv', scale: { mode: Phaser.Scale.FIT, autoCenter: Phaser.Scale.CENTER_BOTH, }, width: 800, height: 600, physics: { default: 'arcade', arcade: { gravity: { y: 0 }, debug: false }, }, scene: [StartScene, Example, ChatboxScene, LoadingScreen, MainScene, DeathScene, GeneratingRoomScene], }; window.phaserGame = new Phaser.Game(config)