class Example extends Phaser.Scene { constructor() { super(); this.showGrid = false; this.rooms = {}; this.roomDirectionIndicators = {}; // New property to store direction indicators for all rooms this.hasKey = false; // New property to track if the player has found the key this.controlsShown = false; this.currentRoom = 'roomForward'; this.initialMessage = "This is a fake 3D maze generator. Feel free to report any bug you ran into."; this.roomKeys = [{ key: 'fourWayRoom', number: 1 }, { key: 'verticalRoom', number: 2 }, { key: 'horizontalRoom', number: 3 }, { key: 'rightOnlyRoom', number: 4 }, { key: 'leftOnlyRoom', number: 5 }, { key: 'forwardOnlyRoom', number: 6 }, { key: 'backOnlyRoom', number: 7 }, { key: 'rightUpRoom', number: 8 }, { key: 'rightDownRoom', number: 9 }, { key: 'leftUpRoom', number: 10 }, { key: 'leftDownRoom', number: 11 }, { key: 'downUpLeftRoom', number: 12 }, { key: 'downUpRightRoom', number: 13 }]; this.playerMarker = null; this.playerPosition = { x: 0, y: 9 }; // Bottom-left corner this.fadeDuration = 200; // Duration of fade transition in milliseconds this.discoveredRooms = []; // New array to keep track of discovered rooms this.previousRoom = null; // To keep track of the previous room this.lastDirection = null; // To keep track of the last direction moved this.roomMemory = {}; // New object to store room memories this.disableMapAndX = false; // Changed to false to enable the map system this.previousDirection = null; // To keep track of the previous direction this.grid = null; // To store the grid graphics object this.playerX = null; // To store the player X marker this.directionIndicators = null; // To store the direction indicators this.messageText = null; // To store the message text this.gridRooms = {}; // New object to store rooms for each grid position this.visitedSquares = {}; // New object to track visited squares this.generatingText = null; // To store the "Generating Maze" text this.roomTypeText = null; // To store the room type text this.generationInterval = 10; // Significantly reduced interval for much faster generation this.generationTimer = null; // Timer for room generation this.currentGenerationPosition = { x: 0, y: 0 }; // Current position for room generation this.generatedRoomsList = []; // New array to store generated rooms this.consoleText = null; // To store the console-like text this.fastGeneration = true; // New flag to indicate fast generation mode this.mazeGenerated = false; // Flag to check if maze generation is complete this.gameStarted = false; // Flag to check if the game has started this.scrollOffset = 0; // To keep track of scroll position this.availablePositions = []; // New array to store available positions for room placement this.isFirstRoom = true; // New flag to check if it's the first room being generated this.keyRoomPosition = null; // To store the position of the KEYROOM this.oneDirectionRoomCount = 0; // New counter for one-direction rooms this.fourDirectionRoomCount = 0; // New counter for four-direction rooms this.startTime = null; // To store the start time of the game this.downArrow = null; // New property to store the down arrow graphics } generateSeed() { return Math.floor(Math.random() * 1000000).toString(); } preload() { this.load.image('fourWayRoom', 'https://play.rosebud.ai/assets/RoomFowardRightLeft.png?tQ2v'); this.load.image('verticalRoom', 'https://play.rosebud.ai/assets/RoomFoward.png?VCAi'); this.load.image('horizontalRoom', 'https://play.rosebud.ai/assets/RoomRightLeft.png?GOkC'); this.load.image('rightOnlyRoom', 'https://play.rosebud.ai/assets/RoomRight.png?HBQg'); this.load.image('leftOnlyRoom', 'https://play.rosebud.ai/assets/RoomLeft.png?bpi4'); this.load.image('forwardOnlyRoom', 'https://play.rosebud.ai/assets/RoomFoward.png?VCAi'); this.load.image('backOnlyRoom', 'https://play.rosebud.ai/assets/Roomback.png?lzz0'); this.load.image('rightUpRoom', 'https://play.rosebud.ai/assets/RoomFowardRight.png?pGLl'); this.load.image('rightDownRoom', 'https://play.rosebud.ai/assets/RoomRight.png?HBQg'); this.load.image('leftUpRoom', 'https://play.rosebud.ai/assets/RoomFowardLeft.png?dPKL'); this.load.image('leftDownRoom', 'https://play.rosebud.ai/assets/RoomLeft.png?bpi4'); this.load.image('downUpLeftRoom', 'https://play.rosebud.ai/assets/RoomFowardLeft.png?dPKL'); this.load.image('downUpRightRoom', 'https://play.rosebud.ai/assets/RoomFowardRight.png?pGLl'); } create() { // Initialize properties that were previously only set in the constructor this.showGrid = false; this.rooms = {}; this.seed = this.generateSeed(); // Generate and store a seed this.rng = new Phaser.Math.RandomDataGenerator([this.seed]); // Create a seeded RNG this.roomDirectionIndicators = {}; this.hasKey = false; this.controlsShown = false; this.currentRoom = 'roomForward'; this.playerPosition = { x: 0, y: 9 }; this.discoveredRooms = []; this.previousRoom = null; this.lastDirection = null; this.roomMemory = {}; this.disableMapAndX = false; this.previousDirection = null; this.visitedSquares = {}; this.generatedRoomsList = []; this.mazeGenerated = false; this.gameStarted = false; this.scrollOffset = 0; this.availablePositions = []; this.isFirstRoom = true; this.keyRoomPosition = null; this.oneDirectionRoomCount = 0; this.fourDirectionRoomCount = 0; this.keyRoomRevealed = false; // Create the rooms roster with allowed directions this.rooms = { fourWayRoom: { image: this.add.image(0, 0, 'fourWayRoom'), allowedDirections: ['up', 'down', 'left', 'right'], number: 1 }, verticalRoom: { image: this.add.image(0, 0, 'verticalRoom'), allowedDirections: ['up', 'down'], number: 2 }, horizontalRoom: { image: this.add.image(0, 0, 'horizontalRoom'), allowedDirections: ['left', 'right'], number: 3 }, rightOnlyRoom: { image: this.add.image(0, 0, 'rightOnlyRoom'), allowedDirections: ['right'], number: 4 }, leftOnlyRoom: { image: this.add.image(0, 0, 'leftOnlyRoom'), allowedDirections: ['left'], number: 5 }, forwardOnlyRoom: { image: this.add.image(0, 0, 'forwardOnlyRoom'), allowedDirections: ['up'], number: 6 }, backOnlyRoom: { image: this.add.image(0, 0, 'backOnlyRoom'), allowedDirections: ['down'], number: 7 }, rightUpRoom: { image: this.add.image(0, 0, 'rightUpRoom'), allowedDirections: ['right', 'up'], number: 8 }, rightDownRoom: { image: this.add.image(0, 0, 'rightDownRoom'), allowedDirections: ['right', 'down'], number: 9 }, leftUpRoom: { image: this.add.image(0, 0, 'leftUpRoom'), allowedDirections: ['left', 'up'], number: 10 }, leftDownRoom: { image: this.add.image(0, 0, 'leftDownRoom'), allowedDirections: ['left', 'down'], number: 11 }, downUpLeftRoom: { image: this.add.image(0, 0, 'downUpLeftRoom'), allowedDirections: ['down', 'up', 'left'], number: 12 }, downUpRightRoom: { image: this.add.image(0, 0, 'downUpRightRoom'), allowedDirections: ['down', 'up', 'right'], number: 13 } }; // Set up each room image for (let room in this.rooms) { this.rooms[room].image.setOrigin(0, 0); this.rooms[room].image.setDisplaySize(this.sys.game.config.width, this.sys.game.config.height); this.rooms[room].image.setVisible(false); } // Create initial game title text this.generatingText = this.add.text(this.sys.game.config.width / 2, 50, '3D Neon Maze', { fontFamily: 'Arial', fontSize: 42, color: '#00ff00', fontStyle: 'bold' }); this.generatingText.setOrigin(0.5); this.generatingText.setShadow(0, 0, '#00ffff', 8, true, true); // Add "Made by Pocok155" text this.madeByText = this.add.text(this.sys.game.config.width / 2, 100, 'Made by Pocok155', { fontFamily: 'Arial', fontSize: 24, color: '#00ff00', fontStyle: 'italic' }); this.madeByText.setOrigin(0.5); this.madeByText.setShadow(0, 0, '#00ffff', 4, true, true); // Create console-like text this.consoleText = this.add.text(10, 100, '', { fontFamily: 'Courier', fontSize: 26, color: '#ffffff', wordWrap: { width: this.sys.game.config.width - 20 } }); // Show initial message instead of starting maze generation this.showInitialMessage(); // Add key input this.input.keyboard.on('keydown-UP', this.handleUpArrow, this); this.input.keyboard.on('keydown-LEFT', this.handleLeftArrow, this); this.input.keyboard.on('keydown-RIGHT', this.handleRightArrow, this); this.input.keyboard.on('keydown-DOWN', this.handleDownArrow, this); this.input.keyboard.on('keydown-M', this.toggleMap, this); this.input.keyboard.on('keydown-K', this.revealKeyRoom, this); this.input.keyboard.on('keydown-ENTER', this.startGame, this); this.keyRoomRevealed = false; // New property to track if key room has been revealed // Create fade rectangle this.fadeRect = this.add.rectangle(0, 0, this.sys.game.config.width, this.sys.game.config.height, 0x000000); this.fadeRect.setOrigin(0, 0); this.fadeRect.setAlpha(0); // Create the grid this.grid = this.add.graphics(); this.drawGrid(); this.grid.setVisible(false); // Create the player X marker this.playerX = this.add.graphics(); // Create the direction indicators this.directionIndicators = this.add.graphics(); this.directionIndicators.setVisible(false); this.drawPlayerX(); this.playerX.setVisible(false); // Create message text this.messageText = this.add.text(this.sys.game.config.width / 2, this.sys.game.config.height - 50, '', { fontFamily: 'Arial', fontSize: 28, color: '#ffffff' }); this.messageText.setOrigin(0.5); this.messageText.setVisible(false); // Create the down arrow this.downArrow = this.add.graphics(); this.drawDownArrow(); this.downArrow.setVisible(false); } drawDownArrow() { this.downArrow.clear(); this.downArrow.fillStyle(0x000000, 1); // Black color const arrowWidth = 30; const arrowHeight = 20; const x = this.sys.game.config.width / 2; const y = this.sys.game.config.height - 30; this.downArrow.beginPath(); this.downArrow.moveTo(x, y); this.downArrow.lineTo(x - arrowWidth / 2, y - arrowHeight); this.downArrow.lineTo(x + arrowWidth / 2, y - arrowHeight); this.downArrow.closePath(); this.downArrow.fillPath(); } showInitialMessage() { const messageText = this.add.text(this.sys.game.config.width / 2, this.sys.game.config.height / 2, this.initialMessage, { fontFamily: 'Arial', fontSize: 24, color: '#ffffff', align: 'center', wordWrap: { width: this.sys.game.config.width - 100 } }); messageText.setOrigin(0.5); const pressEnterText = this.add.text(this.sys.game.config.width / 2, this.sys.game.config.height / 2 + 100, 'Press ENTER to start generating', { fontFamily: 'Arial', fontSize: 20, color: '#ffffff' }); pressEnterText.setOrigin(0.5); const enterKey = this.input.keyboard.addKey('ENTER'); enterKey.once('down', () => { messageText.destroy(); pressEnterText.destroy(); this.startGeneratingMaze(); }); } startGeneratingMaze() { // Change the text to indicate maze generation this.generatingText.setText('Maze Generated'); this.generatingText.setColor('#ffffff'); this.generatingText.setFontStyle('normal'); this.generatingText.setShadow(0, 0, '#ffffff', 0); // Hide the "Made by" text this.madeByText.setVisible(false); // Create a list of all available positions for (let x = 0; x < 10; x++) { for (let y = 0; y < 10; y++) { this.availablePositions.push({ x, y }); } } // Shuffle the available positions using the seeded RNG Phaser.Utils.Array.Shuffle(this.availablePositions, this.rng); // Place the key room first this.keyRoomPosition = this.availablePositions.pop(); this.gridRooms[`${this.keyRoomPosition.x},${this.keyRoomPosition.y}`] = 'fourWayRoom'; // Start with a four-way room for the key room this.generatedRoomsList.push(`Generated: KEYROOM (fourWayRoom) at (${this.keyRoomPosition.x}, ${this.keyRoomPosition.y})`); this.fourDirectionRoomCount++; if (this.fastGeneration) { while (this.availablePositions.length > 0) { this.generateNextRoom(); } this.finishMazeGeneration(); } else { this.generationTimer = this.time.addEvent({ delay: this.generationInterval, callback: this.generateNextRoom, callbackScope: this, loop: true }); } } generateNextRoom() { if (this.availablePositions.length === 0) { // Maze generation complete this.generationTimer.remove(); this.finishMazeGeneration(); return; } const position = this.availablePositions.pop(); const gridKey = `${position.x},${position.y}`; // Get compatible room types based on adjacent rooms let compatibleRoomTypes = this.getCompatibleRoomTypes(position.x, position.y); // For the starting room (0, 9), ensure it allows moving forward or right or both if (position.x === 0 && position.y === 9) { compatibleRoomTypes = compatibleRoomTypes.filter(roomType => (this.rooms[roomType].allowedDirections.includes('up') || this.rooms[roomType].allowedDirections.includes('right')) && !this.rooms[roomType].allowedDirections.includes('left') && !this.rooms[roomType].allowedDirections.includes('down') ); } if (compatibleRoomTypes.length === 0) { // If no compatible room types, skip this position this.generatedRoomsList.push(`Skipped: No compatible room at (${position.x}, ${position.y})`); return; } // Choose a random compatible room type const randomIndex = Phaser.Math.Between(0, compatibleRoomTypes.length - 1); const roomType = compatibleRoomTypes[randomIndex]; this.gridRooms[gridKey] = roomType; if (!this.fastGeneration) { this.generatedRoomsList.push(`Generated: ${roomType} at (${position.x}, ${position.y})`); } // Update room type counts const directions = this.rooms[roomType].allowedDirections; if (directions.length === 1) { this.oneDirectionRoomCount++; } else if (directions.length === 4) { this.fourDirectionRoomCount++; } // Check adjacent squares only if not in fast generation mode if (!this.fastGeneration) { this.checkAdjacentSquares(position.x, position.y); } } getCompatibleRoomTypes(x, y) { const adjacentRooms = this.getAdjacentRooms(x, y); const compatibleRoomTypes = []; for (let roomType in this.rooms) { if (this.isRoomCompatible(roomType, adjacentRooms, x, y)) { compatibleRoomTypes.push(roomType); } } return this.enforceCornerRules(compatibleRoomTypes, x, y); } enforceCornerRules(compatibleRoomTypes, x, y) { if (x === 0 && y === 0) { // 0,0 room cannot allow up and left direction return compatibleRoomTypes.filter(roomType => !this.rooms[roomType].allowedDirections.includes('up') && !this.rooms[roomType].allowedDirections.includes('left') ); } else if (x === 9 && y === 0) { // 9,0 room must allow down direction and cannot allow right direction return compatibleRoomTypes.filter(roomType => this.rooms[roomType].allowedDirections.includes('down') && !this.rooms[roomType].allowedDirections.includes('right') ); } else if (x === 0 && y === 9) { // 0,9 Room never allow down and left direction return compatibleRoomTypes.filter(roomType => !this.rooms[roomType].allowedDirections.includes('down') && !this.rooms[roomType].allowedDirections.includes('left') ); } else if (x === 9 && y === 9) { // 9,9 room never allow down and right direction return compatibleRoomTypes.filter(roomType => !this.rooms[roomType].allowedDirections.includes('down') && !this.rooms[roomType].allowedDirections.includes('right') ); } else if (x === 0 && y >= 1 && y <= 8) { // Left edge rooms (0, 1) to (0, 8) cannot allow left direction return compatibleRoomTypes.filter(roomType => !this.rooms[roomType].allowedDirections.includes('left') ); } else if (x === 9 && y >= 1 && y <= 8) { // Right edge rooms (9, 1) to (9, 8) cannot allow right direction return compatibleRoomTypes.filter(roomType => !this.rooms[roomType].allowedDirections.includes('right') ); } else if (y === 0 && x >= 1 && x <= 8) { // Top edge rooms (1, 0) to (8, 0) cannot allow up direction return compatibleRoomTypes.filter(roomType => !this.rooms[roomType].allowedDirections.includes('up') ); } else if (y === 9 && x >= 1 && x <= 8) { // Bottom edge rooms (1, 9) to (8, 9) cannot allow down direction return compatibleRoomTypes.filter(roomType => !this.rooms[roomType].allowedDirections.includes('down') ); } return compatibleRoomTypes; } getAdjacentRooms(x, y) { const adjacentRooms = { up: this.gridRooms[`${x},${y-1}`], down: this.gridRooms[`${x},${y+1}`], left: this.gridRooms[`${x-1},${y}`], right: this.gridRooms[`${x+1},${y}`] }; return adjacentRooms; } isRoomCompatible(roomType, adjacentRooms, x, y) { const room = this.rooms[roomType]; // Check if the room's allowed directions match with adjacent rooms for (let direction in adjacentRooms) { if (adjacentRooms[direction]) { const adjacentRoom = this.rooms[adjacentRooms[direction]]; if (!adjacentRoom) { console.warn(`Adjacent room ${adjacentRooms[direction]} not found`); return false; } const oppositeDirection = this.getOppositeDirection(direction); if (room.allowedDirections.includes(direction) !== adjacentRoom.allowedDirections.includes(oppositeDirection)) { return false; } } } // Enforce edge rules if (x === 0 && room.allowedDirections.includes('left')) { return false; } if (x === 9 && room.allowedDirections.includes('right')) { return false; } if (y === 0 && room.allowedDirections.includes('up')) { return false; } if (y === 9 && room.allowedDirections.includes('down')) { return false; } return true; } getOppositeDirection(direction) { const opposites = { up: 'down', down: 'up', left: 'right', right: 'left' }; return opposites[direction]; } checkAdjacentSquares(x, y) { const directions = [{ dx: 0, dy: -1, name: 'above' }, { dx: 0, dy: 1, name: 'below' }, { dx: 1, dy: 0, name: 'right' }, { dx: -1, dy: 0, name: 'left' }]; directions.forEach(dir => { const newX = x + dir.dx; const newY = y + dir.dy; const newKey = `${newX},${newY}`; if (newX < 0 || newX > 9 || newY < 0 || newY > 9) { this.generatedRoomsList.push(`Checked: ${dir.name} (${newX}, ${newY}) - Border`); } else if (this.gridRooms[newKey]) { const roomType = this.gridRooms[newKey]; const room = this.rooms[roomType]; if (room) { const allowedDirections = room.allowedDirections.join(', '); this.generatedRoomsList.push(`Checked: ${dir.name} (${newX}, ${newY}) - ${roomType} (Allowed: ${allowedDirections})`); } else { this.generatedRoomsList.push(`Checked: ${dir.name} (${newX}, ${newY}) - ${roomType} (Room not found)`); } } else { this.generatedRoomsList.push(`Checked: ${dir.name} (${newX}, ${newY}) - empty`); } }); } finishMazeGeneration() { let attempts = 0; const maxAttempts = 10; while (attempts < maxAttempts) { // Ensure there's a path from the starting room to the key room if (!this.isKeyRoomReachable()) { this.resetMazeGeneration(); attempts++; continue; } // Ensure the top right corner is accessible from the starting point if (!this.isPositionReachable(9, 0)) { this.resetMazeGeneration(); attempts++; continue; } // Ensure the top right corner has a downward path const topRightRoom = this.gridRooms['9,0']; if (!topRightRoom || !this.rooms[topRightRoom].allowedDirections.includes('down')) { this.resetMazeGeneration(); attempts++; continue; } // If all conditions are met, break the loop break; } if (attempts === maxAttempts) { console.error('Failed to generate a valid maze after maximum attempts'); } this.mazeGenerated = true; // Generate the final room list for display this.generatedRoomsList = []; for (let x = 0; x < 10; x++) { for (let y = 0; y < 10; y++) { const roomType = this.gridRooms[`${x},${y}`]; if (roomType) { this.generatedRoomsList.push(`Generated: ${roomType} at (${x}, ${y})`); } } } } resetMazeGeneration() { this.gridRooms = {}; this.generatedRoomsList = []; this.isFirstRoom = true; this.keyRoomPosition = null; this.availablePositions = []; this.oneDirectionRoomCount = 0; this.fourDirectionRoomCount = 0; this.startGeneratingMaze(); } isKeyRoomReachable() { return this.isPositionReachable(this.keyRoomPosition.x, this.keyRoomPosition.y); } isPositionReachable(targetX, targetY) { const visited = new Set(); const stack = [{ x: 0, y: 9 }]; // Start from the starting room while (stack.length > 0) { const { x, y } = stack.pop(); const key = `${x},${y}`; if (visited.has(key)) continue; visited.add(key); if (x === targetX && y === targetY) { return true; // Target position is reachable } const currentRoom = this.gridRooms[key]; if (!currentRoom || !this.rooms[currentRoom]) { console.warn(`Room not found for position (${x}, ${y})`); continue; } const allowedDirections = this.rooms[currentRoom].allowedDirections; if (allowedDirections.includes('up') && y > 0) stack.push({ x, y: y - 1 }); if (allowedDirections.includes('down') && y < 9) stack.push({ x, y: y + 1 }); if (allowedDirections.includes('left') && x > 0) stack.push({ x: x - 1, y }); if (allowedDirections.includes('right') && x < 9) stack.push({ x: x + 1, y }); } return false; // Target position is not reachable } startGame() { if (!this.mazeGenerated || this.gameStarted) return; if (!this.controlsShown) { this.showControlsMessage(); return; } this.gameStarted = true; this.startTime = new Date(); // Set the start time this.generatingText.setVisible(false); this.consoleText.setVisible(false); // Mark the initial square as visited this.markSquareAsVisited(this.playerPosition.x, this.playerPosition.y); // Show the initial room this.currentRoom = this.gridRooms[`${this.playerPosition.x},${this.playerPosition.y}`]; if (this.currentRoom && this.rooms[this.currentRoom]) { this.rooms[this.currentRoom].image.setVisible(true); } else { console.warn('Initial room not found'); } this.updateRoomTypeText(); // Enable player movement this.input.keyboard.enabled = true; // Update down arrow visibility this.updateDownArrowVisibility(); } copyToClipboard(text) { const textArea = document.createElement('textarea'); textArea.value = text; document.body.appendChild(textArea); textArea.select(); try { document.execCommand('copy'); console.log('Text copied to clipboard'); } catch (err) { console.error('Failed to copy text: ', err); } document.body.removeChild(textArea); } showControlsMessage() { this.controlsShown = true; const controlsText = this.add.text(this.sys.game.config.width / 2, this.sys.game.config.height / 2, "Controls\nArrow keys - Moving\nM - Map\n\nFind the key and get out", { fontFamily: 'Arial', fontSize: 24, color: '#ffffff', align: 'center' } ); controlsText.setOrigin(0.5); const seedText = this.add.text(this.sys.game.config.width / 2, this.sys.game.config.height / 2 + 100, `Seed: ${this.seed} (Click to copy)`, { fontFamily: 'Arial', fontSize: 20, color: '#ffff00', align: 'center' } ); seedText.setOrigin(0.5); seedText.setInteractive({ useHandCursor: true }); seedText.on('pointerdown', () => { this.copyToClipboard(this.seed); this.showMessage("Seed copied to clipboard!"); }); const pressEnterText = this.add.text(this.sys.game.config.width / 2, this.sys.game.config.height - 50, 'Press ENTER to start', { fontFamily: 'Arial', fontSize: 20, color: '#ffffff' } ); pressEnterText.setOrigin(0.5); const enterKey = this.input.keyboard.addKey('ENTER'); enterKey.once('down', () => { controlsText.destroy(); seedText.destroy(); pressEnterText.destroy(); this.startGame(); }); } update() { // Update logic not needed for static background } toggleMap() { if (!this.gameStarted) return; this.showGrid = !this.showGrid; this.grid.setVisible(this.showGrid); this.playerX.setVisible(this.showGrid); this.directionIndicators.setVisible(this.showGrid); for (let room in this.rooms) { this.rooms[room].image.setVisible(!this.showGrid && room === this.currentRoom); } // Always keep the console text hidden after the game has started this.consoleText.setVisible(false); if (this.showGrid) { this.drawRoomDirections(); } // Show or hide the key room highlight based on the map visibility if (this.keyRoomHighlight) { this.keyRoomHighlight.setVisible(this.showGrid); } // Update down arrow visibility this.updateDownArrowVisibility(); } drawGrid() { const width = this.sys.game.config.width; const height = this.sys.game.config.height; const cellWidth = width / 10; const cellHeight = height / 10; this.grid.clear(); this.grid.lineStyle(2, 0x00ff00, 1); // Draw vertical lines for (let x = 0; x <= width; x += cellWidth) { this.grid.moveTo(x, 0); this.grid.lineTo(x, height); } // Draw horizontal lines for (let y = 0; y <= height; y += cellHeight) { this.grid.moveTo(0, y); this.grid.lineTo(width, y); } // Fill visited squares with translucent green this.grid.fillStyle(0x00ff00, 0.3); for (let key in this.visitedSquares) { let [x, y] = key.split(',').map(Number); this.grid.fillRect(x * cellWidth, y * cellHeight, cellWidth, cellHeight); } // Highlight KEYROOM with a different color if (this.keyRoomPosition && this.visitedSquares[`${this.keyRoomPosition.x},${this.keyRoomPosition.y}`]) { this.grid.fillStyle(0xff0000, 0.3); this.grid.fillRect( this.keyRoomPosition.x * cellWidth, this.keyRoomPosition.y * cellHeight, cellWidth, cellHeight ); } this.grid.strokePath(); } drawPlayerX() { const width = this.sys.game.config.width; const height = this.sys.game.config.height; const cellWidth = width / 10; const cellHeight = height / 10; this.playerX.clear(); this.playerX.lineStyle(4, 0xff0000, 1); const x = this.playerPosition.x * cellWidth; const y = this.playerPosition.y * cellHeight; const padding = 10; this.playerX.moveTo(x + padding, y + padding); this.playerX.lineTo(x + cellWidth - padding, y + cellHeight - padding); this.playerX.moveTo(x + cellWidth - padding, y + padding); this.playerX.lineTo(x + padding, y + cellHeight - padding); this.playerX.strokePath(); } handleUpArrow() { if (!this.gameStarted) { this.scrollOffset = Math.max(0, this.scrollOffset - 30); this.updateConsoleText(); return; } if (this.showGrid) return; if (this.isValidMove(0, -1)) { this.previousRoom = this.currentRoom; this.movePlayer(0, -1); this.changeRoom('up'); this.previousDirection = 'up'; } else { this.showMessage("Cannot move there"); } } handleDownArrow() { if (!this.gameStarted) { this.scrollOffset = Math.min( this.generatedRoomsList.length * 30 - this.sys.game.config.height + 100, this.scrollOffset + 30 ); this.updateConsoleText(); return; } if (this.showGrid) return; if (this.isValidMove(0, 1)) { this.previousRoom = this.currentRoom; this.movePlayer(0, 1); this.changeRoom('down'); this.previousDirection = 'down'; } else { this.showMessage("Cannot move there"); } } handleLeftArrow() { if (!this.gameStarted || this.showGrid) return; if (this.isValidMove(-1, 0)) { this.previousRoom = this.currentRoom; this.movePlayer(-1, 0); this.changeRoom('left'); this.previousDirection = 'left'; } else { this.showMessage("Cannot move there"); } } handleRightArrow() { if (!this.gameStarted || this.showGrid) return; if (this.isValidMove(1, 0)) { this.previousRoom = this.currentRoom; this.movePlayer(1, 0); this.changeRoom('right'); this.previousDirection = 'right'; } else { this.showMessage("Cannot move there"); } } movePlayer(dx, dy) { this.playerPosition.x = Phaser.Math.Clamp(this.playerPosition.x + dx, 0, 9); this.playerPosition.y = Phaser.Math.Clamp(this.playerPosition.y + dy, 0, 9); this.drawPlayerX(); this.markSquareAsVisited(this.playerPosition.x, this.playerPosition.y); } changeRoom(direction) { this.fadeOut(() => { // Hide current room if (this.currentRoom && this.rooms[this.currentRoom]) { this.rooms[this.currentRoom].image.setVisible(false); } // Get the room assigned to the current grid position const gridKey = `${this.playerPosition.x},${this.playerPosition.y}`; this.currentRoom = this.gridRooms[gridKey]; // Check if the new room exists and has valid directions if (!this.currentRoom || !this.rooms[this.currentRoom]) { console.warn(`Invalid room at position (${this.playerPosition.x}, ${this.playerPosition.y})`); this.movePlayer(-this.getDirectionOffset(direction).dx, -this.getDirectionOffset(direction).dy); this.showMessage("Cannot move there"); this.fadeIn(); return; } // Show new room this.rooms[this.currentRoom].image.setVisible(true); // Update room type text this.updateRoomTypeText(); // Check if player has entered the key room if (this.playerPosition.x === this.keyRoomPosition.x && this.playerPosition.y === this.keyRoomPosition.y) { this.showMessage("Wow, You found the key"); this.hasKey = true; } // Check if player has entered the exit room (top right corner) if (this.playerPosition.x === 9 && this.playerPosition.y === 0) { if (this.hasKey) { const endTime = new Date(); const elapsedSeconds = Math.floor((endTime - this.startTime) / 1000); this.showMessage(`Exit is unlocked. Finished in ${elapsedSeconds} seconds!`); this.time.delayedCall(2000, () => this.showCongratulationScreen(elapsedSeconds)); } else { this.showMessage("You don't have the key"); } } this.fadeIn(); }); // Draw the direction indicators for the new room this.drawRoomDirections(); // Update down arrow visibility this.updateDownArrowVisibility(); } drawRoomDirections() { const width = this.sys.game.config.width; const height = this.sys.game.config.height; const cellWidth = width / 10; const cellHeight = height / 10; const squareSize = 10; // Size of the black square this.directionIndicators.clear(); this.directionIndicators.fillStyle(0x000000, 1); // Black color for squares // Store and draw indicators for the current room if (this.currentRoom && this.rooms[this.currentRoom]) { const x = this.playerPosition.x * cellWidth; const y = this.playerPosition.y * cellHeight; const allowedDirections = this.rooms[this.currentRoom].allowedDirections; const roomKey = `${this.playerPosition.x},${this.playerPosition.y}`; this.roomDirectionIndicators[roomKey] = allowedDirections; } // Draw indicators for all visited rooms for (const [roomKey, directions] of Object.entries(this.roomDirectionIndicators)) { const [roomX, roomY] = roomKey.split(',').map(Number); const x = roomX * cellWidth; const y = roomY * cellHeight; if (directions.includes('up')) { this.directionIndicators.fillRect(x + (cellWidth - squareSize) / 2, y, squareSize, squareSize); } if (directions.includes('down')) { this.directionIndicators.fillRect(x + (cellWidth - squareSize) / 2, y + cellHeight - squareSize, squareSize, squareSize); } if (directions.includes('left')) { this.directionIndicators.fillRect(x, y + (cellHeight - squareSize) / 2, squareSize, squareSize); } if (directions.includes('right')) { this.directionIndicators.fillRect(x + cellWidth - squareSize, y + (cellHeight - squareSize) / 2, squareSize, squareSize); } } } getDirectionOffset(direction) { const offsets = { 'up': { dx: 0, dy: -1 }, 'down': { dx: 0, dy: 1 }, 'left': { dx: -1, dy: 0 }, 'right': { dx: 1, dy: 0 } }; return offsets[direction]; } fadeOut(callback) { this.tweens.add({ targets: this.fadeRect, alpha: 1, duration: this.fadeDuration / 2, onComplete: callback }); } fadeIn() { this.tweens.add({ targets: this.fadeRect, alpha: 0, duration: this.fadeDuration / 2 }); } isValidMove(dx, dy) { const newX = this.playerPosition.x + dx; const newY = this.playerPosition.y + dy; if (newX < 0 || newX > 9 || newY < 0 || newY > 9) { return false; } const currentRoom = this.gridRooms[`${this.playerPosition.x},${this.playerPosition.y}`]; if (!currentRoom || !this.rooms[currentRoom]) { console.warn(`Room not found for current position (${this.playerPosition.x}, ${this.playerPosition.y})`); return false; } const direction = dy === -1 ? 'up' : dy === 1 ? 'down' : dx === -1 ? 'left' : 'right'; const nextRoom = this.gridRooms[`${newX},${newY}`]; if (!nextRoom || !this.rooms[nextRoom]) { console.warn(`Next room not found at position (${newX}, ${newY})`); return false; } const oppositeDirection = this.getOppositeDirection(direction); // Special case for entering the top right corner (9,0) if (newX === 9 && newY === 0) { return this.rooms[currentRoom].allowedDirections.includes(direction); } return this.rooms[currentRoom].allowedDirections.includes(direction) && this.rooms[nextRoom].allowedDirections.includes(oppositeDirection); } showMessage(message) { this.messageText.setText(message); this.messageText.setVisible(true); this.time.delayedCall(2000, () => { this.messageText.setVisible(false); }); } markSquareAsVisited(x, y) { const key = `${x},${y}`; this.visitedSquares[key] = true; this.drawGrid(); // Redraw the grid to show the newly visited square } updateRoomTypeText() { const isKeyRoom = this.playerPosition.x === this.keyRoomPosition.x && this.playerPosition.y === this.keyRoomPosition.y; if (this.currentRoom && this.rooms[this.currentRoom]) { const roomNumber = this.rooms[this.currentRoom].number; const numberText = roomNumber !== null ? ` (${roomNumber})` : ''; const keyRoomText = isKeyRoom ? ' [KEYROOM]' : ''; this.consoleText.setText(`Current Room: ${this.currentRoom}${numberText}${keyRoomText}\n\n${this.generatedRoomsList.join('\n')}`); } else { console.warn(`Room not found for position (${this.playerPosition.x}, ${this.playerPosition.y})`); this.consoleText.setText(`Current Room: Unknown\n\n${this.generatedRoomsList.join('\n')}`); } } updateConsoleText() { const visibleLines = Math.floor((this.sys.game.config.height - 100) / 30); const startIndex = Math.floor(this.scrollOffset / 30); const visibleText = this.generatedRoomsList.slice(startIndex, startIndex + visibleLines); this.consoleText.setText(visibleText.join('\n')); this.consoleText.y = 100 - (this.scrollOffset % 30); } showCongratulationScreen(elapsedSeconds) { // Hide all game elements this.hideAllGameElements(); // Create congratulation text const congratsText = this.add.text(this.sys.game.config.width / 2, this.sys.game.config.height / 2 - 100, 'Congratulations!', { fontFamily: 'Arial', fontSize: 48, color: '#00ff00' }); congratsText.setOrigin(0.5); // Create completion message const completionText = this.add.text(this.sys.game.config.width / 2, this.sys.game.config.height / 2, 'You have successfully escaped the maze!', { fontFamily: 'Arial', fontSize: 24, color: '#ffffff' }); completionText.setOrigin(0.5); // Add time taken message const timeText = this.add.text(this.sys.game.config.width / 2, this.sys.game.config.height / 2 + 50, `Finished the maze in ${elapsedSeconds} seconds`, { fontFamily: 'Arial', fontSize: 24, color: '#ffff00' }); timeText.setOrigin(0.5); // Add "Press enter to try again" message const tryAgainText = this.add.text(this.sys.game.config.width / 2, this.sys.game.config.height / 2 + 150, 'Press enter to try again', { fontFamily: 'Arial', fontSize: 24, color: '#00ff00' }); tryAgainText.setOrigin(0.5); // Add event listener for the Enter key const enterKey = this.input.keyboard.addKey('ENTER'); enterKey.once('down', () => { this.resetGame(); }); } resetGame() { // Reset all necessary game states this.showGrid = false; this.rooms = {}; this.roomDirectionIndicators = {}; this.hasKey = false; this.controlsShown = false; this.currentRoom = 'roomForward'; this.playerPosition = { x: 0, y: 9 }; this.discoveredRooms = []; this.previousRoom = null; this.lastDirection = null; this.roomMemory = {}; this.disableMapAndX = false; this.previousDirection = null; this.visitedSquares = {}; this.generatedRoomsList = []; this.mazeGenerated = false; this.gameStarted = false; this.scrollOffset = 0; this.availablePositions = []; this.isFirstRoom = true; this.keyRoomPosition = null; this.oneDirectionRoomCount = 0; this.fourDirectionRoomCount = 0; this.keyRoomRevealed = false; // Clear existing graphics and text this.grid.clear(); this.playerX.clear(); this.directionIndicators.clear(); if (this.keyRoomHighlight) { this.keyRoomHighlight.clear(); } // Restart the scene this.scene.restart(); } hideAllGameElements() { // Hide all room images for (let room in this.rooms) { this.rooms[room].image.setVisible(false); } // Hide grid and player marker this.grid.setVisible(false); this.playerX.setVisible(false); this.directionIndicators.setVisible(false); // Hide any other UI elements this.messageText.setVisible(false); this.consoleText.setVisible(false); } revealKeyRoom() { if (!this.gameStarted || this.keyRoomRevealed) return; this.keyRoomRevealed = true; const keyRoomX = this.keyRoomPosition.x; const keyRoomY = this.keyRoomPosition.y; // Highlight the key room on the grid const cellWidth = this.sys.game.config.width / 10; const cellHeight = this.sys.game.config.height / 10; this.keyRoomHighlight = this.add.graphics(); this.keyRoomHighlight.fillStyle(0xffff00, 0.5); // Yellow, semi-transparent this.keyRoomHighlight.fillRect( keyRoomX * cellWidth, keyRoomY * cellHeight, cellWidth, cellHeight ); // Show a message this.showMessage("Key room revealed!"); // If the map is not visible, show it temporarily if (!this.showGrid) { this.toggleMap(); this.time.delayedCall(3000, () => { this.toggleMap(); }); } } } const container = document.getElementById('renderDiv'); const config = { type: Phaser.AUTO, parent: 'renderDiv', scale: { mode: Phaser.Scale.FIT, autoCenter: Phaser.Scale.CENTER_BOTH, }, width: 1469, height: 828, pixelArt: true, crisp: true, physics: { default: 'arcade', arcade: { gravity: { y: 300 }, debug: false } }, scene: Example, backgroundColor: '#000000' }; window.phaserGame = new Phaser.Game(config);