class DungeonUtils { static generateRoomTiles(width, height, condition = () => true) { const tiles = []; for (let y = 0; y < height; y++) { for (let x = 0; x < width; x++) { if (condition(x, y)) { tiles.push({ x, y }); } } } return tiles; } static transformOctant(x, y, octant) { switch (octant) { case 0: return [x, -y]; case 1: return [y, -x]; case 2: return [y, x]; case 3: return [x, y]; case 4: return [-x, y]; case 5: return [-y, x]; case 6: return [-y, -x]; case 7: return [-x, -y]; } } } class DungeonBase { constructor(scene, width, height, gridSize) { this.scene = scene; this.width = Math.min(width, 3200); this.height = Math.min(height, 2400); this.gridSize = gridSize; this.tileMap = []; this.visibilityMap = []; this.exploredMap = []; this.initMaps(); } initMaps() { const width = Math.max(1, Math.ceil(this.width / this.gridSize)); const height = Math.max(1, Math.ceil(this.height / this.gridSize)); this.tileMap = Array(height).fill().map(() => Array(width).fill(0)); this.visibilityMap = Array(height).fill().map(() => Array(width).fill(false)); this.exploredMap = Array(height).fill().map(() => Array(width).fill(false)); } isValidPosition(x, y) { return x >= 0 && x < this.tileMap[0].length && y >= 0 && y < this.tileMap.length; } } class DungeonGenerator extends DungeonBase { constructor(scene, initialWidth, initialHeight, gridSize) { super(scene, initialWidth, initialHeight, gridSize); this.initialWidth = Math.min(initialWidth, 3200); this.initialHeight = Math.min(initialHeight, 2400); this.rooms = []; this.corridors = []; this.leafs = []; this.graphics = null; this.startLabel = null; this.startRoom = null; this.offsetX = 0; this.offsetY = 0; this.animationDelay = 50; // Increased delay for slower visualization } async generate(minRoomSize, maxRoomSize, minRooms, maxRooms, minCorridorSize, maxCorridorSize, animationSpeed) { if (minRooms < 1 || maxRooms < minRooms || minRoomSize < 1 || maxRoomSize < minRoomSize || minCorridorSize < 1 || maxCorridorSize < minCorridorSize) { throw new Error("Invalid parameters. Ensure minRooms >= 1, maxRooms >= minRooms, minRoomSize >= 1, maxRoomSize >= minRoomSize, minCorridorSize >= 1, and maxCorridorSize >= minCorridorSize."); } this.animationDelay = animationSpeed; try { this.clearExistingData(); await this.generateDungeonStructure(minRoomSize, maxRoomSize, minRooms, maxRooms, minCorridorSize, maxCorridorSize); this.generateDungeonRepresentation(); this.centerDungeon(); this.draw(); } catch (error) { console.error("Error during dungeon generation:", error); throw new Error(`Failed to generate dungeon: ${error.message}. Please try again with different parameters.`); } } clearExistingData() { this.rooms = []; this.corridors = []; this.leafs = []; this.initMaps(); this.offsetX = 0; this.offsetY = 0; if (this.graphics) { this.graphics.clear(); } else { this.graphics = this.scene.add.graphics(); } } async generateDungeonStructure(minRoomSize, maxRoomSize, minRooms, maxRooms, minCorridorSize, maxCorridorSize) { await this.generateBSP(0, 0, this.width / this.gridSize, this.height / this.gridSize, minRoomSize, maxRoomSize); await this.generateRooms(minRooms, maxRooms, minRoomSize, maxRoomSize); await this.connectRooms(minCorridorSize, maxCorridorSize); this.setStartRoom(); } generateDungeonRepresentation() { this.generateTileMap(); } centerDungeon() { let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity; this.rooms.forEach(room => { minX = Math.min(minX, room.x); minY = Math.min(minY, room.y); maxX = Math.max(maxX, room.x + room.width); maxY = Math.max(maxY, room.y + room.height); }); const dungeonWidth = maxX - minX; const dungeonHeight = maxY - minY; this.offsetX = Math.floor((this.width / this.gridSize - dungeonWidth) / 2) - minX; this.offsetY = Math.floor((this.height / this.gridSize - dungeonHeight) / 2) - minY; this.rooms.forEach(room => { room.x += this.offsetX; room.y += this.offsetY; }); this.corridors.forEach(corridor => { corridor.x1 += this.offsetX; corridor.y1 += this.offsetY; corridor.x2 += this.offsetX; corridor.y2 += this.offsetY; }); this.generateTileMap(); } async generateBSP(x, y, width, height, minRoomSize, maxRoomSize) { if (width > maxRoomSize || height > maxRoomSize) { let splitHorizontal = Math.random() > 0.5; if (width > height && width / height >= 1.25) splitHorizontal = false; else if (height > width && height / width >= 1.25) splitHorizontal = true; if (splitHorizontal) { const splitHeight = Math.floor(height / 2) + Phaser.Math.Between(-2, 2); await this.generateBSP(x, y, width, splitHeight, minRoomSize, maxRoomSize); await this.generateBSP(x, y + splitHeight, width, height - splitHeight, minRoomSize, maxRoomSize); } else { const splitWidth = Math.floor(width / 2) + Phaser.Math.Between(-2, 2); await this.generateBSP(x, y, splitWidth, height, minRoomSize, maxRoomSize); await this.generateBSP(x + splitWidth, y, width - splitWidth, height, minRoomSize, maxRoomSize); } } else if (width >= minRoomSize && height >= minRoomSize) { this.leafs.push({ x, y, width, height }); await this.visualizeLeaf(x, y, width, height); } } async visualizeLeaf(x, y, width, height) { this.graphics.lineStyle(3, 0xFFFF00, 1); this.graphics.strokeRect(x * this.gridSize, y * this.gridSize, width * this.gridSize, height * this.gridSize); await this.delay(this.animationDelay); } async generateRooms(minRooms, maxRooms, minRoomSize, maxRoomSize) { let roomsToCreate = Phaser.Math.Between(minRooms, maxRooms); let createdRooms = 0; for (const leaf of this.leafs) { if (createdRooms < roomsToCreate && await this.tryCreateRoom(leaf, minRoomSize, maxRoomSize)) { createdRooms++; } } if (createdRooms < minRooms) { for (const leaf of this.leafs) { if (createdRooms < roomsToCreate && !this.rooms.some(room => room.leaf === leaf)) { if (await this.tryCreateRoom(leaf, minRoomSize, maxRoomSize)) { createdRooms++; } } } } let attempts = 0; const maxAttempts = 100; while (createdRooms < minRooms && attempts < maxAttempts) { const randomLeaf = Phaser.Utils.Array.GetRandom(this.leafs); if (await this.tryCreateRoom(randomLeaf, minRoomSize, maxRoomSize, true)) { createdRooms++; } attempts++; } if (createdRooms < minRooms) { throw new Error(`Failed to create minimum number of rooms. Created ${createdRooms}, minimum required: ${minRooms}. Try increasing max room size or decreasing min room size.`); } } async tryCreateRoom(leaf, minRoomSize, maxRoomSize, force = false) { if (force || Math.random() < 0.8) { const roomShape = Phaser.Math.Between(0, 3); let room = this.createRoom(leaf, roomShape, minRoomSize, maxRoomSize); if (room && !this.roomCollides(room)) { room.leaf = leaf; this.rooms.push(room); await this.visualizeRoom(room); return true; } } return false; } async visualizeRoom(room) { this.graphics.fillStyle(0xFF0000, 0.7); room.tiles.forEach(tile => { const x = (room.x + tile.x) * this.gridSize; const y = (room.y + tile.y) * this.gridSize; this.graphics.fillRect(x, y, this.gridSize, this.gridSize); }); await this.delay(this.animationDelay * 2); // Increased delay for room creation } createRoom(leaf, shape, minRoomSize, maxRoomSize) { const roomWidth = Phaser.Math.Between(Math.max(minRoomSize, Math.floor(leaf.width * 0.6)), Math.min(maxRoomSize, leaf.width)); const roomHeight = Phaser.Math.Between(Math.max(minRoomSize, Math.floor(leaf.height * 0.6)), Math.min(maxRoomSize, leaf.height)); const roomX = leaf.x + Math.floor((leaf.width - roomWidth) / 2); const roomY = leaf.y + Math.floor((leaf.height - roomHeight) / 2); let tiles; switch (shape) { case 0: tiles = DungeonUtils.generateRoomTiles(roomWidth, roomHeight); break; case 1: const cutXL = Math.floor(roomWidth * 0.3); const cutYL = Math.floor(roomHeight * 0.3); tiles = DungeonUtils.generateRoomTiles(roomWidth, roomHeight, (x, y) => x >= cutXL || y >= cutYL); break; case 2: const cutWidthT = Math.floor(roomWidth * 0.3); const cutHeightT = Math.floor(roomHeight * 0.3); tiles = DungeonUtils.generateRoomTiles(roomWidth, roomHeight, (x, y) => y < cutHeightT || (x >= cutWidthT && x < roomWidth - cutWidthT)); break; case 3: const crossCutWidth = Math.floor(roomWidth * 0.3); const crossCutHeight = Math.floor(roomHeight * 0.3); tiles = DungeonUtils.generateRoomTiles(roomWidth, roomHeight, (x, y) => (x >= crossCutWidth && x < roomWidth - crossCutWidth) || (y >= crossCutHeight && y < roomHeight - crossCutHeight) ); break; } return { x: roomX, y: roomY, width: roomWidth, height: roomHeight, tiles }; } roomCollides(newRoom) { return this.rooms.some(existingRoom => { const xOverlap = Math.max(0, Math.min(newRoom.x + newRoom.width + 1, existingRoom.x + existingRoom.width + 1) - Math.max(newRoom.x - 1, existingRoom.x - 1)); const yOverlap = Math.max(0, Math.min(newRoom.y + newRoom.height + 1, existingRoom.y + existingRoom.height + 1) - Math.max(newRoom.y - 1, existingRoom.y - 1)); return xOverlap > 0 && yOverlap > 0; }); } async connectRooms(minCorridorSize, maxCorridorSize) { const edges = this.generateAllPossibleEdges(); const sortedEdges = edges.sort((a, b) => a.distance - b.distance); const mst = this.createMinimumSpanningTree(sortedEdges); for (const edge of mst) { await this.createCorridor(edge.roomA, edge.roomB, minCorridorSize, maxCorridorSize); } } generateAllPossibleEdges() { const edges = []; for (let i = 0; i < this.rooms.length; i++) { for (let j = i + 1; j < this.rooms.length; j++) { const roomA = this.rooms[i]; const roomB = this.rooms[j]; const distance = this.calculateDistance(roomA, roomB); edges.push({ roomA, roomB, distance }); } } return edges; } calculateDistance(roomA, roomB) { const centerA = { x: roomA.x + roomA.width / 2, y: roomA.y + roomA.height / 2 }; const centerB = { x: roomB.x + roomB.width / 2, y: roomB.y + roomB.height / 2 }; return Math.sqrt(Math.pow(centerA.x - centerB.x, 2) + Math.pow(centerA.y - centerB.y, 2)); } createMinimumSpanningTree(edges) { const mst = []; const disjointSet = new DisjointSet(this.rooms.length); for (const edge of edges) { const indexA = this.rooms.indexOf(edge.roomA); const indexB = this.rooms.indexOf(edge.roomB); if (disjointSet.find(indexA) !== disjointSet.find(indexB)) { mst.push(edge); disjointSet.union(indexA, indexB); } if (mst.length === this.rooms.length - 1) break; } return mst; } async createCorridor(roomA, roomB, minCorridorSize, maxCorridorSize) { const pointA = { x: roomA.x + Math.floor(roomA.width / 2), y: roomA.y + Math.floor(roomA.height / 2) }; const pointB = { x: roomB.x + Math.floor(roomB.width / 2), y: roomB.y + Math.floor(roomB.height / 2) }; const corridorWidth = Phaser.Math.Between(minCorridorSize, maxCorridorSize); if (Math.random() < 0.5) { await this.createHorizontalCorridor(pointA, pointB, corridorWidth); await this.createVerticalCorridor(pointA, pointB, corridorWidth); } else { await this.createVerticalCorridor(pointA, pointB, corridorWidth); await this.createHorizontalCorridor(pointA, pointB, corridorWidth); } } async createHorizontalCorridor(pointA, pointB, corridorWidth) { const x1 = Math.min(pointA.x, pointB.x); const x2 = Math.max(pointA.x, pointB.x); const y = pointA.y; await this.visualizeCorridor({ x1: x1, y1: y - Math.floor((corridorWidth - 1) / 2), x2: x2, y2: y + Math.ceil((corridorWidth - 1) / 2) }); } async createVerticalCorridor(pointA, pointB, corridorWidth) { const x = pointB.x; const y1 = Math.min(pointA.y, pointB.y); const y2 = Math.max(pointA.y, pointB.y); await this.visualizeCorridor({ x1: x - Math.floor((corridorWidth - 1) / 2), y1: y1, x2: x + Math.ceil((corridorWidth - 1) / 2), y2: y2 }); } async visualizeCorridor(corridor) { this.graphics.fillStyle(0x00FF00, 0.7); this.graphics.fillRect( corridor.x1 * this.gridSize, corridor.y1 * this.gridSize, (corridor.x2 - corridor.x1 + 1) * this.gridSize, (corridor.y2 - corridor.y1 + 1) * this.gridSize ); this.corridors.push(corridor); await this.delay(this.animationDelay * 2); // Increased delay for corridor creation } setStartRoom() { if (this.rooms.length > 0) { const randomIndex = Phaser.Math.Between(0, this.rooms.length - 1); this.startRoom = this.rooms[randomIndex]; } else { throw new Error('No rooms generated to set as start room'); } } generateTileMap() { const width = Math.max(1, Math.ceil(this.width / this.gridSize)); const height = Math.max(1, Math.ceil(this.height / this.gridSize)); this.tileMap = Array(height).fill().map(() => Array(width).fill(0)); this.rooms.forEach(room => { room.tiles.forEach(tile => { const x = room.x + tile.x; const y = room.y + tile.y; if (x >= 0 && x < width && y >= 0 && y < height) { this.tileMap[y][x] = 1; } }); }); this.corridors.forEach(corridor => { const [x1, y1, x2, y2] = [corridor.x1, corridor.y1, corridor.x2, corridor.y2].map(Math.floor); for (let y = Math.max(0, Math.min(y1, y2)); y <= Math.min(height - 1, Math.max(y1, y2)); y++) { for (let x = Math.max(0, Math.min(x1, x2)); x <= Math.min(width - 1, Math.max(x1, x2)); x++) { this.tileMap[y][x] = 1; } } }); } initVisibilityMap() { this.visibilityMap = this.tileMap.map(row => row.map(() => false)); } initExploredMap() { this.exploredMap = this.tileMap.map(row => row.map(() => false)); } updateFOV(playerX, playerY, radius) { const gridX = Math.floor(playerX / this.gridSize); const gridY = Math.floor(playerY / this.gridSize); this.visibilityMap = this.visibilityMap.map(row => row.map(() => false)); for (let octant = 0; octant < 8; octant++) { this.castLight(gridX, gridY, radius, 1, 1.0, 0.0, octant); } this.visibilityMap[gridY][gridX] = true; this.exploredMap[gridY][gridX] = true; } castLight(cx, cy, radius, row, startSlope, endSlope, octant) { if (startSlope < endSlope) return; let radius_squared = radius * radius; for (let j = row; j <= radius; j++) { let dx = -j - 1; let dy = -j; while (dx <= 0) { dx += 1; let [mapX, mapY] = DungeonUtils.transformOctant(dx, dy, octant); mapX += cx; mapY += cy; if (!this.isValidPosition(mapX, mapY)) { continue; } let slopeStart = (dx - 0.5) / (dy + 0.5); let slopeEnd = (dx + 0.5) / (dy - 0.5); if (startSlope < slopeEnd) { continue; } else if (endSlope > slopeStart) { break; } if (dx * dx + dy * dy < radius_squared) { this.visibilityMap[mapY][mapX] = true; this.exploredMap[mapY][mapX] = true; } if (!this.tileMap[mapY][mapX]) { if (dy > 0) { this.castLight(cx, cy, radius, j + 1, startSlope, slopeStart, octant); } startSlope = slopeEnd; } } if (startSlope < endSlope) { break; } } } clear() { if (this.graphics) { this.graphics.clear(); } if (this.startLabel) { this.startLabel.destroy(); this.startLabel = null; } } draw() { this.clear(); if (!this.graphics) { this.graphics = this.scene.add.graphics(); } this.graphics.lineStyle(2, 0x000000); this.rooms.forEach(room => { room.tiles.forEach(tile => { const x = (room.x + tile.x) * this.gridSize; const y = (room.y + tile.y) * this.gridSize; this.graphics.strokeRect(x, y, this.gridSize, this.gridSize); }); }); this.graphics.lineStyle(2, 0xFF0000); this.rooms.forEach(room => { room.tiles.forEach(tile => { const x = (room.x + tile.x) * this.gridSize; const y = (room.y + tile.y) * this.gridSize; this.graphics.strokeRect(x + 1, y + 1, this.gridSize - 2, this.gridSize - 2); }); }); this.graphics.lineStyle(2, 0xFF0000); this.corridors.forEach(corridor => { this.graphics.fillStyle(0xFF0000, 0.5); this.graphics.fillRect( corridor.x1 * this.gridSize, corridor.y1 * this.gridSize, (corridor.x2 - corridor.x1 + 1) * this.gridSize, (corridor.y2 - corridor.y1 + 1) * this.gridSize ); }); if (this.startRoom) { this.graphics.lineStyle(4, 0x00FF00); this.startRoom.tiles.forEach(tile => { const x = (this.startRoom.x + tile.x) * this.gridSize; const y = (this.startRoom.y + tile.y) * this.gridSize; this.graphics.strokeRect(x, y, this.gridSize, this.gridSize); }); const startRoomCenterX = (this.startRoom.x + this.startRoom.width / 2) * this.gridSize; const startRoomCenterY = (this.startRoom.y + this.startRoom.height / 2) * this.gridSize; this.startLabel = this.scene.add.text(startRoomCenterX, startRoomCenterY, 'S', { font: '32px Arial', fill: '#00FF00' }).setOrigin(0.5); } } drawTiles() { this.clear(); if (!this.graphics) { this.graphics = this.scene.add.graphics(); } const lightRadius = 5; const playerX = this.scene.player ? this.scene.player.x : 0; const playerY = this.scene.player ? this.scene.player.y : 0; for (let y = 0; y < this.tileMap.length; y++) { for (let x = 0; x < this.tileMap[y].length; x++) { this.drawTile(x, y, playerX, playerY, lightRadius); } } } drawTile(x, y, playerX, playerY, lightRadius) { let color; let alpha = 1; if (this.visibilityMap[y][x]) { [color, alpha] = this.getVisibleTileColor(x, y, playerX, playerY, lightRadius); } else if (this.exploredMap[y][x]) { [color, alpha] = this.getExploredTileColor(x, y); } else { return; } this.graphics.fillStyle(color, alpha); this.graphics.fillRect(x * this.gridSize, y * this.gridSize, this.gridSize, this.gridSize); if (this.tileMap[y][x] === 0) { this.graphics.lineStyle(1, 0x000000, alpha); this.graphics.strokeRect(x * this.gridSize, y * this.gridSize, this.gridSize, this.gridSize); } } getVisibleTileColor(x, y, playerX, playerY, lightRadius) { let alpha = 1; if (this.scene.player) { const distance = Math.sqrt(Math.pow(x - playerX / this.gridSize, 2) + Math.pow(y - playerY / this.gridSize, 2)); alpha = Math.max(0, Math.min(1, 1 - distance / lightRadius)); } const color = this.tileMap[y][x] === 1 ? 0xFFFFFF : 0x444444; return [color, alpha]; } getExploredTileColor(x, y) { const alpha = 0.5; const color = this.tileMap[y][x] === 1 ? 0xAAAAAA : 0x222222; return [color, alpha]; } delay(ms) { return new Promise(resolve => setTimeout(resolve, ms)); } } class DisjointSet { constructor(size) { this.parent = Array.from({ length: size }, (_, i) => i); this.rank = Array(size).fill(0); } find(x) { if (this.parent[x] !== x) { this.parent[x] = this.find(this.parent[x]); } return this.parent[x]; } union(x, y) { const rootX = this.find(x); const rootY = this.find(y); if (rootX === rootY) return; if (this.rank[rootX] < this.rank[rootY]) { this.parent[rootX] = rootY; } else if (this.rank[rootX] > this.rank[rootY]) { this.parent[rootY] = rootX; } else { this.parent[rootY] = rootX; this.rank[rootX]++; } } } class Button extends Phaser.GameObjects.Container { constructor(scene, x, y, text, style = {}, padding = { x: 20, y: 10 }) { super(scene, x, y); this.label = scene.add.text(0, 0, text, { font: 'bold 18px Arial', fill: '#FFFFFF', ...style }); this.background = scene.add.rectangle( 0, 0, this.label.width + padding.x * 2, this.label.height + padding.y * 2, 0x4a4a4a ); this.background.setStrokeStyle(2, 0xffffff); this.add(this.background); this.add(this.label); this.label.setPosition( -this.label.width / 2, -this.label.height / 2 ); this.setSize(this.background.width, this.background.height); this.setInteractive({ useHandCursor: true }) .on('pointerover', this.enterButtonHoverState) .on('pointerout', this.enterButtonRestState) .on('pointerdown', this.enterButtonActiveState) .on('pointerup', this.enterButtonHoverState); } enterButtonHoverState() { this.background.setFillStyle(0x6a6a6a); } enterButtonRestState() { this.background.setFillStyle(0x4a4a4a); } enterButtonActiveState() { this.background.setFillStyle(0x8a8a8a); } } class UIScene extends Phaser.Scene { constructor() { super({ key: 'UIScene', active: true }); this.generateButton = null; this.startGameButton = null; this.minRoomsInput = null; this.maxRoomsInput = null; this.minRoomSizeInput = null; this.maxRoomSizeInput = null; this.minCorridorSizeInput = null; this.maxCorridorSizeInput = null; this.animationSpeedInput = null; this.uiContainer = null; } create() { this.uiContainer = this.add.container(0, 0); this.createMenuBackground(); this.createTitle(); this.createInputFields(); this.createButtons(); } createMenuBackground() { const background = this.add.rectangle(400, 300, 700, 600, 0x000000, 0.7) .setStrokeStyle(2, 0xffffff); this.uiContainer.add(background); } createTitle() { const title = this.add.text(400, 80, 'Dungeon Generator', { font: 'bold 32px Arial', fill: '#FFFFFF' }).setOrigin(0.5); this.uiContainer.add(title); } createInputFields() { this.createInputField(250, 180, 'Min Rooms:', 'minRoomsInput', '1'); this.createInputField(550, 180, 'Max Rooms:', 'maxRoomsInput', '2'); this.createInputField(250, 250, 'Min Room Size:', 'minRoomSizeInput', '5'); this.createInputField(550, 250, 'Max Room Size:', 'maxRoomSizeInput', '10'); this.createInputField(250, 320, 'Min Corridor Size:', 'minCorridorSizeInput', '1'); this.createInputField(550, 320, 'Max Corridor Size:', 'maxCorridorSizeInput', '2'); this.createInputField(400, 390, 'Animation Delay:', 'animationSpeedInput', '50'); } createInputField(x, y, labelText, inputName, defaultValue) { const label = this.add.text(x, y - 30, labelText, { font: '18px Arial', fill: '#FFFFFF' }).setOrigin(0.5, 0.5); this.uiContainer.add(label); const input = this.add.dom(x, y, 'input', { type: 'number', name: inputName, value: defaultValue, style: 'width: 100px; padding: 5px; text-align: center; color: #000000; background-color: #FFFFFF; border: 1px solid #FFFFFF;' }); this[inputName] = input; this.uiContainer.add(input); input.node.value = defaultValue; } createButtons() { this.createButton('Generate Dungeon', 400, 460, async () => { const minRooms = parseInt(this.minRoomsInput.node.value); const maxRooms = parseInt(this.maxRoomsInput.node.value); const minRoomSize = parseInt(this.minRoomSizeInput.node.value); const maxRoomSize = parseInt(this.maxRoomSizeInput.node.value); const minCorridorSize = parseInt(this.minCorridorSizeInput.node.value); const maxCorridorSize = parseInt(this.maxCorridorSizeInput.node.value); const animationSpeed = parseInt(this.animationSpeedInput.node.value); try { await this.scene.get('MainScene').regenerateDungeon(minRooms, maxRooms, minRoomSize, maxRoomSize, minCorridorSize, maxCorridorSize, animationSpeed); } catch (error) { console.error(error.message); this.showErrorMessage(error.message); } }); this.createButton('Start Game', 400, 530, () => { this.scene.get('MainScene').startGame(); this.hideUI(); }); } createButton(text, x, y, callback) { const button = new Button(this, x, y, text); this.add.existing(button); button.on('pointerup', callback); this.uiContainer.add(button); return button; } hideUI() { this.uiContainer.setVisible(false); } showUI() { this.uiContainer.setVisible(true); } showErrorMessage(message) { const errorText = this.add.text(400, 590, message, { font: '18px Arial', fill: '#FF0000', align: 'center', wordWrap: { width: 600 } }).setOrigin(0.5); this.uiContainer.add(errorText); this.time.delayedCall(5000, () => { errorText.destroy(); }); } } class MainScene extends Phaser.Scene { constructor() { super({ key: 'MainScene' }); this.dungeonGenerator = null; this.player = null; this.inputManager = null; this.gameStarted = false; } create() { this.cameras.main.setBackgroundColor('#000000'); this.dungeonGenerator = new DungeonGenerator(this, 3200, 2400, 32); this.generateInitialDungeon(); this.cameras.main.setBounds(0, 0, this.dungeonGenerator.width, this.dungeonGenerator.height); this.cameras.main.setZoom(0.25); this.cameras.main.centerOn(this.dungeonGenerator.width / 2, this.dungeonGenerator.height / 2); this.inputManager = new InputManager(this); } async generateInitialDungeon() { await this.dungeonGenerator.generate(5, 10, 1, 2, 1, 2, 50); this.dungeonGenerator.draw(); } async regenerateDungeon(minRooms, maxRooms, minRoomSize, maxRoomSize, minCorridorSize, maxCorridorSize, animationSpeed) { try { this.dungeonGenerator.clear(); await this.dungeonGenerator.generate(minRoomSize, maxRoomSize, minRooms, maxRooms, minCorridorSize, maxCorridorSize, animationSpeed); this.dungeonGenerator.draw(); this.cameras.main.setBounds(0, 0, this.dungeonGenerator.width, this.dungeonGenerator.height); this.cameras.main.centerOn(this.dungeonGenerator.width / 2, this.dungeonGenerator.height / 2); } catch (error) { console.error("Error regenerating dungeon:", error); this.scene.get('UIScene').showErrorMessage(error.message); } } startGame() { if (this.gameStarted) return; this.gameStarted = true; const startRoom = this.dungeonGenerator.startRoom; const playerX = (startRoom.x + startRoom.width / 2) * this.dungeonGenerator.gridSize; const playerY = (startRoom.y + startRoom.height / 2) * this.dungeonGenerator.gridSize; this.player = this.add.rectangle(playerX, playerY, 20, 20, 0x0000FF); this.player.setOrigin(0.5); this.player.setDepth(1); this.cameras.main.startFollow(this.player); this.cameras.main.setZoom(1); this.dungeonGenerator.player = this.player; this.updateFOV(); } movePlayer(dx, dy) { const speed = 5; this.tryMovePlayer(dx * speed, dy * speed); } tryMovePlayer(dx, dy) { const newX = this.player.x + dx; const newY = this.player.y + dy; if (this.isValidPlayerPosition(newX, newY)) { this.player.x = newX; this.player.y = newY; this.updateFOV(); } } isValidPlayerPosition(x, y) { const gridX = Math.floor(x / this.dungeonGenerator.gridSize); const gridY = Math.floor(y / this.dungeonGenerator.gridSize); return gridX >= 0 && gridX < this.dungeonGenerator.tileMap[0].length && gridY >= 0 && gridY < this.dungeonGenerator.tileMap.length && this.dungeonGenerator.tileMap[gridY][gridX] === 1; } updateFOV() { const fovRadius = 11; this.dungeonGenerator.updateFOV(this.player.x, this.player.y, fovRadius); this.dungeonGenerator.drawTiles(); this.player.setVisible(true); } update() { if (!this.gameStarted) { this.handleCameraMovement(); } else { this.handlePlayerMovement(); } } handleCameraMovement() { const camera = this.cameras.main; const speed = 20; if (this.inputManager.isMovingLeft()) { camera.scrollX -= speed; } else if (this.inputManager.isMovingRight()) { camera.scrollX += speed; } if (this.inputManager.isMovingUp()) { camera.scrollY -= speed; } else if (this.inputManager.isMovingDown()) { camera.scrollY += speed; } } handlePlayerMovement() { const speed = 5; let dx = 0; let dy = 0; if (this.inputManager.isMovingLeft()) { dx -= 1; } else if (this.inputManager.isMovingRight()) { dx += 1; } if (this.inputManager.isMovingUp()) { dy -= 1; } else if (this.inputManager.isMovingDown()) { dy += 1; } if (dx !== 0 || dy !== 0) { const [normalizedDx, normalizedDy] = this.normalizeVector(dx, dy); this.tryMovePlayer(normalizedDx * speed, normalizedDy * speed); } } normalizeVector(x, y) { const length = Math.sqrt(x * x + y * y); if (length !== 0) { return [x / length, y / length]; } return [0, 0]; } } class InputManager { constructor(scene) { this.scene = scene; this.cursors = scene.input.keyboard.createCursorKeys(); this.wasd = { up: scene.input.keyboard.addKey(Phaser.Input.Keyboard.KeyCodes.W), down: scene.input.keyboard.addKey(Phaser.Input.Keyboard.KeyCodes.S), left: scene.input.keyboard.addKey(Phaser.Input.Keyboard.KeyCodes.A), right: scene.input.keyboard.addKey(Phaser.Input.Keyboard.KeyCodes.D) }; this.setupMouseInput(); } setupMouseInput() { this.scene.input.on('pointermove', this.handleMouseDrag, this); this.scene.input.on('wheel', this.handleMouseWheel, this); } handleMouseDrag(pointer) { if (pointer.isDown) { this.scene.cameras.main.scrollX -= (pointer.x - pointer.prevPosition.x) / this.scene.cameras.main.zoom; this.scene.cameras.main.scrollY -= (pointer.y - pointer.prevPosition.y) / this.scene.cameras.main.zoom; } } handleMouseWheel(pointer, gameObjects, deltaX, deltaY, deltaZ) { const zoomChange = -deltaY * 0.001; const newZoom = Phaser.Math.Clamp(this.scene.cameras.main.zoom + zoomChange, 0.1, 2); const worldPoint = this.scene.cameras.main.getWorldPoint(pointer.x, pointer.y); this.scene.cameras.main.zoom = newZoom; const newWorldPoint = this.scene.cameras.main.getWorldPoint(pointer.x, pointer.y); this.scene.cameras.main.scrollX += newWorldPoint.x - worldPoint.x; this.scene.cameras.main.scrollY += newWorldPoint.y - worldPoint.y; } isMovingLeft() { return this.cursors.left.isDown || this.wasd.left.isDown; } isMovingRight() { return this.cursors.right.isDown || this.wasd.right.isDown; } isMovingUp() { return this.cursors.up.isDown || this.wasd.up.isDown; } isMovingDown() { return this.cursors.down.isDown || this.wasd.down.isDown; } } const config = { type: Phaser.AUTO, parent: 'renderDiv', scale: { mode: Phaser.Scale.FIT, autoCenter: Phaser.Scale.CENTER_BOTH, }, width: 800, height: 600, dom: { createContainer: true }, scene: [MainScene, UIScene] }; window.phaserGame = new Phaser.Game(config);