class Example extends Phaser.Scene { constructor() { super(); this.cameraSpeed = 5; this.cursors = null; this.wallSegments = []; this.hour = 0; this.day = 1; this.discussionOccurred = false; this.callOutCounts = {}; // New property to track call-outs this.specialColorNames = { 0x000000: 'Eclipse Black', 0x00021c: 'Midnight Depths', 0x1c284d: 'Oceanic Twilight', 0x343473: 'Twilight Mist', 0x2d5280: 'Stormy Sea', 0x4d7a99: 'Dusk Blue', 0x7497a6: 'Frosted Aqua', 0xa3ccd9: 'Sky Reflection', 0xf0edd8: 'Whispering Sand', 0x732866: 'Violet Bloom', 0xa6216e: 'Berry Fizz', 0xd94c87: 'Raspberry Dream', 0xd9214f: 'Crimson Kiss', 0xf25565: 'Coral Splash', 0xf27961: 'Peach Sunset', 0x993649: 'Garnet Glint', 0xb36159: 'Copper Glow', 0xf09c60: 'Amber Dawn', 0xb38f24: 'Golden Harvest', 0xb3b324: 'Lime Zest', 0xf7c93e: 'Sunshine Yellow', 0x17735f: 'Forest Whisper', 0x119955: 'Emerald Wave', 0x67b31b: 'Lime Sprout', 0x1ba683: 'Teal Tide', 0x47cca9: 'Aqua Dreams', 0x96e3c9: 'Cerulean Bliss', 0x2469b3: 'Blue Horizon', 0x0b8be6: 'Electric Sky', 0x0bafe6: 'Aqua Aurora', 0xf28d85: 'Salmon Embrace', 0xf0bb90: 'Peachy Glow' }; } create() { // Set the background color to black this.cameras.main.setBackgroundColor('#000000'); this.specialTiles = []; this.playerTileColor = null; this.container = this.add.container(0, 0); this.createGrid(); this.setupCamera(); this.setupControls(); this.createAdvanceTimeButton(); this.roomInfoText = this.add.text(10, 10, '', { fontSize: '16px', fill: '#ffffff', stroke: '#000000', strokeThickness: 3 }); this.roomInfoText.setScrollFactor(0); this.roomInfoText.setDepth(1); this.colorInfoText = this.add.text(10, 40, '', { fontSize: '16px', fill: '#ffffff', stroke: '#000000', strokeThickness: 3 }); this.colorInfoText.setScrollFactor(0); this.colorInfoText.setDepth(1); this.colorInfoText.setVisible(false); // Add player role text this.playerRoleText = this.add.text(10, 70, 'Your Role: Not assigned', { fontSize: '16px', fill: '#ffffff', stroke: '#000000', strokeThickness: 3 }); this.playerRoleText.setScrollFactor(0); this.playerRoleText.setDepth(1); // Add hour and day counter this.timeText = this.add.text(this.cameras.main.width - 10, 10, '', { fontSize: '16px', fill: '#ffffff', stroke: '#000000', strokeThickness: 3 }); this.timeText.setOrigin(1, 0); this.timeText.setScrollFactor(0); this.timeText.setDepth(1); // Add people count this.peopleText = this.add.text(this.cameras.main.width - 10, 30, '', { fontSize: '16px', fill: '#ffffff', stroke: '#000000', strokeThickness: 3 }); this.peopleText.setOrigin(1, 0); this.peopleText.setScrollFactor(0); this.peopleText.setDepth(1); this.updateTimeAndPeopleText(); } setupCamera() { const totalWidth = 50 * 16; const totalHeight = 38 * 16; this.cameras.main.setBounds(0, 0, totalWidth, totalHeight); this.physics.world.setBounds(0, 0, totalWidth, totalHeight); } setupControls() { this.cursors = this.input.keyboard.createCursorKeys(); } update() { const camera = this.cameras.main; if (this.cursors.left.isDown) { camera.scrollX -= this.cameraSpeed; } else if (this.cursors.right.isDown) { camera.scrollX += this.cameraSpeed; } if (this.cursors.up.isDown) { camera.scrollY -= this.cameraSpeed; } else if (this.cursors.down.isDown) { camera.scrollY += this.cameraSpeed; } // Update room info and color info text positions this.roomInfoText.setPosition(camera.scrollX + 10, camera.scrollY + 10); if (this.colorInfoText.visible) { const worldPoint = this.input.activePointer.positionToCamera(camera); this.colorInfoText.setPosition( worldPoint.x - this.colorInfoText.width / 2, worldPoint.y - 16 - this.colorInfoText.height ); } // Update time and people text positions this.timeText.setPosition(camera.scrollX + camera.width - 10, camera.scrollY + 10); this.peopleText.setPosition(camera.scrollX + camera.width - 10, camera.scrollY + 30); } createAdvanceTimeButton() { this.advanceTimeButton = this.add.text(10, this.cameras.main.height - 40, 'Advance 1 Hour', { fontSize: '16px', fill: '#ffffff', backgroundColor: '#000000', padding: { left: 10, right: 10, top: 5, bottom: 5 } }); this.advanceTimeButton.setInteractive(); this.advanceTimeButton.on('pointerdown', () => this.advanceTimeAndReRandomize()); this.advanceTimeButton.setScrollFactor(0); } advanceTimeAndReRandomize() { // Check if the grid is properly initialized if (!this.grid || !Array.isArray(this.grid) || this.grid.length === 0) { console.error('Grid is not properly initialized'); return; } // Update hour and day this.hour++; if (this.hour >= 24) { this.hour = 0; this.day++; } // Reset the discussion flag this.discussionOccurred = false; // Remember the player tile color let playerTileColor = this.playerTile ? this.playerTile.color : null; let updatedSpecialTiles = []; for (let tile of this.specialTiles) { // Remove the tile from its current position this.grid[tile.y][tile.x] = this.isInRoom(tile.x, tile.y) ? 2 : 0; let newX, newY; const isCurrentlyInRoom = this.isInRoom(tile.x, tile.y); const shouldEnterRoom = !isCurrentlyInRoom && Math.random() < 0.5; const shouldExitRoom = isCurrentlyInRoom && Math.random() < 0.3; let attempts = 0; const maxAttempts = 50; let validPositionFound = false; do { if (shouldEnterRoom) { const availableRooms = this.rooms.filter(room => !updatedSpecialTiles.some(otherTile => otherTile.x >= room.x && otherTile.x < room.x + room.width && otherTile.y >= room.y && otherTile.y < room.y + room.height ) ); if (availableRooms.length > 0) { const randomRoom = Phaser.Utils.Array.GetRandom(availableRooms); newX = Phaser.Math.Between(randomRoom.x, randomRoom.x + randomRoom.width - 1); newY = Phaser.Math.Between(randomRoom.y, randomRoom.y + randomRoom.height - 1); } } else if (shouldExitRoom) { newX = Phaser.Math.Between(Math.max(0, tile.x - 5), Math.min(this.gridWidth - 1, tile.x + 5)); newY = Phaser.Math.Between(Math.max(0, tile.y - 5), Math.min(this.gridHeight - 1, tile.y + 5)); } else { newX = Phaser.Math.Between(Math.max(0, tile.x - 2), Math.min(this.gridWidth - 1, tile.x + 2)); newY = Phaser.Math.Between(Math.max(0, tile.y - 2), Math.min(this.gridHeight - 1, tile.y + 2)); } attempts++; if (newX >= 0 && newX < this.gridWidth && newY >= 0 && newY < this.gridHeight) { if (this.grid[newY][newX] !== 3 && // Not a wall this.grid[newY][newX] !== 5 && // Not a door this.grid[newY][newX] !== 6 && // Not another special tile ((!shouldEnterRoom && !shouldExitRoom) || // Normal movement (shouldEnterRoom && this.isInRoom(newX, newY)) || // Entering a room (shouldExitRoom && !this.isInRoom(newX, newY)))) { // Exiting a room validPositionFound = true; } } } while (!validPositionFound && attempts < maxAttempts); if (validPositionFound) { tile.x = newX; tile.y = newY; this.grid[newY][newX] = 6; // Mark as special tile updatedSpecialTiles.push(tile); } else { // If no valid position found, keep the tile in its current position this.grid[tile.y][tile.x] = 6; updatedSpecialTiles.push(tile); } } // Update special tiles this.specialTiles = updatedSpecialTiles; // Check for killer-innocent interactions this.checkKillerInnocentInteractions(); // Re-select the player tile with the same color this.playerTile = this.specialTiles.find(tile => tile.color === playerTileColor); if (!this.playerTile && this.specialTiles.length > 0) { this.playerTile = Phaser.Utils.Array.GetRandom(this.specialTiles); } // Update player role display this.updatePlayerRoleDisplay(); // Check for game over conditions if (this.checkGameOver()) { return; // Exit the method if the game is over } // Redraw the grid this.redrawGrid(); // Update time and people text this.updateTimeAndPeopleText(); } checkGameOver() { const killers = this.specialTiles.filter(tile => tile.role === 'killer'); const innocents = this.specialTiles.filter(tile => tile.role === 'innocent'); if (killers.length === 0) { this.gameOver('Innocents Win! All killers have been eliminated.'); return true; } else if (killers.length >= innocents.length) { this.gameOver('Killers Win! The number of killers is equal to or greater than the number of innocents.'); return true; } return false; } gameOver(message) { // Create a semi-transparent overlay const overlay = this.add.rectangle(0, 0, this.cameras.main.width, this.cameras.main.height, 0x000000, 0.7); overlay.setOrigin(0); overlay.setScrollFactor(0); overlay.setDepth(1000); // Calculate text size based on screen dimensions const fontSize = Math.min(this.cameras.main.width, this.cameras.main.height) * 0.05; // Display game over message const gameOverText = this.add.text(this.cameras.main.centerX, this.cameras.main.centerY - fontSize, message, { font: `${fontSize}px Arial`, fill: '#ffffff', align: 'center', wordWrap: { width: this.cameras.main.width * 0.8 } }); gameOverText.setOrigin(0.5); gameOverText.setScrollFactor(0); gameOverText.setDepth(1001); // Display reload message const reloadText = this.add.text(this.cameras.main.centerX, this.cameras.main.centerY + fontSize, 'Reload page to play again', { font: `${fontSize * 0.6}px Arial`, fill: '#ffffff', align: 'center' }); reloadText.setOrigin(0.5); reloadText.setScrollFactor(0); reloadText.setDepth(1001); // Disable the "Advance 1 Hour" button this.advanceTimeButton.disableInteractive(); this.advanceTimeButton.setAlpha(0.5); } checkKillerInnocentInteractions() { const killers = this.specialTiles.filter(tile => tile.role === 'killer'); const innocents = this.specialTiles.filter(tile => tile.role === 'innocent'); let innocentRemoved = false; for (const killer of killers) { const killerRoom = this.rooms.find(room => killer.x >= room.x && killer.x < room.x + room.width && killer.y >= room.y && killer.y < room.y + room.height ); if (killerRoom) { const innocentsToRemove = innocents.filter(innocent => innocent.x >= killerRoom.x && innocent.x < killerRoom.x + killerRoom.width && innocent.y >= killerRoom.y && innocent.y < killerRoom.y + killerRoom.height ); for (const innocent of innocentsToRemove) { if (this.removeSpecialTile(innocent.x, innocent.y)) { innocentRemoved = true; } } } } console.log(`After interactions: ${killers.length} killers, ${innocents.length} innocents`); // Initiate gathering and discussion only if an innocent was removed and discussion hasn't occurred yet if (innocentRemoved && !this.discussionOccurred) { this.gatherSpecialTilesAndDiscuss(); this.discussionOccurred = true; } } removeSpecialTile(x, y) { const index = this.specialTiles.findIndex(tile => tile.x === x && tile.y === y); if (index !== -1) { const removedTile = this.specialTiles.splice(index, 1)[0]; this.grid[y][x] = this.isInRoom(x, y) ? 2 : 0; if (this.playerTile === removedTile) { this.playerTile = this.specialTiles.length > 0 ? Phaser.Utils.Array.GetRandom(this.specialTiles) : null; } this.redrawGrid(); this.updateTimeAndPeopleText(); console.log(`Removed ${removedTile.role} at (${x}, ${y})`); const killers = this.specialTiles.filter(tile => tile.role === 'killer'); const innocents = this.specialTiles.filter(tile => tile.role === 'innocent'); console.log(`After removal: ${killers.length} killers, ${innocents.length} innocents`); return true; } return false; } findLargestRoom() { return this.rooms.reduce((largestRoom, currentRoom) => { const currentArea = currentRoom.width * currentRoom.height; const largestArea = largestRoom.width * largestRoom.height; return currentArea > largestArea ? currentRoom : largestRoom; }); } gatherSpecialTilesAndDiscuss() { // Find the largest room for gathering const largestRoom = this.findLargestRoom(); // Calculate the starting position for tile placement let startX = largestRoom.x + 1; // Start one tile away from the left wall let startY = largestRoom.y + 1; // Start one tile away from the top wall let currentX = startX; let currentY = startY; // Move all special tiles to the gathering spot this.specialTiles.forEach((tile, index) => { // Remove the tile from its current position this.grid[tile.y][tile.x] = this.isInRoom(tile.x, tile.y) ? 2 : 0; // Place the tile in the new position tile.x = currentX; tile.y = currentY; this.grid[currentY][currentX] = 6; // Move to the next position currentX++; if (currentX >= largestRoom.x + largestRoom.width - 1) { currentX = startX; currentY++; } // If we've reached the bottom of the room, start a new column if (currentY >= largestRoom.y + largestRoom.height - 1) { startX++; currentX = startX; currentY = startY; } }); // Redraw the grid to show the new positions this.redrawGrid(); // Show the discussion menu this.showDiscussionMenu(); } showDiscussionMenu() { // Create a semi-transparent overlay const overlay = this.add.rectangle(0, 0, this.cameras.main.width, this.cameras.main.height, 0x000000, 0.7); overlay.setOrigin(0); overlay.setScrollFactor(0); overlay.setDepth(1000); // Create the discussion menu const menuWidth = this.cameras.main.width * 0.8; const menuHeight = this.cameras.main.height * 0.8; const menu = this.add.rectangle(this.cameras.main.centerX, this.cameras.main.centerY, menuWidth, menuHeight, 0xffffff); menu.setScrollFactor(0); menu.setDepth(1001); // Add discussion text const discussionText = this.add.text(this.cameras.main.centerX, this.cameras.main.centerY - menuHeight * 0.3, 'Discussion Time!', { font: '32px Arial', fill: '#ffffff', stroke: '#000000', strokeThickness: 4 }); discussionText.setOrigin(0.5); discussionText.setScrollFactor(0); discussionText.setDepth(1002); // Add continue button const continueButton = this.add.text(this.cameras.main.centerX, this.cameras.main.centerY + menuHeight * 0.3, 'Continue', { font: '24px Arial', fill: '#ffffff', backgroundColor: '#000000', padding: { left: 10, right: 10, top: 5, bottom: 5 } }); continueButton.setOrigin(0.5); continueButton.setInteractive({ useHandCursor: true }); continueButton.setScrollFactor(0); continueButton.setDepth(1002); continueButton.on('pointerdown', () => { // Remove the discussion menu overlay.destroy(); menu.destroy(); discussionText.destroy(); continueButton.destroy(); // Start the discussion this.startDiscussion(); }); } startDiscussion() { // Get all special tiles (both killers and innocents) const allSpecialTiles = this.specialTiles; // Shuffle the array to randomize the order of discussion Phaser.Utils.Array.Shuffle(allSpecialTiles); // Start the discussion for each tile this.discussNextTile(allSpecialTiles, 0); } discussNextTile(tiles, index) { if (index >= tiles.length) { // All tiles have had their turn, end the discussion this.endDiscussion(); return; } const currentTile = tiles[index]; const isPlayerTile = currentTile === this.playerTile; // Display the tile's information const tileInfo = this.add.text(this.cameras.main.centerX, this.cameras.main.centerY - 100, `${this.specialColorNames[currentTile.color]}\nBackground: ${currentTile.background}\nPersonality: ${currentTile.personality}`, { font: '24px Arial', fill: '#ffffff', align: 'center', stroke: '#000000', strokeThickness: 3 } ); tileInfo.setOrigin(0.5); tileInfo.setScrollFactor(0); tileInfo.setDepth(1002); // If it's the player's tile, allow them to choose what to say if (isPlayerTile) { this.showPlayerChoices(currentTile, () => { tileInfo.destroy(); this.discussNextTile(tiles, index + 1); }); } else { // For AI tiles, generate a random statement const { statement, isLying, hasObservation } = this.generateAIStatement(currentTile); const statementText = this.add.text(this.cameras.main.centerX, this.cameras.main.centerY + 50, statement, { font: '20px Arial', fill: '#ffffff', align: 'center', stroke: '#000000', strokeThickness: 3 } ); statementText.setOrigin(0.5); statementText.setScrollFactor(0); statementText.setDepth(1002); const buttonY = this.cameras.main.centerY + 100; const buttonSpacing = 50; // Add a button for the player to call out a lie const callOutButton = this.add.text(this.cameras.main.centerX - 100, buttonY, "Call Out Lie", { font: '20px Arial', fill: '#ffffff', backgroundColor: '#000000', padding: { left: 10, right: 10, top: 5, bottom: 5 } } ); callOutButton.setOrigin(0.5); callOutButton.setInteractive({ useHandCursor: true }); callOutButton.on('pointerdown', () => this.handleCallOut(currentTile, isLying)); // Add a button to ask for elaboration if there's an observation let elaborateButton; if (hasObservation) { elaborateButton = this.add.text(this.cameras.main.centerX + 100, buttonY, "Ask to Elaborate", { font: '20px Arial', fill: '#ffffff', backgroundColor: '#000000', padding: { left: 10, right: 10, top: 5, bottom: 5 } } ); elaborateButton.setOrigin(0.5); elaborateButton.setInteractive({ useHandCursor: true }); elaborateButton.on('pointerdown', () => this.handleElaboration(currentTile)); } // Wait for a few seconds before moving to the next tile this.time.delayedCall(7000, () => { tileInfo.destroy(); statementText.destroy(); callOutButton.destroy(); if (elaborateButton) elaborateButton.destroy(); this.discussNextTile(tiles, index + 1); }); } } handleElaboration(tile) { const elaboration = this.generateElaboration(tile); const elaborationText = this.add.text(this.cameras.main.centerX, this.cameras.main.centerY + 150, elaboration, { font: '18px Arial', fill: '#ffffff', align: 'center', stroke: '#000000', strokeThickness: 2 } ); elaborationText.setOrigin(0.5); elaborationText.setScrollFactor(0); elaborationText.setDepth(1003); this.time.delayedCall(5000, () => { elaborationText.destroy(); }); } generateElaboration(tile) { const elaborations = [ "I'm not entirely sure, but it seemed very odd.", "It's hard to explain, but something just felt off about it.", "I wish I could give you more details, but that's all I noticed.", "I've been thinking about it, and it still doesn't make sense to me.", "Maybe it's nothing, but I thought it was worth mentioning.", "I don't want to jump to conclusions, but it definitely caught my attention." ]; return Phaser.Utils.Array.GetRandom(elaborations); } handleCallOut(tile, isLying) { let responseText; if (isLying) { responseText = `${this.specialColorNames[tile.color]} was indeed lying!`; // Implement consequences for catching a liar (e.g., remove the killer) this.removeSpecialTile(tile.x, tile.y); } else { responseText = `${this.specialColorNames[tile.color]} was telling the truth. Your accusation was false.`; // Implement consequences for false accusation (e.g., lose trust or a chance to vote) } const response = this.add.text(this.cameras.main.centerX, this.cameras.main.centerY + 150, responseText, { font: '20px Arial', fill: '#ffffff', align: 'center' } ); response.setOrigin(0.5); response.setScrollFactor(0); response.setDepth(1002); this.time.delayedCall(3000, () => { response.destroy(); }); } showPlayerChoices(playerTile, callback) { const choices = [ "I'm innocent and I saw something suspicious", "I didn't see anything unusual", "I think I know who the killer might be", "I prefer not to say anything" ]; const choiceButtons = choices.map((choice, index) => { const button = this.add.text(this.cameras.main.centerX, this.cameras.main.centerY + 50 + index * 40, choice, { font: '18px Arial', fill: '#ffffff', backgroundColor: '#000000', padding: { left: 10, right: 10, top: 5, bottom: 5 } } ); button.setOrigin(0.5); button.setInteractive({ useHandCursor: true }); button.setScrollFactor(0); button.setDepth(1002); button.on('pointerdown', () => { choiceButtons.forEach(b => b.destroy()); const playerStatement = this.add.text(this.cameras.main.centerX, this.cameras.main.centerY + 50, `You said: ${choice}`, { font: '20px Arial', fill: '#ffffff', align: 'center' } ); playerStatement.setOrigin(0.5); playerStatement.setScrollFactor(0); playerStatement.setDepth(1002); this.time.delayedCall(2000, () => { playerStatement.destroy(); callback(); }); }); return button; }); } generateRandomObservation() { const observations = [ "I saw [color] acting suspiciously near the [room].", "I heard a strange noise coming from the [room].", "I found a mysterious object in the [room].", "I noticed [color] and [color] whispering to each other.", "Something seemed off about the [room] earlier.", "I overheard an unusual conversation near the [room]." ]; let observation = Phaser.Utils.Array.GetRandom(observations); // Replace [room] with a random room type if (observation.includes("[room]")) { const roomTypes = ['bedroom', 'kitchen', 'living room', 'study', 'bathroom']; const randomRoom = Phaser.Utils.Array.GetRandom(roomTypes); observation = observation.replace("[room]", randomRoom); } // Replace [color] with random color names while (observation.includes("[color]")) { const randomColor = Phaser.Utils.Array.GetRandom(Object.values(this.specialColorNames)); observation = observation.replace("[color]", randomColor); } return observation; } generateAIStatement(tile) { const isKiller = tile.role === 'killer'; const isLying = isKiller && Math.random() < 0.5; let statement; if (!tile.observation && Math.random() < 0.3) { tile.observation = this.generateRandomObservation(); } if (tile.observation && Math.random() < 0.5) { statement = tile.observation; } else if (isLying) { const lieTypes = [ "I was in the [room] most of the time.", "I can vouch for [color], we were together in the [room]." ]; statement = Phaser.Utils.Array.GetRandom(lieTypes); } else { const truthfulStatements = [ "I didn't see anything suspicious.", "I think we should be careful and observe closely.", "Does anyone have any leads?", "Let's not jump to conclusions.", "I have a suspicion, but I'm not sure yet." ]; statement = Phaser.Utils.Array.GetRandom(truthfulStatements); } // Replace [room] with a random room type if (statement.includes("[room]")) { const roomTypes = ['bedroom', 'kitchen', 'living room', 'study', 'bathroom']; const randomRoom = Phaser.Utils.Array.GetRandom(roomTypes); statement = statement.replace("[room]", randomRoom); } // Replace [color] with a random color name, excluding the current tile's color if (statement.includes("[color]")) { const otherColors = Object.values(this.specialColorNames).filter(color => color !== this.specialColorNames[tile.color]); const randomColor = Phaser.Utils.Array.GetRandom(otherColors); statement = statement.replace("[color]", randomColor); } return { statement, isLying, hasObservation: !!tile.observation }; } endDiscussion() { // Display end of initial discussion message const endMessage = this.add.text(this.cameras.main.centerX, this.cameras.main.centerY, "Initial discussion has ended. Starting call-out phase!", { font: '32px Arial', fill: '#ffffff', align: 'center' } ); endMessage.setOrigin(0.5); endMessage.setScrollFactor(0); endMessage.setDepth(1002); // Wait for a few seconds, then start the second phase this.time.delayedCall(3000, () => { endMessage.destroy(); this.startSecondDiscussionPhase(); }); } startSecondDiscussionPhase() { // Get all special tiles (both killers and innocents) const allSpecialTiles = this.specialTiles; // Shuffle the array to randomize the order of discussion Phaser.Utils.Array.Shuffle(allSpecialTiles); // Start the second phase discussion for each tile this.discussNextTileSecondPhase(allSpecialTiles, 0); // Initialize voting-related properties this.votesCast = {}; this.playerCredibility = {}; this.specialTiles.forEach(tile => { this.playerCredibility[this.specialColorNames[tile.color]] = 1; // Start with neutral credibility }); } discussNextTileSecondPhase(tiles, index) { if (index >= tiles.length) { // All tiles have had their turn, end the second phase discussion this.endSecondDiscussionPhase(); return; } const currentTile = tiles[index]; const isPlayerTile = currentTile === this.playerTile; // Display the tile's information const tileInfo = this.add.text(this.cameras.main.centerX, this.cameras.main.centerY - 100, `${this.specialColorNames[currentTile.color]} is speaking`, { font: '24px Arial', fill: '#ffffff', align: 'center' } ); tileInfo.setOrigin(0.5); tileInfo.setScrollFactor(0); tileInfo.setDepth(1002); if (isPlayerTile) { this.showPlayerCallOutChoices(currentTile, () => { tileInfo.destroy(); this.discussNextTileSecondPhase(tiles, index + 1); }); } else { this.aiCallOut(currentTile, tiles, () => { tileInfo.destroy(); this.discussNextTileSecondPhase(tiles, index + 1); }); } } showPlayerCallOutChoices(playerTile, callback) { const choices = [ "I think someone was lying earlier", "I want to support someone's statement", "I have nothing more to add" ]; const choiceButtons = choices.map((choice, index) => { const button = this.add.text(this.cameras.main.centerX, this.cameras.main.centerY + 50 + index * 40, choice, { font: '18px Arial', fill: '#ffffff', backgroundColor: '#000000', padding: { left: 10, right: 10, top: 5, bottom: 5 } } ); button.setOrigin(0.5); button.setInteractive({ useHandCursor: true }); button.setScrollFactor(0); button.setDepth(1002); button.on('pointerdown', () => { choiceButtons.forEach(b => b.destroy()); if (index === 0) { this.showCallOutOptions(playerTile, callback); } else if (index === 1) { this.showSupportOptions(playerTile, callback); } else { callback(); } }); return button; }); } showCallOutOptions(playerTile, callback) { const otherTiles = this.specialTiles.filter(tile => tile !== playerTile); const options = otherTiles.map(tile => `Call out ${this.specialColorNames[tile.color]}`); options.push("Never mind, I don't want to call anyone out"); const optionButtons = options.map((option, index) => { const button = this.add.text(this.cameras.main.centerX, this.cameras.main.centerY + 50 + index * 40, option, { font: '18px Arial', fill: '#ffffff', backgroundColor: '#000000', padding: { left: 10, right: 10, top: 5, bottom: 5 } } ); button.setOrigin(0.5); button.setInteractive({ useHandCursor: true }); button.setScrollFactor(0); button.setDepth(1002); button.on('pointerdown', () => { optionButtons.forEach(b => b.destroy()); if (index < otherTiles.length) { this.handleCallOut(otherTiles[index], otherTiles[index].role === 'killer'); } callback(); }); return button; }); } showSupportOptions(playerTile, callback) { const otherTiles = this.specialTiles.filter(tile => tile !== playerTile); const options = otherTiles.map(tile => `Support ${this.specialColorNames[tile.color]}`); options.push("Never mind, I don't want to support anyone"); const optionButtons = options.map((option, index) => { const button = this.add.text(this.cameras.main.centerX, this.cameras.main.centerY + 50 + index * 40, option, { font: '18px Arial', fill: '#ffffff', backgroundColor: '#000000', padding: { left: 10, right: 10, top: 5, bottom: 5 } } ); button.setOrigin(0.5); button.setInteractive({ useHandCursor: true }); button.setScrollFactor(0); button.setDepth(1002); button.on('pointerdown', () => { optionButtons.forEach(b => b.destroy()); if (index < otherTiles.length) { this.handleSupport(otherTiles[index]); } callback(); }); return button; }); } aiCallOut(aiTile, allTiles, callback) { const otherTiles = allTiles.filter(tile => tile !== aiTile); const targetTile = Phaser.Utils.Array.GetRandom(otherTiles); const isKiller = aiTile.role === 'killer'; const callOutChance = isKiller ? 0.6 : 0.3; // Killers are more likely to call out if (Math.random() < callOutChance) { const accusation = this.generateAccusation(aiTile, targetTile); this.showDialogue(accusation, () => { this.handleInnocentReaction(targetTile, accusation, () => { this.handleOtherInnocentsReaction(aiTile, targetTile, allTiles, callback); }); }); } else { this.time.delayedCall(2000, callback); } } generateAccusation(accuser, accused) { const accusations = [ `I think ${this.specialColorNames[accused.color]} is acting suspiciously.`, `${this.specialColorNames[accused.color]} seems to be hiding something.`, `I don't trust ${this.specialColorNames[accused.color]}. They're too quiet.`, `${this.specialColorNames[accused.color]}'s story doesn't add up.`, `I saw ${this.specialColorNames[accused.color]} near the crime scene.` ]; return `${this.specialColorNames[accuser.color]}: ${Phaser.Utils.Array.GetRandom(accusations)}`; } handleInnocentReaction(accused, accusation, callback) { if (accused.role === 'innocent') { const isOffended = Math.random() < 0.7; // 70% chance to be offended let reaction; if (isOffended) { reaction = `${this.specialColorNames[accused.color]}: How dare you accuse me! I'm innocent!`; } else { reaction = `${this.specialColorNames[accused.color]}: I understand your suspicion, but I assure you I'm innocent.`; } this.showDialogue(reaction, callback); } else { callback(); } } handleOtherInnocentsReaction(accuser, accused, allTiles, callback) { const otherInnocents = allTiles.filter(tile => tile !== accuser && tile !== accused && tile.role === 'innocent'); if (otherInnocents.length > 0 && Math.random() < 0.5) { // 50% chance for another innocent to react const reacter = Phaser.Utils.Array.GetRandom(otherInnocents); const agreeWithKiller = Math.random() < 0.3; // 30% chance to agree with the killer let reaction; if (agreeWithKiller) { reaction = `${this.specialColorNames[reacter.color]}: I hate to say it, but ${this.specialColorNames[accuser.color]} might be right about ${this.specialColorNames[accused.color]}.`; this.playerCredibility[this.specialColorNames[accused.color]] -= 0.2; } else { reaction = `${this.specialColorNames[reacter.color]}: I don't think ${this.specialColorNames[accused.color]} is suspicious. We shouldn't jump to conclusions.`; this.playerCredibility[this.specialColorNames[accuser.color]] -= 0.1; } this.showDialogue(reaction, callback); } else { callback(); } } showDialogue(text, callback) { const dialogueBox = this.add.rectangle(this.cameras.main.centerX, this.cameras.main.centerY, 600, 100, 0x000000, 0.7); dialogueBox.setOrigin(0.5); dialogueBox.setScrollFactor(0); const dialogueText = this.add.text(this.cameras.main.centerX, this.cameras.main.centerY, text, { font: '18px Arial', fill: '#ffffff', align: 'center', wordWrap: { width: 580 } }); dialogueText.setOrigin(0.5); dialogueText.setScrollFactor(0); this.time.delayedCall(3000, () => { dialogueBox.destroy(); dialogueText.destroy(); callback(); }); } handleCallOut(targetTile, isLying) { let responseText; const targetColor = this.specialColorNames[targetTile.color]; if (isLying) { responseText = `${targetColor} was caught in a lie!`; targetTile.caughtLying = true; // Mark the tile as caught lying } else { responseText = `${targetColor} was telling the truth. The accusation was false.`; } // Increment the call-out count regardless of whether the accusation was true or false this.callOutCounts[targetColor] = (this.callOutCounts[targetColor] || 0) + 1; this.showResponseText(responseText); } handleSupport(targetTile) { const responseText = `${this.specialColorNames[targetTile.color]}'s statement was supported.`; this.showResponseText(responseText); } showResponseText(text) { const response = this.add.text(this.cameras.main.centerX, this.cameras.main.centerY + 150, text, { font: '20px Arial', fill: '#ffffff', align: 'center', stroke: '#000000', strokeThickness: 3 } ); response.setOrigin(0.5); response.setScrollFactor(0); response.setDepth(1002); this.time.delayedCall(3000, () => { response.destroy(); }); } endSecondDiscussionPhase() { // Display end of second phase discussion message const endMessage = this.add.text(this.cameras.main.centerX, this.cameras.main.centerY, "Call-out phase has ended. Time to vote!", { font: '32px Arial', fill: '#ffffff', align: 'center' } ); endMessage.setOrigin(0.5); endMessage.setScrollFactor(0); endMessage.setDepth(1002); // Wait for a few seconds, then start the voting phase this.time.delayedCall(3000, () => { endMessage.destroy(); this.startVotingPhase(); }); } startVotingPhase() { console.log("Voting phase started"); // Reset votes this.votesCast = {}; this.specialTiles.forEach(tile => { this.votesCast[this.specialColorNames[tile.color]] = 0; }); // Player voting this.showVotingOptions(); } showWeightedVotingOptions() { const votePrompt = this.add.text(this.cameras.main.centerX, this.cameras.main.centerY - 150, "It's time to vote! Who do you think is the killer?\nVote weight is based on how often a player was called out.", { font: '24px Arial', fill: '#ffffff', align: 'center' } ); votePrompt.setOrigin(0.5); votePrompt.setScrollFactor(0); const voteButtons = this.specialTiles.map((tile, index) => { const tileColor = this.specialColorNames[tile.color]; const callOutCount = this.callOutCounts[tileColor] || 0; const voteWeight = Math.max(1, callOutCount); // Minimum weight of 1 const button = this.add.text(this.cameras.main.centerX, this.cameras.main.centerY + index * 40, `${tileColor} (Weight: ${voteWeight})`, { font: '20px Arial', fill: '#ffffff', backgroundColor: '#000000', padding: { left: 10, right: 10, top: 5, bottom: 5 } } ); button.setOrigin(0.5); button.setInteractive({ useHandCursor: true }); button.setScrollFactor(0); button.on('pointerdown', () => { this.handlePlayerVote(tile, voteWeight); votePrompt.destroy(); voteButtons.forEach(b => b.destroy()); this.handleWeightedAIVoting(); }); return button; }); } handlePlayerVote(votedTile, voteWeight) { const votedColor = this.specialColorNames[votedTile.color]; this.votesCast[votedColor] = (this.votesCast[votedColor] || 0) + voteWeight; console.log(`Player voted for ${votedColor} with weight ${voteWeight}`); } handleWeightedAIVoting() { this.specialTiles.forEach(tile => { if (tile !== this.playerTile) { const votedTile = this.getAIVote(tile); const votedColor = this.specialColorNames[votedTile.color]; const voteWeight = Math.max(1, this.callOutCounts[votedColor] || 0); this.votesCast[votedColor] = (this.votesCast[votedColor] || 0) + voteWeight; console.log(`${this.specialColorNames[tile.color]} voted for ${votedColor} with weight ${voteWeight}`); } }); this.tallyVotes(); } getAIVote(voter) { if (voter.role === 'killer') { // Killers are more likely to vote for innocents const innocents = this.specialTiles.filter(tile => tile.role === 'innocent' && tile !== voter); return Phaser.Utils.Array.GetRandom(innocents); } else { // Innocents vote randomly, but can't vote for themselves const options = this.specialTiles.filter(tile => tile !== voter); return Phaser.Utils.Array.GetRandom(options); } } tallyVotes() { const sortedVotes = Object.entries(this.votesCast).sort((a, b) => b[1] - a[1]); const [eliminatedColor, highestVotes] = sortedVotes[0]; const eliminatedTile = this.specialTiles.find(tile => this.specialColorNames[tile.color] === eliminatedColor); this.showVotingResults(eliminatedColor, highestVotes, eliminatedTile.role); } showVotingResults(eliminatedColor, votes, role) { const resultText = this.add.text(this.cameras.main.centerX, this.cameras.main.centerY, `${eliminatedColor} has been eliminated with ${votes.toFixed(2)} weighted votes.\nThey were ${role === 'killer' ? 'a killer!' : 'an innocent...'}`, { font: '24px Arial', fill: '#ffffff', align: 'center' } ); resultText.setOrigin(0.5); resultText.setScrollFactor(0); this.time.delayedCall(5000, () => { resultText.destroy(); this.eliminatePlayer(eliminatedColor); // Automatically advance to the next hour after elimination this.time.delayedCall(1000, () => { this.advanceTimeAndReRandomize(); }); }); } showVotingResults(eliminatedColor, votes, role) { const resultText = this.add.text(this.cameras.main.centerX, this.cameras.main.centerY, `${eliminatedColor} has been eliminated with ${votes.toFixed(2)} weighted votes.\nThey were ${role === 'killer' ? 'a killer!' : 'an innocent...'}`, { font: '24px Arial', fill: '#ffffff', align: 'center' } ); resultText.setOrigin(0.5); resultText.setScrollFactor(0); this.time.delayedCall(5000, () => { resultText.destroy(); this.eliminatePlayer(eliminatedColor); }); } eliminatePlayer(eliminatedColor) { this.specialTiles = this.specialTiles.filter(tile => this.specialColorNames[tile.color] !== eliminatedColor); if (this.playerTile && this.specialColorNames[this.playerTile.color] === eliminatedColor) { this.playerTile = null; } this.updateGridAfterVoting(); this.redrawGrid(); this.checkGameOver(); } startVotingPhase() { console.log("Voting phase started"); // Remove tiles caught lying this.specialTiles = this.specialTiles.filter(tile => !tile.caughtLying); // Reset the camera zoom this.cameras.main.zoomTo(1, 1000); // Zoom back to normal over 1 second this.cameras.main.pan(this.cameras.main.width / 2, this.cameras.main.height / 2, 1000); // Center the camera // Reset votes this.votesCast = {}; // Show the weighted voting options this.showWeightedVotingOptions(); } updateGridAfterVoting() { // Clear all special tiles from the grid for (let y = 0; y < this.gridHeight; y++) { for (let x = 0; x < this.gridWidth; x++) { if (this.grid[y][x] === 6) { this.grid[y][x] = this.isInRoom(x, y) ? 2 : 0; } } } // Place the remaining special tiles on the grid this.specialTiles.forEach(tile => { this.grid[tile.y][tile.x] = 6; }); } redistributeSpecialTiles() { const killers = this.specialTiles.filter(tile => tile.role === 'killer'); const innocents = this.specialTiles.filter(tile => tile.role === 'innocent'); // Redistribute killers killers.forEach(tile => { let newPosition = this.findNewPosition(); if (newPosition) { this.grid[tile.y][tile.x] = this.isInRoom(tile.x, tile.y) ? 2 : 0; tile.x = newPosition.x; tile.y = newPosition.y; this.grid[newPosition.y][newPosition.x] = 6; } }); // Redistribute innocents innocents.forEach(tile => { let newPosition = this.findNewPosition(); if (newPosition) { this.grid[tile.y][tile.x] = this.isInRoom(tile.x, tile.y) ? 2 : 0; tile.x = newPosition.x; tile.y = newPosition.y; this.grid[newPosition.y][newPosition.x] = 6; } }); // Reassemble the specialTiles array this.specialTiles = [...killers, ...innocents]; // Redraw the grid to show the new positions this.redrawGrid(); console.log(`After redistribution: ${killers.length} killers, ${innocents.length} innocents`); } findNewPosition() { let attempts = 0; const maxAttempts = 100; while (attempts < maxAttempts) { const x = Phaser.Math.Between(0, this.gridWidth - 1); const y = Phaser.Math.Between(0, this.gridHeight - 1); if (this.grid[y][x] === 0 || this.grid[y][x] === 2) { return { x, y }; } attempts++; } console.warn('Could not find a new position for a special tile'); return null; } createNewSpecialTile() { const availableColors = Object.keys(this.specialColorNames).map(color => parseInt(color)); let attempts = 0; const maxAttempts = 100; while (attempts < maxAttempts) { const x = Phaser.Math.Between(0, this.gridWidth - 1); const y = Phaser.Math.Between(0, this.gridHeight - 1); if (this.grid[y][x] === 0 || this.grid[y][x] === 2 || this.grid[y][x] === 4) { const color = Phaser.Utils.Array.GetRandom(availableColors); this.grid[y][x] = 6; return { x, y, color }; } attempts++; } console.warn('Could not create a new special tile'); return null; } redrawGrid() { // Clear existing graphics this.container.removeAll(true); // Redraw all tiles for (let y = 0; y < this.gridHeight; y++) { for (let x = 0; x < this.gridWidth; x++) { this.drawTile(x, y); } } // Redraw wall segments this.drawWallSegments(); // Draw player tile border if it exists if (this.playerTile) { this.drawPlayerTileBorder(); } } drawWallSegments() { for (const segment of this.wallSegments) { const wallRect = this.add.rectangle( segment.x * this.tileSize + segment.width * this.tileSize / 2, segment.y * this.tileSize + segment.height * this.tileSize / 2, segment.width * this.tileSize, segment.height * this.tileSize, 0x8B4513 // Brown color for walls ); this.container.add(wallRect); } } drawPlayerTileBorder() { if (this.playerTile) { const borderGraphics = this.add.graphics(); borderGraphics.lineStyle(3, 0x000000, 1); // Changed to black (0x000000) borderGraphics.strokeRect( this.playerTile.x * this.tileSize, this.playerTile.y * this.tileSize, this.tileSize, this.tileSize ); this.container.add(borderGraphics); } } createGrid() { this.gridWidth = 50; this.gridHeight = 38; this.tileSize = 16; const colors = { brown: 0x8B4513, green: 0x228B22, tan: 0xD2B48C, lightGray: 0xD3D3D3 }; const backgrounds = [ 'Doctor', 'Lawyer', 'Teacher', 'Engineer', 'Artist', 'Chef', 'Police Officer', 'Firefighter', 'Scientist', 'Entrepreneur', 'Journalist', 'Athlete', 'Musician', 'Actor', 'Politician', 'Farmer', 'Librarian', 'Pilot', 'Architect', 'Nurse', 'Psychologist', 'Veterinarian', 'Photographer', 'Accountant', 'Plumber', 'Electrician', 'Mechanic', 'Salesperson', 'Designer', 'Programmer' ]; const personalities = [ 'Adventurous', 'Analytical', 'Caring', 'Creative', 'Determined', 'Easygoing', 'Energetic', 'Honest', 'Humorous', 'Idealistic', 'Imaginative', 'Logical', 'Loyal', 'Observant', 'Optimistic', 'Patient' ]; const motives = [ 'Revenge', 'Greed', 'Love', 'Fear', 'Power', 'Jealousy', 'Justice', 'Survival' ]; const assignRoomType = () => { const totalWeight = roomTypes.reduce((sum, type) => sum + type.weight, 0); let random = Math.random() * totalWeight; for (const roomType of roomTypes) { if (random < roomType.weight) { return roomType.type; } random -= roomType.weight; } return 'bedroom'; // Default to bedroom if something goes wrong }; const roomTypes = [{ type: 'bedroom', weight: 30 }, { type: 'kitchen', weight: 15 }, { type: 'dining room', weight: 10 }, { type: 'living room', weight: 15 }, { type: 'bathroom', weight: 10 }, { type: 'study', weight: 8 }, { type: 'game room', weight: 5 }, { type: 'storage', weight: 7 }]; const specialColorNames = { 0x000000: 'Eclipse Black', 0x00021c: 'Midnight Depths', 0x1c284d: 'Oceanic Twilight', 0x343473: 'Twilight Mist', 0x2d5280: 'Stormy Sea', 0x4d7a99: 'Dusk Blue', 0x7497a6: 'Frosted Aqua', 0xa3ccd9: 'Sky Reflection', 0xf0edd8: 'Whispering Sand', 0x732866: 'Violet Bloom', 0xa6216e: 'Berry Fizz', 0xd94c87: 'Raspberry Dream', 0xd9214f: 'Crimson Kiss', 0xf25565: 'Coral Splash', 0xf27961: 'Peach Sunset', 0x993649: 'Garnet Glint', 0xb36159: 'Copper Glow', 0xf09c60: 'Amber Dawn', 0xb38f24: 'Golden Harvest', 0xb3b324: 'Lime Zest', 0xf7c93e: 'Sunshine Yellow', 0x17735f: 'Forest Whisper', 0x119955: 'Emerald Wave', 0x67b31b: 'Lime Sprout', 0x1ba683: 'Teal Tide', 0x47cca9: 'Aqua Dreams', 0x96e3c9: 'Cerulean Bliss', 0x2469b3: 'Blue Horizon', 0x0b8be6: 'Electric Sky', 0x0bafe6: 'Aqua Aurora', 0xf28d85: 'Salmon Embrace', 0xf0bb90: 'Peachy Glow' }; const specialColors = Object.keys(specialColorNames).map(color => parseInt(color)); const createSpecialTiles = (previousColors = []) => { const numTiles = previousColors.length || Phaser.Math.RND.pick([8, 10, 12, 14, 16]); const availableColors = previousColors.length ? [...previousColors] : [...specialColors]; const specialTiles = []; const numKillers = Math.floor(numTiles * 0.25); // 25% of tiles are killers, rounded down for (let i = 0; i < numTiles; i++) { if (availableColors.length === 0) { break; // Stop if we've used all colors } let x, y; let attempts = 0; const maxAttempts = 100; do { x = Phaser.Math.Between(0, this.gridWidth - 1); y = Phaser.Math.Between(0, this.gridHeight - 1); attempts++; if (attempts >= maxAttempts) { console.warn('Could not find a valid position for a special tile'); break; } } while ( (this.grid[y][x] !== 0 && this.grid[y][x] !== 2 && this.grid[y][x] !== 4) || specialTiles.some(tile => tile.x === x && tile.y === y) ); if (attempts < maxAttempts) { const colorIndex = Phaser.Math.Between(0, availableColors.length - 1); const selectedColor = availableColors.splice(colorIndex, 1)[0]; const newTile = { x, y, color: selectedColor, role: specialTiles.length < numKillers ? 'killer' : 'innocent', background: Phaser.Utils.Array.GetRandom(backgrounds), personality: Phaser.Utils.Array.GetRandom(personalities), motive: Phaser.Utils.Array.GetRandom(motives) }; specialTiles.push(newTile); this.grid[y][x] = 6; // 6 will represent our special tiles // If this is the first tile, set it as the player tile and update the role display if (specialTiles.length === 1) { this.playerTile = newTile; this.updatePlayerRoleDisplay(); } } } return specialTiles; }; this.createSpecialTiles = createSpecialTiles; // Make it accessible to the class // Create a 2D array to represent the grid, initially filled with tan (0) this.grid = Array(this.gridHeight).fill().map(() => Array(this.gridWidth).fill(0)); const distanceBetween = (x1, y1, x2, y2) => { return Math.max(Math.abs(x1 - x2), Math.abs(y1 - y2)); }; const isRoomValidPosition = (room) => { const minDistanceFromEdge = 2; // Check distance from edges if (room.x < minDistanceFromEdge || room.y < minDistanceFromEdge || room.x + room.width > this.gridWidth - minDistanceFromEdge || room.y + room.height > this.gridHeight - minDistanceFromEdge) { return false; } return true; }; // Generate rooms this.rooms = []; const minRooms = 7; const maxRooms = 11; const numRooms = Phaser.Math.Between(minRooms, maxRooms); const minRoomSize = 5; const maxRoomSize = 7; const maxCoverage = 0.6; // Maximum 60% of non-green tiles can be rooms let totalRoomArea = 0; const totalNonGreenArea = this.gridWidth * this.gridHeight - Math.floor(this.gridWidth / 2) * Math.floor(this.gridHeight / 2); for (let i = 0; i < numRooms; i++) { let room; let attempts = 0; const maxAttempts = 100; do { room = { x: Phaser.Math.Between(2, this.gridWidth - maxRoomSize - 2), y: Phaser.Math.Between(2, this.gridHeight - maxRoomSize - 2), width: Phaser.Math.Between(minRoomSize, maxRoomSize), height: Phaser.Math.Between(minRoomSize, maxRoomSize), type: assignRoomType() }; // Snap to grid room.x = Math.floor(room.x / 2) * 2; room.y = Math.floor(room.y / 2) * 2; room.width = Math.ceil(room.width / 2) * 2; room.height = Math.ceil(room.height / 2) * 2; attempts++; } while ((!isRoomValidPosition(room) || this.roomsOverlap(room, this.rooms) || (totalRoomArea + room.width * room.height) / totalNonGreenArea > maxCoverage) && attempts < maxAttempts); if (attempts < maxAttempts) { this.rooms.push(room); totalRoomArea += room.width * room.height; } } // Remove this duplicate declaration const isRoomTile = (x, y) => { return this.rooms.some(room => x >= room.x && x < room.x + room.width && y >= room.y && y < room.y + room.height ); }; const isWallTile = (x, y) => { // Check if it's an outer wall if (x === 0 || x === this.gridWidth - 1 || y === 0 || y === this.gridHeight - 1) return true; // Check if it's already marked as a wall in the grid if (this.grid[y][x] === 3) return true; // Check if it's a room wall let isWall = false; for (const room of this.rooms) { if (x === room.x - 1 || x === room.x + room.width || y === room.y - 1 || y === room.y + room.height) { if (x >= room.x - 1 && x <= room.x + room.width && y >= room.y - 1 && y <= room.y + room.height) { isWall = true; break; } } } if (isWall) return true; return false; }; this.wallSegments = []; for (let y = 0; y < this.gridHeight; y++) { for (let x = 0; x < this.gridWidth; x++) { if (this.grid[y][x] === 3) { // Wall tile let segment = { x, y, width: 1, height: 1 }; // Check for horizontal extension while (x + segment.width < this.gridWidth && this.grid[y][x + segment.width] === 3) { segment.width++; } // Check for vertical extension let canExtendVertically = true; while (canExtendVertically && y + segment.height < this.gridHeight) { for (let i = 0; i < segment.width; i++) { if (this.grid[y + segment.height][x + i] !== 3) { canExtendVertically = false; break; } } if (canExtendVertically) segment.height++; } this.wallSegments.push(segment); x += segment.width - 1; // Skip the width we've just processed } } } // Fill the grid with appropriate values for (let y = 0; y < this.gridHeight; y++) { for (let x = 0; x < this.gridWidth; x++) { if (isRoomTile(x, y)) { this.grid[y][x] = 2; // Room } else if (isWallTile(x, y)) { this.grid[y][x] = 3; // Wall } // We don't need an else case here because the grid is already filled with 0 (tan) } } // Update wallSegments based on the grid this.wallSegments = []; for (let y = 0; y < this.gridHeight; y++) { for (let x = 0; x < this.gridWidth; x++) { if (this.grid[y][x] === 3) { // Wall tile let segment = { x, y, width: 1, height: 1 }; // Check for horizontal extension while (x + segment.width < this.gridWidth && this.grid[y][x + segment.width] === 3) { segment.width++; } // Check for vertical extension let canExtendVertically = true; while (canExtendVertically && y + segment.height < this.gridHeight) { for (let i = 0; i < segment.width; i++) { if (this.grid[y + segment.height][x + i] !== 3) { canExtendVertically = false; break; } } if (canExtendVertically) segment.height++; } this.wallSegments.push(segment); x += segment.width - 1; // Skip the width we've just processed } } } // We no longer need the flood fill operation // All non-room, non-wall areas are already tan (0) // The code for converting isolated tan areas to rooms can also be removed // Add doors to rooms for (const room of this.rooms) { const directions = ['top', 'right', 'bottom', 'left']; for (const direction of directions) { let doorX, doorY; switch (direction) { case 'top': doorX = Phaser.Math.Between(room.x, room.x + room.width - 2); doorY = room.y - 1; break; case 'right': doorX = room.x + room.width; doorY = Phaser.Math.Between(room.y, room.y + room.height - 2); break; case 'bottom': doorX = Phaser.Math.Between(room.x, room.x + room.width - 2); doorY = room.y + room.height; break; case 'left': doorX = room.x - 1; doorY = Phaser.Math.Between(room.y, room.y + room.height - 2); break; } if (this.isValidDoorLocation(doorX, doorY, this.grid, this.gridWidth, this.gridHeight)) { this.grid[doorY][doorX] = 5; // 5 represents a door if (direction === 'top' || direction === 'bottom') { this.grid[doorY][doorX + 1] = 5; } else { this.grid[doorY + 1][doorX] = 5; } } } } // Add entrances to interior const interiorEntrances = this.findInteriorEntrances(this.grid, this.gridWidth, this.gridHeight); for (const entrance of interiorEntrances) { this.grid[entrance.y][entrance.x] = 5; // 5 represents a door/entrance } // Create special tiles this.specialTiles = this.createSpecialTiles(); // Select a random special tile to be the player tile this.playerTile = Phaser.Utils.Array.GetRandom(this.specialTiles); // Draw tiles based on the updated grid for (let y = 0; y < this.gridHeight; y++) { for (let x = 0; x < this.gridWidth; x++) { let color; switch (this.grid[y][x]) { case 1: color = colors.green; break; case 2: const room = this.rooms.find(r => x >= r.x && x < r.x + r.width && y >= r.y && y < r.y + r.height); if (room) { switch (room.type) { case 'bedroom': color = 0xADD8E6; // Light blue break; case 'kitchen': color = 0x90EE90; // Light green break; case 'dining room': color = 0xFFDAB9; // Peach break; case 'living room': color = 0xFFB6C1; // Light pink break; case 'bathroom': color = 0xE6E6FA; // Lavender break; case 'study': color = 0xD2B48C; // Tan break; case 'game room': color = 0x98FB98; // Pale green break; case 'storage': color = 0xDCDCDC; // Gainsboro break; default: color = colors.lightGray; } } else { color = colors.lightGray; } break; case 3: continue; // Skip wall tiles, we'll draw them separately case 0: case 4: color = colors.tan; break; case 5: color = 0xFFA500; // Orange color for doors and entrances break; case 6: const specialTile = this.specialTiles.find(tile => tile.x === x && tile.y === y); color = specialTile ? specialTile.color : 0xFFFFFF; // Default to white if not found break; } const rect = this.add.rectangle( x * this.tileSize + this.tileSize / 2, y * this.tileSize + this.tileSize / 2, this.tileSize, this.tileSize, color ); this.container.add(rect); rect.setInteractive(); rect.on('pointerover', () => { if (this.grid[y][x] === 6) { const colorName = specialColorNames[color]; this.roomInfoText.setText('Special Colored Tile'); this.colorInfoText.setText(colorName); this.colorInfoText.setVisible(true); } else { const currentRoom = this.rooms.find(r => x >= r.x && x < r.x + r.width && y >= r.y && y < r.y + r.height); if (currentRoom) { this.roomInfoText.setText(`Room Type: ${currentRoom.type}`); this.colorInfoText.setVisible(false); } else if (this.grid[y][x] === 5) { this.roomInfoText.setText('Door'); this.colorInfoText.setVisible(false); } else { // Do not show any text for tan (0 or 4) or green (1) tiles this.roomInfoText.setText(''); this.colorInfoText.setVisible(false); } } if (this.colorInfoText.visible) { this.colorInfoText.setPosition( rect.x - this.colorInfoText.width / 2, rect.y - this.tileSize - this.colorInfoText.height ); } }); rect.on('pointerout', () => { this.roomInfoText.setText(''); this.colorInfoText.setVisible(false); }); } } // Draw merged wall segments for (const segment of this.wallSegments) { const wallRect = this.add.rectangle( segment.x * this.tileSize + segment.width * this.tileSize / 2, segment.y * this.tileSize + segment.height * this.tileSize / 2, segment.width * this.tileSize, segment.height * this.tileSize, colors.brown ); this.container.add(wallRect); } // Create white border around the player tile if (this.playerTile) { const borderGraphics = this.add.graphics(); borderGraphics.lineStyle(2, 0xFFFFFF, 1); borderGraphics.strokeRect( this.playerTile.x * this.tileSize, this.playerTile.y * this.tileSize, this.tileSize, this.tileSize ); this.container.add(borderGraphics); } } drawTile(x, y) { let color; switch (this.grid[y][x]) { case 1: color = 0x228B22; // Green break; case 2: const room = this.rooms.find(r => x >= r.x && x < r.x + r.width && y >= r.y && y < r.y + r.height); if (room) { switch (room.type) { case 'bedroom': color = 0xADD8E6; // Light blue break; case 'kitchen': color = 0x90EE90; // Light green break; case 'dining room': color = 0xFFDAB9; // Peach break; case 'living room': color = 0xFFB6C1; // Light pink break; case 'bathroom': color = 0xE6E6FA; // Lavender break; case 'study': color = 0xD2B48C; // Tan break; case 'game room': color = 0x98FB98; // Pale green break; case 'storage': color = 0xDCDCDC; // Gainsboro break; default: color = 0xD3D3D3; // Light gray } } else { color = 0xD3D3D3; // Light gray } break; case 3: color = 0x8B4513; // Brown (for walls) break; case 0: case 4: color = 0xD2B48C; // Tan break; case 5: color = 0xFFA500; // Orange color for doors and entrances break; case 6: const specialTile = this.specialTiles.find(tile => tile.x === x && tile.y === y); color = specialTile ? specialTile.color : 0xD2B48C; // Default to tan if not found break; default: color = 0xD2B48C; // Default to tan for unknown tiles } // Draw the tile const rect = this.add.rectangle( x * this.tileSize + this.tileSize / 2, y * this.tileSize + this.tileSize / 2, this.tileSize, this.tileSize, color ); this.container.add(rect); // Draw black border only for the player tile if (this.playerTile && this.playerTile.x === x && this.playerTile.y === y) { const borderGraphics = this.add.graphics(); borderGraphics.lineStyle(2, 0x000000, 1); // Black border borderGraphics.strokeRect( x * this.tileSize, y * this.tileSize, this.tileSize, this.tileSize ); this.container.add(borderGraphics); } // Add interactivity and hover effects const hitArea = this.add.rectangle( x * this.tileSize + this.tileSize / 2, y * this.tileSize + this.tileSize / 2, this.tileSize, this.tileSize ); hitArea.setInteractive(); hitArea.on('pointerover', () => this.handleTileHover(x, y, hitArea)); hitArea.on('pointerout', () => this.handleTileHoverExit()); this.container.add(hitArea); } handleTileHover(x, y, rect) { if (this.grid[y][x] === 6) { const specialTile = this.specialTiles.find(tile => tile.x === x && tile.y === y); const colorName = this.specialColorNames[specialTile.color]; this.roomInfoText.setText('Special Colored Tile'); this.colorInfoText.setText(`${colorName}\nBackground: ${specialTile.background}\nPersonality: ${specialTile.personality}\nMotive: ${specialTile.motive}`); this.colorInfoText.setVisible(true); this.colorInfoText.setPosition( rect.x - this.colorInfoText.width / 2, rect.y - this.tileSize - this.colorInfoText.height ); } else { const room = this.rooms.find(r => x >= r.x && x < r.x + r.width && y >= r.y && y < r.y + r.height); if (room) { this.roomInfoText.setText(`Room Type: ${room.type}`); } else if (this.grid[y][x] === 5) { this.roomInfoText.setText('Door'); } else { this.roomInfoText.setText(''); } this.colorInfoText.setVisible(false); } } handleTileHoverExit() { this.roomInfoText.setText(''); this.colorInfoText.setVisible(false); } roomsOverlap(room, otherRooms) { return otherRooms.some(otherRoom => !(room.x + room.width < otherRoom.x || otherRoom.x + otherRoom.width < room.x || room.y + room.height < otherRoom.y || otherRoom.y + otherRoom.height < room.y) ); } isValidDoorLocation(x, y, grid, gridWidth, gridHeight) { // Check if the location is within the grid if (x < 0 || x >= gridWidth || y < 0 || y >= gridHeight) { return false; } // Check if the location is a wall tile if (grid[y][x] !== 3) { return false; } // Check if there's a tan tile or room tile on either side const leftOrRight = (grid[y][x - 1] === 0 || grid[y][x - 1] === 2 || grid[y][x - 1] === 4) && (grid[y][x + 1] === 0 || grid[y][x + 1] === 2 || grid[y][x + 1] === 4); const topOrBottom = (grid[y - 1] && (grid[y - 1][x] === 0 || grid[y - 1][x] === 2 || grid[y - 1][x] === 4)) && (grid[y + 1] && (grid[y + 1][x] === 0 || grid[y + 1][x] === 2 || grid[y + 1][x] === 4)); return leftOrRight || topOrBottom; } findInteriorEntrances(grid, gridWidth, gridHeight) { const entrances = []; for (let y = 1; y < gridHeight - 1; y++) { for (let x = 1; x < gridWidth - 1; x++) { if (grid[y][x] === 3) { // If it's a wall const adjacentTiles = [{ x: x - 1, y: y }, { x: x + 1, y: y }, { x: x, y: y - 1 }, { x: x, y: y + 1 }]; const interiorAdjacent = adjacentTiles.filter(tile => grid[tile.y][tile.x] === 0 || grid[tile.y][tile.x] === 4 ); const roomAdjacent = adjacentTiles.filter(tile => grid[tile.y][tile.x] === 2 ); if (interiorAdjacent.length > 0 && roomAdjacent.length > 0) { entrances.push({ x, y }); } } } } return entrances; } isInRoom(x, y) { return this.rooms.some(room => x >= room.x && x < room.x + room.width && y >= room.y && y < room.y + room.height ); } updateTimeAndPeopleText() { this.timeText.setText(`Day ${this.day}, Hour ${this.hour}`); this.peopleText.setText(`People left: ${this.specialTiles.length}`); } updatePlayerRoleDisplay() { if (this.playerRoleText) { if (this.playerTile) { this.playerRoleText.setText(`Your Role: ${this.playerTile.role}`); } else { this.playerRoleText.setText('Your Role: Not assigned'); } } } } const config = { type: Phaser.AUTO, 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: Example }; window.phaserGame = new Phaser.Game(config);