class Example extends Phaser.Scene { constructor () { super(); this.player = null; this.walls = []; this.rays = []; this.graphics = null; this.keys = null; this.worldSize = 10000; this.trees = []; this.treeImages = []; this.groundTexture = null; this.skyTexture = null; this.skybox = null; this.wizardTower = null; this.moon = null; this.spookyClouds = []; this.shadowMan = null; this.visionCone = null; this.path = null; } preload () { this.load.image('sky', 'https://play.rosebud.ai/assets/Sky.png?GJxR'); this.load.image('wall', 'https://play.rosebud.ai/assets/Dirt_02-256x256.png?2QXR'); this.load.image('tree', 'https://play.rosebud.ai/assets/colortree.png?xDcZ'); this.load.image('ground', 'https://play.rosebud.ai/assets/Dirt_02-256x256.png?2QXR'); this.load.image('wizardtower', 'https://play.rosebud.ai/assets/wizardtower01.png?BAQH'); this.load.image('moon', 'https://play.rosebud.ai/assets/orangespookymoon.png?mtu7'); this.load.image('spookycloud', 'https://play.rosebud.ai/assets/Spookycloud.png?X8GU'); this.load.image('shadowman', 'https://play.rosebud.ai/assets/shadowman.png?suRR'); } create () { try { this.player = { x: this.worldSize / 2, y: this.worldSize / 2, angle: 0, speed: 15, turnSpeed: 0.05, verticalAngle: 0, height: 75 }; this.createWalls(); this.createRays(); this.createWizardTower(); this.createPath(); this.createTrees(); this.createShadowMan(); this.graphics = this.add.graphics(); this.groundTexture = this.textures.get('ground'); this.skyTexture = this.textures.get('sky'); this.createSkybox(); this.createMoon(); this.createSpookyClouds(); this.createVisionCone(); this.input.on('pointerdown', function () { this.input.mouse.requestPointerLock(); }, this); this.input.on('pointermove', function (pointer) { if (this.input.mouse.locked) { this.player.angle += pointer.movementX * 0.001; this.player.angle = Phaser.Math.Angle.Wrap(this.player.angle); this.player.verticalAngle -= pointer.movementY * 0.001; this.player.verticalAngle = Phaser.Math.Clamp(this.player.verticalAngle, -Math.PI/2 + 0.01, Math.PI/2 - 0.01); } }, this); this.keys = this.input.keyboard.addKeys({ w: Phaser.Input.Keyboard.KeyCodes.W, a: Phaser.Input.Keyboard.KeyCodes.A, s: Phaser.Input.Keyboard.KeyCodes.S, d: Phaser.Input.Keyboard.KeyCodes.D, q: Phaser.Input.Keyboard.KeyCodes.Q }); } catch (error) { console.error('Error in create method:', error); } } createVisionCone() { this.visionCone = new Phaser.Geom.Triangle(0, 0, 0, 0, 0, 0); } createPath() { const centerX = this.worldSize / 2; const centerY = this.worldSize / 2; const pathWidth = 200; const numPoints = 100; const maxDeviation = 2000; let points = [{x: centerX, y: centerY}]; let angle = Math.random() * Math.PI * 2; let radius = 0; for (let i = 1; i < numPoints; i++) { const t = i / (numPoints - 1); radius += this.worldSize / (2 * numPoints); angle += (Math.random() - 0.5) * Math.PI / 2; // More dramatic turns const deviation = Phaser.Math.Between(-maxDeviation, maxDeviation); let x = centerX + Math.cos(angle) * radius + Math.cos(angle + Math.PI/2) * deviation; let y = centerY + Math.sin(angle) * radius + Math.sin(angle + Math.PI/2) * deviation; // Ensure the point is within the world bounds x = Phaser.Math.Clamp(x, 0, this.worldSize); y = Phaser.Math.Clamp(y, 0, this.worldSize); points.push({x, y}); } // Ensure the last point is on the world border const lastPoint = points[points.length - 1]; const angleToCenter = Math.atan2(lastPoint.y - centerY, lastPoint.x - centerX); if (Math.abs(Math.cos(angleToCenter)) > Math.abs(Math.sin(angleToCenter))) { lastPoint.x = Math.cos(angleToCenter) > 0 ? this.worldSize : 0; lastPoint.y = centerY + Math.tan(angleToCenter) * (lastPoint.x - centerX); } else { lastPoint.y = Math.sin(angleToCenter) > 0 ? this.worldSize : 0; lastPoint.x = centerX + (lastPoint.y - centerY) / Math.tan(angleToCenter); } this.path = { points: points, width: pathWidth }; } update(time) { try { if (!this.player) return; let moved = false; if (this.keys.w.isDown) { this.player.x += Math.cos(this.player.angle) * this.player.speed; this.player.y += Math.sin(this.player.angle) * this.player.speed; moved = true; } if (this.keys.s.isDown) { this.player.x -= Math.cos(this.player.angle) * this.player.speed; this.player.y -= Math.sin(this.player.angle) * this.player.speed; moved = true; } if (this.keys.a.isDown) { this.player.x += Math.cos(this.player.angle - Math.PI/2) * this.player.speed; this.player.y += Math.sin(this.player.angle - Math.PI/2) * this.player.speed; moved = true; } if (this.keys.d.isDown) { this.player.x += Math.cos(this.player.angle + Math.PI/2) * this.player.speed; this.player.y += Math.sin(this.player.angle + Math.PI/2) * this.player.speed; moved = true; } if (this.keys.q.isDown) { this.player.verticalAngle = 0; } this.player.x = Phaser.Math.Clamp(this.player.x, 0, this.worldSize); this.player.y = Phaser.Math.Clamp(this.player.y, 0, this.worldSize); this.updateVisionCone(); this.updateShadowMan(time); this.renderScene(); this.renderTrees(); this.renderWizardTower(); this.updateSkybox(); this.renderMoon(); this.updateAndRenderSpookyClouds(); this.renderShadowMan(); } catch (error) { console.error('Error in update method:', error); } } updateVisionCone() { const fov = Math.PI / 3; const viewDist = 10000; const x1 = this.player.x + Math.cos(this.player.angle - fov / 2) * viewDist; const y1 = this.player.y + Math.sin(this.player.angle - fov / 2) * viewDist; const x2 = this.player.x + Math.cos(this.player.angle + fov / 2) * viewDist; const y2 = this.player.y + Math.sin(this.player.angle + fov / 2) * viewDist; this.visionCone.setTo(this.player.x, this.player.y, x1, y1, x2, y2); } updateShadowMan(time) { try { if (time - this.shadowMan.lastMoveTime < this.shadowMan.moveInterval) { return; } const dx = this.player.x - this.shadowMan.x; const dy = this.player.y - this.shadowMan.y; const distance = Math.sqrt(dx * dx + dy * dy); const angleToPlayer = Math.atan2(dy, dx); this.shadowMan.angle = angleToPlayer; const inVisionCone = Phaser.Geom.Triangle.ContainsPoint(this.visionCone, new Phaser.Geom.Point(this.shadowMan.x, this.shadowMan.y)); let moveAngle; let visible = inVisionCone; // Check if Shadowman is visible (not hidden by trees or walls) if (visible) { const ray = new Phaser.Geom.Line(this.player.x, this.player.y, this.shadowMan.x, this.shadowMan.y); for (const wall of this.walls) { if (Phaser.Geom.Intersects.LineToLine(ray, new Phaser.Geom.Line(wall.x1, wall.y1, wall.x2, wall.y2))) { visible = false; break; } } if (visible) { for (const tree of this.trees) { if (Phaser.Geom.Intersects.LineToCircle(ray, new Phaser.Geom.Circle(tree.x, tree.y, 50))) { visible = false; break; } } } } this.shadowMan.speed = this.player.speed * 1.5; // Find the nearest tree to hide behind let nearestTree = null; let nearestTreeDistance = Infinity; for (const tree of this.trees) { const treeDistance = Phaser.Math.Distance.Between(this.shadowMan.x, this.shadowMan.y, tree.x, tree.y); if (treeDistance < nearestTreeDistance && !Phaser.Geom.Triangle.ContainsPoint(this.visionCone, new Phaser.Geom.Point(tree.x, tree.y))) { nearestTree = tree; nearestTreeDistance = treeDistance; } } if (nearestTree) { moveAngle = Math.atan2(nearestTree.y - this.shadowMan.y, nearestTree.x - this.shadowMan.x); } else { // If no suitable tree found, move away from the player moveAngle = angleToPlayer + Math.PI; } // Add some randomness to the movement moveAngle += (Math.random() - 0.5) * Math.PI / 4; this.shadowMan.x += Math.cos(moveAngle) * this.shadowMan.speed; this.shadowMan.y += Math.sin(moveAngle) * this.shadowMan.speed; this.shadowMan.x = Phaser.Math.Clamp(this.shadowMan.x, 0, this.worldSize); this.shadowMan.y = Phaser.Math.Clamp(this.shadowMan.y, 0, this.worldSize); this.shadowMan.visible = visible; this.shadowMan.lastMoveTime = time; } catch (error) { console.error('Error in updateShadowMan method:', error); } } updateAndRenderSpookyClouds() { try { const screenWidth = 600; const screenHeight = 600; const fov = Math.PI / 3; const viewDist = 10000; for (const cloud of this.spookyClouds) { cloud.x += cloud.vx; cloud.y += cloud.vy; if (Math.random() < 0.005) { cloud.vx = (Math.random() - 0.5) * 0.75; cloud.vy = (Math.random() - 0.5) * 0.75; } cloud.x = Phaser.Math.Wrap(cloud.x, 0, this.worldSize); cloud.y = Phaser.Math.Wrap(cloud.y, 0, this.worldSize); cloud.z = Phaser.Math.Clamp(cloud.z, this.player.height + 3000, 9000); const dx = cloud.x - this.player.x; const dy = cloud.y - this.player.y; const dz = cloud.z - this.player.height; const horizontalAngle = Math.atan2(dy, dx) - this.player.angle; const normalizedHorizontalAngle = Phaser.Math.Angle.Wrap(horizontalAngle); const distance = Math.sqrt(dx * dx + dy * dy); const verticalAngle = Math.atan2(dz, distance) - this.player.verticalAngle; if (Math.abs(normalizedHorizontalAngle) < fov / 2 && verticalAngle > -Math.PI / 2 && verticalAngle < Math.PI / 2) { const x = screenWidth / 2 + (normalizedHorizontalAngle / (fov / 2)) * screenWidth; const y = screenHeight / 2 - (verticalAngle / (Math.PI / 2)) * screenHeight; cloud.image.setPosition(x, y); cloud.image.setVisible(true); const cloudDistance = Math.sqrt(dx * dx + dy * dy + dz * dz); const cloudScale = (2000 / cloudDistance) * 0.3; cloud.image.setScale(cloudScale); cloud.image.setAlpha(Math.max(0, 1 - (cloudDistance / viewDist))); } else { cloud.image.setVisible(false); } } } catch (error) { console.error('Error in updateAndRenderSpookyClouds method:', error); } } createWalls() { try { const w = this.worldSize; this.walls = [ {x1: 0, y1: 0, x2: w, y2: 0}, {x1: w, y1: 0, x2: w, y2: w}, {x1: w, y1: w, x2: 0, y2: w}, {x1: 0, y1: w, x2: 0, y2: 0} ]; } catch (error) { console.error('Error in createWalls method:', error); } } createRays() { try { for (let i = 0; i < 320; i++) { this.rays.push(new Phaser.Geom.Line()); } } catch (error) { console.error('Error in createRays method:', error); } } createTrees() { try { const towerClearingRadius = 750; const treeDensity = 0.00025; // Increased density const numTrees = Math.floor(this.worldSize * this.worldSize * treeDensity); const gridSize = Math.floor(Math.sqrt(this.worldSize * this.worldSize / numTrees)); const shuffledPositions = []; for (let x = 0; x < this.worldSize; x += gridSize) { for (let y = 0; y < this.worldSize; y += gridSize) { shuffledPositions.push({x, y}); } } Phaser.Utils.Array.Shuffle(shuffledPositions); for (const pos of shuffledPositions) { const treeX = pos.x + Phaser.Math.Between(0, gridSize); const treeY = pos.y + Phaser.Math.Between(0, gridSize); const distanceToTower = Phaser.Math.Distance.Between(treeX, treeY, this.worldSize / 2, this.worldSize / 2); if (distanceToTower > towerClearingRadius && !this.isOnPath(treeX, treeY)) { this.addTree(treeX, treeY); } if (this.trees.length >= numTrees) break; } // Add additional trees in empty areas const maxAttempts = 1000; let attempts = 0; while (this.trees.length < numTrees * 1.2 && attempts < maxAttempts) { const x = Phaser.Math.Between(0, this.worldSize); const y = Phaser.Math.Between(0, this.worldSize); const distanceToTower = Phaser.Math.Distance.Between(x, y, this.worldSize / 2, this.worldSize / 2); if (distanceToTower > towerClearingRadius && !this.isOnPath(x, y) && this.isEmptySpace(x, y)) { this.addTree(x, y); } attempts++; } } catch (error) { console.error('Error in createTrees method:', error); } } isEmptySpace(x, y) { const minDistance = 200; // Minimum distance between trees for (const tree of this.trees) { const distance = Phaser.Math.Distance.Between(x, y, tree.x, tree.y); if (distance < minDistance) { return false; } } return true; } isOnPath(x, y) { for (let i = 1; i < this.path.points.length; i++) { const p1 = this.path.points[i - 1]; const p2 = this.path.points[i]; const closestPoint = this.closestPointOnLine(x, y, p1.x, p1.y, p2.x, p2.y); const distance = Phaser.Math.Distance.Between(x, y, closestPoint.x, closestPoint.y); if (distance <= this.path.width / 2) { return true; } } return false; } closestPointOnLine(x, y, x1, y1, x2, y2) { const A1 = y2 - y1; const B1 = x1 - x2; const C1 = (y2 - y1) * x1 + (x1 - x2) * y1; const C2 = -B1 * x + A1 * y; const det = A1 * A1 + B1 * B1; let cx = 0; let cy = 0; if (det != 0) { cx = (A1 * C1 - B1 * C2) / det; cy = (A1 * C2 + B1 * C1) / det; } else { cx = x; cy = y; } return {x: cx, y: cy}; } addTree(x, y) { this.trees.push({x, y, visible: false}); const treeImage = this.add.image(300, 300, 'tree'); treeImage.setOrigin(0.5, 1); treeImage.setScale(0.75); treeImage.setVisible(false); this.treeImages.push(treeImage); } createWizardTower() { try { this.wizardTower = { x: this.worldSize / 2, y: this.worldSize / 2, visible: false }; const towerImage = this.add.image(300, 300, 'wizardtower'); towerImage.setOrigin(0.5, 1); towerImage.setScale(2); towerImage.setVisible(false); this.wizardTower.image = towerImage; } catch (error) { console.error('Error in createWizardTower method:', error); } } createShadowMan() { try { this.shadowMan = { x: Phaser.Math.Between(0, this.worldSize), y: Phaser.Math.Between(0, this.worldSize), angle: 0, speed: this.player.speed * 1.5, visible: false, image: this.add.image(300, 300, 'shadowman'), lastMoveTime: 0, moveInterval: 500 }; this.shadowMan.image.setOrigin(0.5, 1); this.shadowMan.image.setScale(0.8 / 3); // Scale down by a factor of 3 and then 20% smaller this.shadowMan.image.setVisible(false); } catch (error) { console.error('Error in createShadowMan method:', error); } } createSkybox() { try { const screenWidth = 600; const screenHeight = 600; this.skybox = this.add.container(screenWidth / 2, screenHeight / 2); const skyImage = this.add.rectangle(0, 0, screenWidth * 2, screenHeight * 2, 0x2a0a4a); skyImage.setOrigin(0.5, 0.5); this.skybox.add(skyImage); this.skybox.setDepth(-1); } catch (error) { console.error('Error in createSkybox method:', error); } } createMoon() { try { this.moon = { x: this.worldSize / 2, y: this.worldSize / 2, z: 9500, image: this.add.image(300, 300, 'moon') }; this.moon.image.setScale(0.5); this.moon.image.setOrigin(0.5, 0.5); this.moon.image.setDepth(999); } catch (error) { console.error('Error in createMoon method:', error); } } createSpookyClouds() { try { for (let i = 0; i < 21; i++) { const cloud = { x: Phaser.Math.Between(0, this.worldSize), y: Phaser.Math.Between(0, this.worldSize), z: Phaser.Math.Between(this.player.height + 3000, 9000), image: this.add.image(300, 300, 'spookycloud'), vx: (Math.random() - 0.5) * 0.75, vy: (Math.random() - 0.5) * 0.75 }; cloud.image.setScale(0.3); cloud.image.setOrigin(0.5, 0.5); cloud.image.setDepth(1000); cloud.image.setAlpha(0.8); this.spookyClouds.push(cloud); } } catch (error) { console.error('Error in createSpookyClouds method:', error); } } renderShadowMan() { try { const fov = Math.PI / 3; const viewDist = 10000; const screenWidth = 600; const screenHeight = 600; const horizonLine = screenHeight / 2 + screenHeight * Math.tan(this.player.verticalAngle); const dx = this.shadowMan.x - this.player.x; const dy = this.shadowMan.y - this.player.y; const distance = Math.sqrt(dx * dx + dy * dy); const angle = Math.atan2(dy, dx) - this.player.angle; const normalizedAngle = Phaser.Math.Angle.Wrap(angle); if (this.shadowMan.visible && distance < viewDist && Math.abs(normalizedAngle) < fov / 2) { const size = (this.player.height * screenHeight) / distance; const x = screenWidth / 2 + (normalizedAngle / (fov / 2)) * (screenWidth / 2); const verticalPosition = horizonLine + size * 0.95; this.shadowMan.image.setPosition(x, verticalPosition); this.shadowMan.image.setScale((size * 0.01 * 0.8) / 3); // Scale down by a factor of 3 and then 20% smaller this.shadowMan.image.setDepth(viewDist - distance); this.shadowMan.image.setAlpha(1 - (distance / viewDist)); this.shadowMan.image.setVisible(true); this.shadowMan.image.setRotation(this.shadowMan.angle - this.player.angle + Math.PI); } else { this.shadowMan.image.setVisible(false); } } catch (error) { console.error('Error in renderShadowMan method:', error); } } renderScene() { try { if (!this.graphics || !this.player) return; this.graphics.clear(); const screenWidth = 600; const screenHeight = 600; const fov = Math.PI / 3; this.renderGround(screenWidth, screenHeight, fov); this.castRays(screenWidth, screenHeight, fov); this.graphics.fillStyle(0xffa500, 0.1); this.graphics.fillRect(0, 0, screenWidth, screenHeight); } catch (error) { console.error('Error in renderScene method:', error); } } renderGround(screenWidth, screenHeight, fov) { try { const horizonLine = screenHeight / 2 + screenHeight * Math.tan(this.player.verticalAngle); const groundHeight = Math.max(0, screenHeight - horizonLine); this.graphics.fillStyle(0x003300); this.graphics.fillRect(0, horizonLine, screenWidth, groundHeight); const textureWidth = this.groundTexture.width; const textureHeight = this.groundTexture.height; for (let y = 0; y < groundHeight; y += 2) { const rowDistance = (this.player.height * screenHeight) / (2 * (y + 1) - screenHeight + 2 * this.player.height); const floorStep = rowDistance * (fov / screenWidth); for (let x = 0; x < screenWidth; x += 2) { const angle = this.player.angle - fov / 2 + (x / screenWidth) * fov; const texX = Math.floor((this.player.x + Math.cos(angle) * rowDistance) % textureWidth); const texY = Math.floor((this.player.y + Math.sin(angle) * rowDistance) % textureHeight); this.graphics.fillStyle(0x004400); this.graphics.fillRect(x, horizonLine + y, 2, 2); } } } catch (error) { console.error('Error in renderGround method:', error); } } castRays(screenWidth, screenHeight, fov) { try { const horizonLine = screenHeight / 2 + screenHeight * Math.tan(this.player.verticalAngle); for (let i = 0; i < this.rays.length; i++) { const ray = this.rays[i]; const rayAngle = this.player.angle - (fov / 2) + (i / this.rays.length) * fov; ray.x1 = this.player.x; ray.y1 = this.player.y; ray.x2 = this.player.x + Math.cos(rayAngle) * 10000; ray.y2 = this.player.y + Math.sin(rayAngle) * 10000; let closestIntersection = null; let closestDistance = Infinity; // Check wall intersections for (const wall of this.walls) { const intersection = Phaser.Geom.Intersects.LineToLine(ray, new Phaser.Geom.Line(wall.x1, wall.y1, wall.x2, wall.y2)); if (intersection) { const distance = Phaser.Math.Distance.Between(this.player.x, this.player.y, intersection.x, intersection.y); if (distance < closestDistance) { closestIntersection = intersection; closestDistance = distance; } } } // Check tree intersections for (const tree of this.trees) { const treeCircle = new Phaser.Geom.Circle(tree.x, tree.y, 50); const intersection = Phaser.Geom.Intersects.GetLineToCircle(ray, treeCircle); if (intersection.length > 0) { const distance = Phaser.Math.Distance.Between(this.player.x, this.player.y, intersection[0].x, intersection[0].y); if (distance < closestDistance) { closestIntersection = intersection[0]; closestDistance = distance; } } } if (closestIntersection) { const correctedDistance = closestDistance * Math.cos(rayAngle - this.player.angle); const wallHeight = (this.player.height * screenHeight) / correctedDistance; const brightness = Math.min(1, 1 - closestDistance / 10000); const wallWidth = screenWidth / this.rays.length; this.graphics.fillStyle(Phaser.Display.Color.GetColor(128 * brightness, 128 * brightness, 128 * brightness)); this.graphics.fillRect(i * wallWidth, horizonLine - wallHeight / 2, wallWidth + 1, wallHeight); } } } catch (error) { console.error('Error in castRays method:', error); } } renderTrees() { try { const fov = Math.PI / 3; const viewDist = 10000; const screenWidth = 600; const screenHeight = 600; const horizonLine = screenHeight / 2 + screenHeight * Math.tan(this.player.verticalAngle); for (let i = 0; i < this.trees.length; i++) { const tree = this.trees[i]; const treeImage = this.treeImages[i]; const dx = tree.x - this.player.x; const dy = tree.y - this.player.y; const distance = Math.sqrt(dx * dx + dy * dy); const angle = Math.atan2(dy, dx) - this.player.angle; const normalizedAngle = Phaser.Math.Angle.Wrap(angle); if (distance < viewDist && Math.abs(normalizedAngle) < fov / 2) { const size = (this.player.height * screenHeight) / distance; const x = screenWidth / 2 + (normalizedAngle / (fov / 2)) * (screenWidth / 2); const verticalPosition = horizonLine + size * 0.98; treeImage.setPosition(x, verticalPosition); treeImage.setScale(size * 0.0025); treeImage.setDepth(viewDist - distance); treeImage.setAlpha(1 - (distance / viewDist)); treeImage.setVisible(true); tree.visible = true; } else { treeImage.setVisible(false); tree.visible = false; } } } catch (error) { console.error('Error in renderTrees method:', error); } } renderWizardTower() { try { const fov = Math.PI / 3; const viewDist = 10000; const screenWidth = 600; const screenHeight = 600; const horizonLine = screenHeight / 2 + screenHeight * Math.tan(this.player.verticalAngle); const dx = this.wizardTower.x - this.player.x; const dy = this.wizardTower.y - this.player.y; const distance = Math.sqrt(dx * dx + dy * dy); const angle = Math.atan2(dy, dx) - this.player.angle; const normalizedAngle = Phaser.Math.Angle.Wrap(angle); if (distance < viewDist && Math.abs(normalizedAngle) < fov / 2) { const size = (this.player.height * screenHeight *6) / distance; const x = screenWidth / 2 + (normalizedAngle / (fov / 2)) * (screenWidth / 2); const verticalPosition = horizonLine + size * 0.5; this.wizardTower.image.setPosition(x, verticalPosition); this.wizardTower.image.setScale(size * 0.004); this.wizardTower.image.setDepth(viewDist - distance); this.wizardTower.image.setAlpha(1 - (distance / viewDist)); this.wizardTower.image.setVisible(true); this.wizardTower.visible = true; } else { this.wizardTower.image.setVisible(false); this.wizardTower.visible = false; } } catch (error) { console.error('Error in renderWizardTower method:', error); } } updateSkybox() { try { const screenHeight = 600; const verticalOffset = this.player.verticalAngle * (screenHeight / Math.PI); this.skybox.y = screenHeight / 2 + verticalOffset; } catch (error) { console.error('Error in updateSkybox method:', error); } } renderMoon() { try { const screenWidth = 600; const screenHeight = 600; const fov = Math.PI / 3; const dx = this.moon.x - this.player.x; const dy = this.moon.y - this.player.y; const dz = this.moon.z - this.player.height; const horizontalAngle = Math.atan2(dy, dx) - this.player.angle; const normalizedHorizontalAngle = Phaser.Math.Angle.Wrap(horizontalAngle); const distance = Math.sqrt(dx * dx + dy * dy); const verticalAngle = Math.atan2(dz, distance) - this.player.verticalAngle; if (Math.abs(normalizedHorizontalAngle) < fov / 2 && verticalAngle > -Math.PI / 2 && verticalAngle < Math.PI / 2) { const x = screenWidth /2 + (normalizedHorizontalAngle / (fov / 2)) * screenWidth; const y = screenHeight / 2 - (verticalAngle / (Math.PI / 2)) * screenHeight; this.moon.image.setPosition(x, y); this.moon.image.setVisible(true); const moonDistance = Math.sqrt(dx * dx + dy * dy + dz * dz); const moonScale = 5000 / moonDistance; this.moon.image.setScale(moonScale); } else { this.moon.image.setVisible(false); } } catch (error) { console.error('Error in renderMoon method:', error); } } } const config = { type: Phaser.AUTO, parent: 'renderDiv', scale: { mode: Phaser.Scale.FIT, autoCenter: Phaser.Scale.CENTER_BOTH, }, width: 600, height: 600, pixelArt: true, scene: Example }; window.phaserGame = new Phaser.Game(config);