const createGlitchText = (scene, x, y, text) => { const glitchConfig = { style: { fontFamily: 'monospace', fontSize: '12px', color: '#ffffff', backgroundColor: '#000000', padding: { x: 6, y: 3 }, align: 'center', fixedWidth: 240, wordWrap: { width: 230 } }, glitchRate: 0.075 // Reduced by 50% from 0.15 }; const textObject = scene.add.text(x, y, text, glitchConfig.style); textObject.setOrigin(0.5); textObject.glitchTimer = scene.time.addEvent({ delay: 100, callback: () => { if (!textObject || !textObject.active || !textObject.scene) { if (textObject?.glitchTimer) { textObject.glitchTimer.remove(); } return; } const glitchedText = text.split(' ') .map(word => word.includes('(') && word.includes(')') && Math.random() < glitchConfig.glitchRate ? word.split('').map(char => Math.random() < 0.3 ? String.fromCharCode(Math.floor(Math.random() * 16) + 94) : char).join('') : word).join(' '); if (textObject && textObject.active && textObject.scene) { textObject.setText(glitchedText); } }, loop: true }); return textObject; } class MenuScene extends Phaser.Scene { constructor() { super({ key: 'MenuScene' }); } preload() { // Load menu music this.load.audio('menuMusic', 'https://play.rosebud.ai/assets/Untitled (40).mp3?YVd6'); } create() { // Create and play menu music this.menuMusic = this.sound.add('menuMusic', { volume: 0.3, loop: true }); this.menuMusic.play(); // Create fade in overlay const fadeOverlay = this.add.graphics() .fillStyle(0x000000) .fillRect(0, 0, 800, 600) .setDepth(1001) .setScrollFactor(0); // Create glitch effect title with initial alpha 0 const title = createGlitchText(this, 400, 120, '(F)LASHLIGHT'); // Add flickering effect this.tweens.add({ targets: title, alpha: { from: 0.7, to: 1 }, duration: 50, yoyo: true, repeat: -1, ease: 'Sine.easeInOut', onUpdate: (tween) => { const flickerIntensity = 0.3 + Math.random() * 0.7; const currentAlpha = 0.7 + (0.3 * flickerIntensity * tween.getValue()); title.setAlpha(currentAlpha); } }); // Set title style title.setStyle({ fontSize: '48px', fontStyle: 'bold', color: '#ffffff', backgroundColor: '#000000', padding: { x: 20, y: 10 }, align: 'center', fixedWidth: 400, wordWrap: { width: 390 } }) .setScrollFactor(0) .setDepth(1000) .setAlpha(0.7); // Set initial alpha for flicker effect // Add copyright notice at bottom const copyright = createGlitchText(this, 400, 580, '© 2025 (F)LASHLIGHT LORË Company. All rights reserved.') .setStyle({ fontSize: '12px', color: '#666666', backgroundColor: '#000000', padding: { x: 4, y: 2 }, align: 'center' }); // Add flickering effect to copyright this.tweens.add({ targets: copyright, alpha: { from: 0.7, to: 1 }, duration: 50, yoyo: true, repeat: -1, ease: 'Sine.easeInOut', onUpdate: (tween) => { const flickerIntensity = 0.3 + Math.random() * 0.7; const currentAlpha = 0.7 + (0.3 * flickerIntensity * tween.getValue()); copyright.setAlpha(currentAlpha); } }); copyright .setScrollFactor(0) .setDepth(1000) .setAlpha(0.7); // Create menu options const menuItems = [{ text: '(BEGIN)', scene: 'GameScene' }, { text: '(CONTROLS)', callback: this.showControls.bind(this) }, { text: '(CREDITS)', callback: this.showCredits.bind(this) }]; let yPosition = 250; menuItems.forEach(item => { const menuItem = createGlitchText(this, 400, yPosition, item.text) .setAlpha(0) // Set initial alpha to 0 .setStyle({ fontSize: '24px', color: '#aaaaaa', backgroundColor: '#000000', padding: { x: 10, y: 5 }, align: 'center' }); // Add flickering effect this.tweens.add({ targets: menuItem, alpha: { from: 0.7, to: 1 }, duration: 50, yoyo: true, repeat: -1, ease: 'Sine.easeInOut', onUpdate: (tween) => { const flickerIntensity = 0.3 + Math.random() * 0.7; const currentAlpha = 0.7 + (0.3 * flickerIntensity * tween.getValue()); menuItem.setAlpha(currentAlpha); } }); menuItem .setInteractive({ useHandCursor: true }) .on('pointerover', () => { menuItem.setStyle({ color: '#ffffff' }); }) .on('pointerout', () => { menuItem.setStyle({ color: '#aaaaaa' }); }) .on('pointerdown', () => { // Don't process clicks if an overlay is active if (this.activeOverlay) return; if (item.scene) { if (this.menuMusic) { this.menuMusic.stop(); } // Create fade out overlay const fadeOutOverlay = this.add.graphics() .fillStyle(0x000000) .fillRect(0, 0, 800, 600) .setDepth(1001) .setScrollFactor(0) .setAlpha(0); // Fade out effect this.tweens.add({ targets: fadeOutOverlay, alpha: 1, duration: 1000, ease: 'Power2', onComplete: () => { this.scene.start(item.scene); } }); } else if (item.callback) { item.callback(); } }); yPosition += 50; }); // Simple fade in effect const fadeInDuration = 2000; // Fade out overlay this.tweens.add({ targets: fadeOverlay, alpha: { from: 1, to: 0 }, duration: fadeInDuration, ease: 'Power2' }); // Fade in menu items with delay const menuElements = this.children.list.filter(child => child.type === 'Text'); menuElements.forEach((element, index) => { this.tweens.add({ targets: element, alpha: { from: 0, to: 1 }, duration: 500, delay: fadeInDuration / 2 + (index * 200), ease: 'Power2' }); }); } showControls() { const overlay = this.createOverlay( '(CONTROLS)\n\n' + 'WASD: Move\n' + 'Mouse: Aim\n' + 'F: Flashlight\n' + 'E: Interact\n' + 'C: Crouch\n' + 'SHIFT: Run\n\n' + '(WHISPERS): The (doors) need a gentle (push) while (Interacting)... timing is (everything), (batch): (#9@£,???)... Keep your (ears) sharp, (darkness) speaks... And do (expand) your view, (you) will appreciate a fuller... (canvas).\n\n' + '(Press ESC to return)' ); this.input.keyboard.once('keydown-ESC', () => overlay.destroy()); } showCredits() { const overlay = this.createOverlay( '(CREDITS)\n\n' + 'Created by: (LORË)\n' + 'Music: (SUNO)\n' + '(SPECIAL THANKS): The (Rosebud AI Team) for their (brilliance), (Mahito) for their (guidance), and YOU for (playing)\n\n' + '(Press ESC to return)' ); this.input.keyboard.once('keydown-ESC', () => overlay.destroy()); } createOverlay(text) { this.activeOverlay = true; const graphics = this.add.graphics(); graphics.fillStyle(0x000000, 0.95); graphics.fillRect(0, 0, 800, 600); const content = createGlitchText(this, 400, 300, text) .setStyle({ fontSize: '16px', color: '#ffffff', backgroundColor: '#000000', padding: { x: 12, y: 6 }, align: 'center', fixedWidth: 400, wordWrap: { width: 380 } }); return { destroy: () => { this.activeOverlay = false; graphics.destroy(); content.destroy(); } }; } } class GameScene extends Phaser.Scene { constructor() { super({ key: 'GameScene' }); // Particle system properties this.particlePool = []; this.maxParticles = 150; this.particleLifespan = 3000; this.dialogueStage = 0; // Track dialogue progress this.doorsOpened = 0; // Track number of opened doors this.oneWayDoors = new Set(); // Track one-way doors this.particleSpawnInterval = 67; // Adjusted to maintain particle density with more particles this.lastParticleSpawn = 0; this.particleScatterThreshold = 0.5; this.breadcrumbs = []; // Initialize breadcrumbs array this.lastBreadcrumb = 0; // Track last breadcrumb time this.breadcrumbInterval = 500; // Time between breadcrumbs (ms) this.maxBreadcrumbs = 50; // Maximum number of stored positions // Add mask layer for visibility this.zoomLevel = 2.01; // Initial zoom level this.maxZoomLevel = 2.50; // Maximum zoom level after 4 minutes this.zoomDuration = 240000; // 4 minutes in milliseconds this.startZoomTime = null; // Track when zoom started this.walls = []; this.maskLayer = null; this.visibilityMask = null; this.memoryObjects = new Map(); // Track illuminated objects and their fade times this.cursors = null; this.isRunning = false; this.flashlightMessage = null; this.interactKey = null; this.activeWaves = []; // Store active sound waves this.dialogueOptions = null; // Store dialogue options menu this.dorctos = []; // Store Dorctos NPCs this.totalFlashlightTime = 0; // Track total flashlight usage time this.maxFlashlightTime = 240000; // 4 minutes in milliseconds this.fadeOutActive = false; // Track if fade out is in progress this.fadeDuration = 200; // Duration of fade effect in milliseconds this.flickerIntensity = 0; // Track flicker intensity this.fadeOutCount = 0; // Track number of fade outs this.flickerRate = 100; // How often to update flicker (milliseconds) this.lastFlickerTime = 0; // Track last flicker update this.dorctoLastSoundTimes = new Map(); // Track last sound time for each Dorcto this.doorInteractionRange = 60; // Range for door interaction this.collectedKeys = 0; // Track collected keys this.keys = []; // Store key objects this.lastSoundTime = 0; this.soundCooldown = 775; // Minimum time between sounds in ms (35% less frequent) this.soundWaveConfig = { initialRadius: 3.885, // Reduced by 25% from 5.18 maxRadius: 29.148, // Reduced by 25% from 38.864 duration: 2500, thickness: 1.275, }; this.player = null; this.movementForce = 0.00381; // Increased by 15% from 0.00331 this.flashlight = null; this.flashlightKey = null; this.isFlashlightOn = false; this.rayCount = 50; this.rayLength = 200; this.lightAngle = Math.PI / 3; // Battery system this.batteryLevel = 100; this.batteryDrainRate = 0.00590; // Battery drains over 4 minutes (adjusted from 3min) this.batteryRechargeRate = 0.024; // Recharge 20% faster than before this.minBatteryLevel = 15; // Minimum battery level (dim light) this.maxRayLength = 200; // Maximum ray length at full battery this.minRayLength = 50; // Minimum ray length at low battery this.maxLightIntensity = 0.2; // Maximum light intensity this.minLightIntensity = 0.05; // Minimum light intensity this.doors = []; this.lockedDoors = new Set(); // Track which doors are locked this.doorAttempts = new Map(); // Track attempts for each door this.stuckDoors = new Set(); // Track which doors need multiple attempts this.isInCorridor = false; // Track if player is in a corridor this.crouchKey = null; this.isCrouching = false; this.normalPlayerRadius = 8.36; // Reduced by 15% from 9.83 this.squeezePlayerRadius = 4.17; // Reduced by 15% from 4.91 this.squeezingMovementMultiplier = 0.5; this.baseDamping = 0.95; this.driftDamping = 0.85; // Increased drift effect (lower value = more drift) // Cache keyMap to avoid recreation every frame this.keyMap = { up: { y: -1, keys: ['up'] }, down: { y: 1, keys: ['down'] }, left: { x: -1, rotation: -0.05, keys: ['left'] }, right: { x: 1, rotation: 0.05, keys: ['right'] } }; // Pre-allocate movement object to avoid garbage collection this.movement = { x: 0, y: 0, rotation: 0 }; } initializeParticlePool() { for (let i = 0; i < this.maxParticles; i++) { const particle = this.add.circle(0, 0, 0.5, 0xFFFFFF); particle.visible = false; particle.active = false; particle.velocity = { x: 0, y: 0 }; particle.lifespan = 0; particle.lastSeenTime = 0; // Track when particle was last seen particle.setAlpha(0); this.particlePool.push(particle); } } spawnParticle(x, y, velocityX = 0, velocityY = 0) { const particle = this.particlePool.find(p => !p.active); if (!particle) return; particle.setPosition(x, y); particle.velocity.x = velocityX + (Math.random() - 0.5) * 0.2; particle.velocity.y = velocityY + (Math.random() - 0.5) * 0.2; particle.lifespan = this.particleLifespan; particle.active = true; particle.visible = true; particle.setAlpha(0.3); } updateParticles(delta) { const now = this.time.now; // Spawn new particles if (now - this.lastParticleSpawn > this.particleSpawnInterval) { const spawnRadius = 100; const angle = Math.random() * Math.PI * 2; const distance = Math.random() * spawnRadius; this.spawnParticle( this.player.x + Math.cos(angle) * distance, this.player.y + Math.sin(angle) * distance ); this.lastParticleSpawn = now; } // Update existing particles this.particlePool.forEach(particle => { if (!particle.active) return; // Update particle physics particle.x += particle.velocity.x; particle.y += particle.velocity.y; // Apply natural drift particle.velocity.x += (Math.random() - 0.5) * 0.01; particle.velocity.y += (Math.random() - 0.5) * 0.01; // Scatter based on player movement if (this.player.body.speed > this.particleScatterThreshold) { const dx = particle.x - this.player.x; const dy = particle.y - this.player.y; const distance = Math.sqrt(dx * dx + dy * dy); if (distance < 50) { const force = (50 - distance) * 0.001; particle.velocity.x += (dx / distance) * force * this.player.body.speed; particle.velocity.y += (dy / distance) * force * this.player.body.speed; } } // Check if particle is in flashlight cone if (this.isFlashlightOn) { const angle = Phaser.Math.Angle.Between( this.player.x, this.player.y, particle.x, particle.y ); const baseAngle = Phaser.Math.Angle.Between( this.player.x, this.player.y, this.input.activePointer.worldX, this.input.activePointer.worldY ); const angleDiff = Phaser.Math.Angle.Wrap(angle - baseAngle); const distance = Phaser.Math.Distance.Between( this.player.x, this.player.y, particle.x, particle.y ); // Only show particle if it's in the flashlight cone if (Math.abs(angleDiff) <= this.lightAngle / 2 && distance <= this.rayLength) { particle.setAlpha(Math.min(0.3, particle.lifespan / this.particleLifespan * 0.3)); } else { particle.setAlpha(0); } } else { // When flashlight is off, particles are invisible particle.setAlpha(0); } // Update lifespan particle.lifespan -= delta; // Deactivate if lifetime is over if (particle.lifespan <= 0) { particle.active = false; particle.visible = false; } }); } preload() { // Load ambient sound this.load.audio('ambient', 'https://play.rosebud.ai/assets/Untitled (39).mp3?wdwQ'); } create() { this.input.setDefaultCursor('none'); // Hide cursor by default // Create fade in overlay const fadeInOverlay = this.add.graphics() .fillStyle(0x000000) .fillRect(0, 0, 800, 600) .setDepth(1001) .setScrollFactor(0) .setAlpha(1); // Fade in effect this.tweens.add({ targets: fadeInOverlay, alpha: 0, duration: 1000, ease: 'Power2', onComplete: () => { fadeInOverlay.destroy(); } }); // Create ambient sound but don't play yet this.ambientSound = this.sound.add('ambient', { volume: 0.5, loop: true }); this.hasStartedMusic = false; // Track if music has started this.initializeParticlePool(); // Prevent context menu on right click this.input.mouse.disableContextMenu(); // Set the background color to a dark color for atmosphere this.cameras.main.setBackgroundColor('#000000'); // Create map walls using lines const wallThickness = 2; // Much thinner walls const tileSize = 24; // Slightly smaller tile size const mapData = [ '##################################################', '#S # # Y Y K #', '# # # N # K # #', '# # # # N # #######', '# R1 # # # # / #', '####D######## ######D##############L########L### #', '# # Y # #', '# # # #############Y#### # #', '# # # # # # # # #', '#### # ##### # # # ######## # #', '# # L D #N # # #', '# # ##### # # ############L### # #', '# C #K # # # # #', '# # # # #######################L##### #', '# # # # L Y # #', '###D######### ####### ############# / #', '# # # # # # K# # #', '# # ######### # # # # ######', '# # # # # # N # # #', '# ######### # # # L # # #', '# L # # C ####### # #', '# ######### # # ### ### # # #', '# D K# # # #K # G # #######', '# # # # # # # # # #', '# # N # L # L # E #', '#######################################################' ]; this.isEnding = false; // Add flag for end sequence this.exitLight = null; // Track exit light graphics this.exitRayCount = 30; // Number of rays for exit light this.exitLightAngle = Math.PI * 0.7; // Wider angle for exit light this.exitRayLength = 120; // Length of exit light rays this.exitPosition = null; // Initialize exit position this.walls = []; // Process map data to create walls for (let y = 0; y < mapData.length; y++) { for (let x = 0; x < mapData[y].length; x++) { const tile = mapData[y][x]; if (tile === '#' || tile === '/') { // Calculate positions const posX = x * tileSize + tileSize / 2; const posY = y * tileSize + tileSize / 2; // Create wall segment const wall = this.add.rectangle(posX, posY, tileSize, tileSize, tile === '/' ? 0x444444 : 0x666666).setAlpha(0); // Different physics properties for pushable walls if (tile === '/') { this.matter.add.gameObject(wall, { isStatic: false, friction: 0.2, restitution: 0, mass: 50, density: 0.001, frictionAir: 0.2, label: 'pushable', collisionFilter: { category: 0x0001, mask: 0xFFFFFFFF } }); wall.isPushable = true; // Mark as pushable for reference } else { this.matter.add.gameObject(wall, { isStatic: true, friction: 0, restitution: 0, mass: Infinity, inertia: Infinity, collisionFilter: { category: 0x0001, mask: 0xFFFFFFFF } }); } this.walls.push(wall); } // Create exit at 'E' positions if (mapData[y][x] === 'E') { const posX = x * tileSize + tileSize / 2; const posY = y * tileSize + tileSize / 2; // Store exit position this.exitPosition = { x: posX, y: posY, tileX: x, tileY: y }; // Create exit marker (invisible by default) const exit = this.add.rectangle(posX, posY, tileSize * 1.5, tileSize * 1.5, 0xff0000) .setAlpha(0) .setDepth(10) .setBlendMode(Phaser.BlendModes.ADD); // Create static physics body for exit as sensor with larger detection area this.matter.add.gameObject(exit, { isStatic: true, isSensor: true, label: 'exit', collisionFilter: { category: 0x0002, mask: 0xFFFFFFFF } }); // Store exit object reference this.exitObject = exit; // Create exit light graphics this.exitLight = this.add.graphics() .setDepth(9); } // Create notes at 'N' or 'G' positions if (mapData[y][x] === 'N' || mapData[y][x] === 'G') { // Initialize note content tracking if not exists if (!this.usedNoteContent) { this.usedNoteContent = new Set(); this.allNoteContents = [ "*Dear colleague... (or whoever finds this)*\n\nThe keys aren't just for opening doors. They're proof that escape is (possible).\n\n- Dr. Dagger", "The (darkness) seems almost... (cooperative), doesn't it? Like it's (testing) us.\n\n- (X#@$%^&!) (&*@#$%)", "The doctor's (methods) are... (unorthodox). The (results) are... (remarkable).\n\n- Staff Note", "Progress (Report): (#0@£,???) showing signs of (adaptation) to the darkness. Further (observation) required.\n\n- Dr.(#@$%^r)", "*(Blood-stained paper, barely legible)*\n\n... (c3ll)... (3ast) (w1ng)... The (walls) are (thin) there... I saw... I (saw) them (escape)... through the (cr@cks)... (they) became (on3)... but (escaped)..." ]; } const posX = x * tileSize + tileSize / 2; const posY = y * tileSize + tileSize / 2; // Create note visual with different style for G const isGNote = mapData[y][x] === 'G'; const note = this.add.rectangle(posX, posY, tileSize / 2, tileSize / 2, isGNote ? 0x990000 : 0xDDDDDD).setAlpha(0); const noteText = this.add.text(posX, posY, isGNote ? '†' : 'N', { fontSize: '14px', color: '#000000', fontStyle: 'bold' }).setOrigin(0.5).setAlpha(0); // Add physics as sensor this.matter.add.gameObject(note, { isSensor: true, isStatic: true, label: 'note' }); // Store note text reference note.noteText = noteText; // Select unused note content if (isGNote) { // Special content for G note with wider text area and glitch effect note.content = "*(A corpse with its body carved into the flesh-with fingernails)*\n\nThey (dance) so beautifully when they (understand). (unintegible) batch (#2@f,???) made such (patterns) with their skull against the (walls). (#7@£,???) became one with the (ceiling)! Oh, how they (twist their limbs) and (merge) with the (walls)!\n\n*(restarting the cycle)*\n\nThis is just the start,\n\nNext (batch): (#9@£,???)"; note.textConfig = { fontSize: '10px', color: '#ffffff', backgroundColor: '#000000', padding: { x: 6, y: 3 }, align: 'center', fixedWidth: 360, wordWrap: { width: 345 } }; } else { let availableContent = this.allNoteContents.filter(content => !this.usedNoteContent.has(content)); // If all contents used, reset the tracking if (availableContent.length === 0) { this.usedNoteContent.clear(); availableContent = this.allNoteContents; } // Select random content from available ones const selectedContent = availableContent[Math.floor(Math.random() * availableContent.length)]; this.usedNoteContent.add(selectedContent); note.content = selectedContent; } } // Create doors at strategic positions if (mapData[y][x] === 'D' || mapData[y][x] === 'L' || mapData[y][x] === 'C' || mapData[y][x] === 'Y') { const posX = x * tileSize + tileSize / 2; const posY = y * tileSize + tileSize / 2; // Determine door orientation based on surrounding walls let isVertical = false; if (y > 0 && y < mapData.length - 1) { isVertical = mapData[y - 1][x] === '#' || mapData[y + 1][x] === '#'; } // Adjust door dimensions based on orientation const doorWidth = isVertical ? tileSize * 0.15 : tileSize * 0.8; const doorHeight = isVertical ? tileSize * 0.8 : tileSize * 0.15; // Create door as a rectangle with appropriate color const doorColor = mapData[y][x] === 'L' ? 0x990000 : mapData[y][x] === 'C' ? 0x4A3728 : mapData[y][x] === 'Y' ? 0x4169E1 : 0x8B4513; const door = this.add.rectangle(posX, posY, doorWidth, doorHeight, doorColor).setAlpha(0); // Mark stuck doors if (mapData[y][x] === 'C') { this.stuckDoors.add(door); } // Rotate the door to match the isometric view door.setAngle(45); // Add physics to the door with specific properties for push behavior // Special handling for 'C' doors and one-way doors const isStuckDoor = mapData[y][x] === 'C'; // Track one-way doors and store their position relative to walls if (mapData[y][x] === 'Y') { this.oneWayDoors.add(door); // Store direction info (right side only) door.allowedDirection = 'right'; } this.matter.add.gameObject(door, { isStatic: true, // All doors start static friction: 0.1, frictionStatic: 0.5, density: 0.001, restitution: 0, mass: isStuckDoor ? Infinity : 1, inertia: isStuckDoor ? Infinity : undefined, collisionFilter: { category: 0x0002, mask: 0xFFFFFFFF, group: 0 } }); // Calculate hinge point and create hinge visual const hingeOffset = isVertical ? { x: 0, y: -(tileSize * 0.4) } : { x: -(tileSize * 0.4), y: 0 }; // Create visible hinge const hinge = this.add.circle( posX + hingeOffset.x, posY + hingeOffset.y, 2, // hinge radius 0x3d3d3d // dark gray color ).setAlpha(0); // Store hinge reference in door object door.hinge = hinge; // Add constraint to make door swing this.matter.add.worldConstraint(door, 0, 1, { pointA: { x: posX + hingeOffset.x, y: posY + hingeOffset.y }, pointB: hingeOffset, stiffness: 0.8, length: 0, angularStiffness: 0.1 }); this.doors.push(door); if (mapData[y][x] === 'L') { this.lockedDoors.add(door); } } // Create keys at 'K' positions if (mapData[y][x] === 'K') { const posX = x * tileSize + tileSize / 2; const posY = y * tileSize + tileSize / 2; // Create key visual const key = this.add.rectangle(posX, posY, tileSize / 2, tileSize / 2, 0xFFD700).setAlpha(0); const keyText = this.add.text(posX, posY, 'K', { fontSize: '14px', color: '#000000' }).setOrigin(0.5).setAlpha(0); // Add physics this.matter.add.gameObject(key, { isSensor: true, isStatic: true, label: 'key' }); // Add to keys array and track associated text key.keyText = keyText; this.keys.push(key); } // Create Dorctos at 'R' positions if (mapData[y][x].startsWith('R')) { const posX = x * tileSize + tileSize / 2; const posY = y * tileSize + tileSize / 2; // Create Dorctos visual with same style as player const dorcto = this.add.circle(posX, posY, this.normalPlayerRadius).setStrokeStyle(1.7, 0xffffff); dorcto.setAlpha(0); // Start invisible // Add physics making Dorcto static and immovable this.matter.add.gameObject(dorcto, { label: 'dorcto', shape: 'circle', isStatic: true, isSensor: true, collisionFilter: { category: 0x0002, mask: 0xFFFFFFFF } }); // Add properties dorcto.name = mapData[y][x]; // Store R1, R2, etc. dorcto.hasShownInitialDialogue = false; dorcto.dialogueTimer = null; dorcto.dialogue = this.add.text(posX, posY - 30, '', { fontSize: '14px', color: '#ffffff', backgroundColor: '#000000', padding: { x: 8, y: 4 }, align: 'center' }).setOrigin(0.5).setAlpha(0); this.dorctos.push(dorcto); } // Store start position when 'S' is found if (mapData[y][x] === 'S') { this.startX = x * tileSize + tileSize / 2; this.startY = y * tileSize + tileSize / 2; } } } this.cameras.main.roundPixels = true; // Prevent pixel bleeding const playerRadius = 8.36; // Reduced by 15% from 9.83 this.player = this.add.circle(this.startX, this.startY, playerRadius).setStrokeStyle(1.7, 0xffffff).setAlpha(1); // Force visibility this.matter.add.gameObject(this.player, { label: 'player', shape: 'circle', friction: 0.1, collisionFilter: { category: 0x0001, mask: 0xFFFFFFFF }, restitution: 0.5, density: 0.005, frictionAir: 0.01, mass: 30, slop: 0, inertia: Infinity }); // Set up keyboard controls this.crouchKey = this.input.keyboard.addKey(Phaser.Input.Keyboard.KeyCodes.C); this.flashlightKey = this.input.keyboard.addKey(Phaser.Input.Keyboard.KeyCodes.F); this.runKey = this.input.keyboard.addKey(Phaser.Input.Keyboard.KeyCodes.SHIFT); this.interactKey = this.input.keyboard.addKey(Phaser.Input.Keyboard.KeyCodes.E); this.cursors = this.input.keyboard.addKeys({ up: Phaser.Input.Keyboard.KeyCodes.W, down: Phaser.Input.Keyboard.KeyCodes.S, left: Phaser.Input.Keyboard.KeyCodes.A, right: Phaser.Input.Keyboard.KeyCodes.D }); // Set up isometric camera this.cameras.main.setRotation(Math.PI / 4); // 45 degrees rotation this.cameras.main.setZoom(this.zoomLevel); // Add camera follow setup // Initial camera follow setup this.cameras.main.startFollow(this.player, { offsetX: 0, offsetY: 0, lerpX: 0.1, lerpY: 0.1, deadzone: new Phaser.Geom.Rectangle(100, 100, 600, 400) // Add deadzone for smoother camera movement }); // Create flashlight graphics object this.flashlight = this.add.graphics(); this.flashlight.setDepth(998); // Just below the mask layer // Create mask layer and visibility mask this.maskLayer = this.add.graphics(); this.visibilityMask = this.add.graphics(); // Set up the mask const mask = new Phaser.Display.Masks.GeometryMask(this, this.visibilityMask); // Create a dark overlay this.maskLayer.fillStyle(0x000000, 1).fillRect(-2000, -2000, 4000, 4000).setDepth(999).setMask(mask); this.soundWaveGraphics = this.add.graphics().setDepth(997); this.flashlightMessage = createGlitchText(this, 400, 300, '*(Head throbbing)...(Darkness)...I need to turn (ON) my (F)lashlight...*') .setStyle({ fontSize: '18px', color: '#ffffff', backgroundColor: '#000000', padding: { x: 10, y: 5 }, align: 'center', fontStyle: 'italic', fixedWidth: 400, wordWrap: { width: 390 } }) .setScrollFactor(0) .setDepth(1000); } shutdown = () => { const cleanupObject = obj => { // Stop ambient sound if it exists if (this.ambientSound) { this.ambientSound.stop(); this.ambientSound.destroy(); } if (obj?.active) { if (obj.body) this.matter.world.remove(obj); if (obj.clear) obj.clear(); obj.destroy(); } }; cleanupObject(this.player); this.doors?.forEach(cleanupObject); cleanupObject(this.flashlight); cleanupObject(this.soundWaveGraphics); if (this.cursors) Object.values(this.cursors).forEach(key => key?.destroy()); [this.squeezingKey, this.flashlightKey].forEach(key => key?.destroy()); this.matter.world.off('collisionstart'); this.tweens.killAll(); Object.assign(this, { doors: [], activeWaves: [] }); this.lockedDoors?.clear(); }; update(time, delta) { if (!this.player || !this.player.body) return; // Check distance to notes and update visibility this.children.list.forEach(obj => { if (obj.body?.label === 'note' && obj.isPlayerNear) { const distance = Phaser.Math.Distance.Between( this.player.x, this.player.y, obj.x, obj.y ); if (distance > 35) { // Same interaction range as before obj.isPlayerNear = false; if (obj.dialogue) { this.tweens.add({ targets: obj.dialogue, alpha: 0, duration: 500, onComplete: () => { obj.dialogue.destroy(); obj.dialogue = null; } }); } } } }); // Check if player has reached the exit const tileSize = 24; if (this.exitPosition && !this.isEnding) { const distanceToExit = Phaser.Math.Distance.Between( this.player.x, this.player.y, this.exitPosition.x, this.exitPosition.y ); if (distanceToExit < tileSize) { this.isEnding = true; this.isEndSequenceTriggered = true; // Add flag when player actually reaches exit this.startEndSequence(); } } // Update particle system this.updateParticles(delta); // Handle squeezing state // Check if player is in a corridor by detecting nearby walls const bodies = this.matter.world.localWorld.bodies; const playerPos = this.player.body.position; const detectionRadius = this.normalPlayerRadius * 1.2; // Count nearby walls let nearbyWalls = 0; for (let body of bodies) { if (body !== this.player.body && body.isStatic && !this.doors.some(door => door.body === body)) { const distance = Phaser.Math.Distance.Between( playerPos.x, playerPos.y, body.position.x, body.position.y ); if (distance < detectionRadius * 2) { nearbyWalls++; } } } this.isInCorridor = nearbyWalls >= 2; const wasCrouching = this.isCrouching; this.isCrouching = this.crouchKey.isDown || (wasCrouching && this.isInCorridor); // Change player size when crouching state changes and it's safe to do so if (wasCrouching !== this.isCrouching && (!this.isInCorridor || this.isCrouching)) { const newRadius = this.isCrouching ? this.squeezePlayerRadius : this.normalPlayerRadius; // Store current position const currentPos = { x: this.player.x, y: this.player.y }; // Remove old physics body this.matter.world.remove(this.player.body); // Update circle size this.player.setRadius(newRadius); // Add new physics body with updated size this.matter.add.gameObject(this.player, { shape: 'circle', friction: 0, restitution: 0.5, density: 0.005, frictionAir: 0.01, mass: 30, slop: 0, inertia: Infinity }); // Restore position this.player.setPosition(currentPos.x, currentPos.y); } this.handleMovement(); this.handleFlashlight(); // Update Dorctos behavior this.dorctos.forEach(dorcto => { if (!dorcto?.active) return; const distance = Phaser.Math.Distance.Between(this.player.x, this.player.y, dorcto.x, dorcto.y); const baseAngle = Math.atan2(this.player.y - dorcto.y, this.player.x - dorcto.x); // Show dialogue when player is near and dorcto is visible if (distance < 35) { // Reduced by 30% from 50 // Show initial dialogue if not shown yet if (!dorcto.hasShownInitialDialogue) { const dialogueText = dorcto.name === 'R2' ? "Hey, you?, what are you doing (here), and where is Dr.Dagger?" : "(*fidgets) A convenient (blackout)... how (delightfully) concerning you're getting caught in this (mess). But you got a pocket flashlight? *soft laugh* That's... fortunate, I suppose. We need to get out of her(E), aren't we?"; dorcto.dialogue = createGlitchText(this, dorcto.x, dorcto.y - 25, dialogueText); dorcto.dialogue.setStyle({ fontSize: '12px', color: '#ffffff', backgroundColor: '#000000', padding: { x: 6, y: 3 }, align: 'center', fixedWidth: 240, wordWrap: { width: 230 } }); dorcto.dialogue.setAlpha(1); dorcto.hasShownInitialDialogue = true; // Clear existing timer if any if (dorcto.dialogueTimer) { dorcto.dialogueTimer.remove(); } // Set fade-out timer dorcto.dialogueTimer = this.time.delayedCall(15000, () => { if (!this.dialogueOptions) { this.tweens.add({ targets: dorcto.dialogue, alpha: 0, duration: 500, onComplete: () => { dorcto.dialogue.glitchTimer?.remove(); } }); } }); } dorcto.dialogue.x = dorcto.x; dorcto.dialogue.y = dorcto.y - 25; dorcto.dialogue.setOrigin(0.5, 1); // Handle interaction to show dialogue options if (Phaser.Input.Keyboard.JustDown(this.interactKey) && !this.dialogueOptions && !this.isEnding && !this.fadeOutActive) { // Create dialogue options menu centered like flashlight message // Create dialogue options at Dorcto's position // Clear any existing dialogue timer if (dorcto.dialogueTimer) { dorcto.dialogueTimer.remove(); } // Hide the initial dialogue dorcto.dialogue.setAlpha(0); // Create dialogue options menu centered like flashlight message // Create dialogue options at Dorcto's position this.input.setDefaultCursor('pointer'); // Show cursor during dialogue this.dialogueOptions = this.add.container(dorcto.x + 80, dorcto.y - 20); // Reduced vertical offset by 50% // Set alpha to ensure visibility this.dialogueOptions.setAlpha(1); const getTalkOption = () => { switch (this.dialogueStage) { case 7: // New stage after finding exit return { text: '[Talk] About that exit...', action: () => { const response = "(delighted laugh) Oh, you've found him! How... (precious). But you see, we're both (bound) here. Not by (choice), oh no... *adjusts coat* The (darkness) has its own... (schedule). But theres are (more) to be found, more (doors) to be opened... More (secrets) to be... (uncovered). Make the most of your... (extended stay)"; this.dialogueStage = 0; // Reset after this dialogue this.showDorctoResponse(dorcto, response); } }; case 6: // Previous case remains unchanged return { text: '[Talk] My head...it hurts...', action: () => { const response = "*gleeful giggle* Oh, does your (head) hurt? The (darkness) can be quite... (persuasive). *adjusts glasses* Keep (trying), though! Your (determination) is... (amusing). Like watching a (moth) drawn to the (flame)..."; this.dialogueStage = 6; // Stay in head hurts dialogue until player reaches exit this.showDorctoResponse(dorcto, response); } }; case 0: return { text: '[Talk] Who are you anyway?', action: () => { const response = "*adjusts coat* A (doctor) Why? yes... fresh from the (academy). *laughs softly* Started today, in fact. Quite the (timing), wouldn't you agree? Almost as if it were... (planned)."; this.dialogueStage = 1; this.showDorctoResponse(dorcto, response); } }; case 1: return { text: '[Talk] What happened here?', action: () => { const response = "*leans closer* The (darkness) came first,... Oh, you should see what the other (patients) are doing now. *whispers* They're... ascending, in their own peculiar way. Fascinating, really..."; this.dialogueStage = 2; this.showDorctoResponse(dorcto, response); } }; case 2: return { text: '[Talk] Have you seen Dr.Dagger?', action: () => { const response = "*twitches* Dr.(Dagger)... ah yes. He was quite... (cooperative). But let's not dawdle here... *glances around* These halls have developed quite an (appetite) lately..."; this.dialogueStage = 3; this.showDorctoResponse(dorcto, response); } }; case 3: return { text: '[Talk] Why are you so nervous?', action: () => { const response = "*fidgets with glasses* (Nervous)? Oh, I suppose I am... *soft giggle* It's just... the (patients) are finally getting their (treatment). The (darkness) is quite the effective... therapist. *twitches* Wouldn't you agree?"; this.dialogueStage = 4; this.showDorctoResponse(dorcto, response); } }; case 4: return { text: '[Insist] So...are you telling where Dagger is?', action: () => { const response = "(Oh...yes) follow the narrow (corridors). Through the (locked doors), past where the (walls) whisper...Dr.(Dagger) went that way, (dancing). But mind the frail keys...(use) them wisely. *twitches violently* East... always (east)..."; this.dialogueStage = 5; this.showDorctoResponse(dorcto, response); } }; case 5: return { text: '[Follow me?]', action: () => { const response = "*nervous laugh* Oh (no), I've (tried) too many times... this (place) won't let anyone... *fidgets with coat* This (place) have their own (plans), you see? Will (keep) us where we (belong). *whispers* Better to stay in our (assigned) spaces..."; // Progress to appropriate stage based on game state if (this.isEnding || this.isEndSequenceTriggered) { this.dialogueStage = 7; // Keep exit dialogue if sequence has started } else if (this.fadeOutCount > 0 || this.fadeOutActive) { this.dialogueStage = 6; // Show head hurts dialogue during/after fadeouts } else { this.dialogueStage = 0; // Reset to beginning } this.showDorctoResponse(dorcto, response); } }; } }; const options = [ getTalkOption(), { text: '[X] Exit conversation', action: () => { this.closeDialogueOptions(); if (dorcto.dialogue) { dorcto.dialogue.setAlpha(0); } } } ]; this.showDorctoResponse = (dorcto, response) => { dorcto.dialogue = createGlitchText(this, dorcto.x, dorcto.y - 25, response); dorcto.dialogue.setStyle({ fontSize: '12px', color: '#ffffff', backgroundColor: '#000000', padding: { x: 6, y: 3 }, align: 'center', fixedWidth: 240, wordWrap: { width: 230 } }); dorcto.dialogue.setAlpha(1); if (dorcto.dialogueTimer) { dorcto.dialogueTimer.remove(); } dorcto.dialogueTimer = this.time.delayedCall(15000, () => { if (!this.dialogueOptions) { this.tweens.add({ targets: dorcto.dialogue, alpha: 0, duration: 500, onComplete: () => { dorcto.dialogue.glitchTimer?.remove(); } }); } }); this.closeDialogueOptions(); }; let yOffset = -23; // Moved up by 15% from -20 options.forEach(option => { const text = createGlitchText(this, 0, yOffset, option.text) .setStyle({ fontSize: '9px', color: '#aaaaaa', backgroundColor: '#000000', padding: { x: 5, y: 2 }, fixedWidth: 240, align: 'left', wordWrap: { width: 230 } }) .setOrigin(0.5) .setInteractive({ useHandCursor: true }) .on('pointerover', () => { text.setStyle({ color: '#ffffff' }); }) .on('pointerout', () => { text.setStyle({ color: '#aaaaaa' }); }) .on('pointerdown', () => { option.action(); }); this.dialogueOptions.add(text); yOffset += 28; // Increased spacing for potential wrapped text }); // Set depth and update visibility settings this.dialogueOptions.setDepth(1000); // Ensure each text element is visible this.dialogueOptions.each(child => { child.setAlpha(1); }); } } else if (!this.dialogueOptions) { dorcto.dialogue.setAlpha(0); } }); // Provide visual feedback when player can't expand if (this.crouchKey.isUp && this.isCrouching && this.isInCorridor) { this.player.setStrokeStyle(2, 0xff0000); this.time.delayedCall(100, () => { this.player.setStrokeStyle(2, 0xffffff); }); } // Update and render sound waves this.handleSoundWaves.update(); // Generate sound waves based on movement if ((this.movement.x || this.movement.y) && this.time.now - this.lastSoundTime > this.soundCooldown) { // Create larger sound waves when running const soundIntensity = this.isRunning ? 2 : 1; this.handleSoundWaves.create(soundIntensity); this.lastSoundTime = this.time.now; } if (!this.collisionHandler && this.matter?.world) { this.collisionHandler = this.handleCollisions; this.matter.world.on('collisionstart', this.collisionHandler); } } lineIntersection = (x1, y1, x2, y2, x3, y3, x4, y4) => { const [d, ε] = [(x1 - x2) * (y3 - y4) - (y1 - y2) * (x3 - x4), 0.0001], [t, u] = Math.abs(d) < ε ? [0, 0] : [ ((x1 - x3) * (y3 - y4) - (y1 - y3) * (x3 - x4)) / d, -((x1 - x2) * (y1 - y3) - (y1 - y2) * (x1 - x3)) / d ]; return Math.abs(d) >= ε && t >= -ε && t <= 1 + ε && u >= -ε && u <= 1 + ε && { x: x1 + t * (x2 - x1), y: y1 + t * (y2 - y1), t }; }; handleSoundWaves = { create: (intensity = 1, source = null) => this.soundWaveGraphics?.active && (source || this.player)?.active && this.activeWaves.push({ x: (source || this.player).body.position.x, y: (source || this.player).body.position.y, radius: this.soundWaveConfig.initialRadius * (this.isSqueezing ? 0.5 : 1) * intensity, alpha: 1, createdAt: this.time.now, maxRadius: this.soundWaveConfig.maxRadius * (this.isSqueezing ? 0.5 : 1) * intensity }), update: () => { if (!this.soundWaveGraphics?.active) return; this.soundWaveGraphics.clear(); // Filter and update active waves this.activeWaves = this.activeWaves.filter(wave => { const progress = (this.time.now - wave.createdAt) / this.soundWaveConfig.duration; if (progress >= 1) return false; const radiusScale = wave.maxRadius / this.soundWaveConfig.maxRadius; wave.radius = Phaser.Math.Easing.Sine.Out(progress) * wave.maxRadius + (this.soundWaveConfig.initialRadius * radiusScale); wave.alpha = Phaser.Math.Easing.Cubic.Out(1 - progress) * 0.8; const lineThickness = this.soundWaveConfig.thickness * (1 - progress * 0.5); this.soundWaveGraphics .lineStyle(lineThickness, 0xffffff, wave.alpha * 0.75) .strokeCircle(wave.x, wave.y, wave.radius); return true; }); } }; closeDialogueOptions = () => this.dialogueOptions?.alpha && this.tweens.add({ targets: this.dialogueOptions, alpha: 0, duration: 500, ease: 'Power2', onComplete: () => { this.dialogueOptions?.destroy(); this.dialogueOptions = null; this.input.setDefaultCursor('none'); // Hide cursor after dialogue } }); destroy = () => [ [...(this.dorctos || [])].forEach(obj => (obj?.body && this.matter.world.remove(obj.body), obj?.dialogue?.destroy(), obj?.destroy())), this.memoryObjects?.clear(), this.shutdown(), Object.assign(this, Object.fromEntries([ 'dorctos', 'player', 'flashlight', 'maskLayer', 'visibilityMask', 'cursors', 'squeezingKey', 'flashlightKey', 'interactKey', 'keyMap', 'movement' ].map(k => [k, null])), { breadcrumbs: [] }), super.destroy?.() ]; handleMovement = () => !this.player?.body ? null : (() => { const { t: time, p: player, mv: movement, km: keyMap, c: cursors, m: matter } = { t: this.time, p: this.player, mv: this.movement, km: this.keyMap, c: this.cursors, m: this.matter }; Object.assign(movement, { x: 0, y: 0, rotation: 0 }); time.now - this.lastBreadcrumb >= this.breadcrumbInterval && player.body.speed > 0.1 && (this.breadcrumbs = [{ x: player.x, y: player.y, timestamp: time.now }, ...this.breadcrumbs.slice(0, this.maxBreadcrumbs - 1) ], this.lastBreadcrumb = time.now); Object.entries(keyMap).forEach(([_, d]) => d.keys.some(k => cursors[k]?.isDown) && (movement.x += d.x || 0, movement.y += d.y || 0, movement.rotation = d.rotation || movement.rotation)); this.isRunning = this.runKey.isDown && !this.isCrouching; (movement.x || movement.y) && (() => { const mult = 100 * (this.isCrouching ? this.squeezingMovementMultiplier : 1) * (this.isRunning ? 1.75 : 1), drift = 0.85, { x: cx, y: cy } = player.body.velocity; matter.setVelocity(player, (movement.x * this.movementForce * mult * drift) + (cx * (1 - drift)), (movement.y * this.movementForce * mult * drift) + (cy * (1 - drift))); })(); matter.setAngularVelocity(player, movement.rotation); player.body.velocity && matter.setVelocity(player, player.body.velocity.x * ((movement.x || movement.y) ? this.baseDamping : this.driftDamping), player.body.velocity.y * ((movement.x || movement.y) ? this.baseDamping : this.driftDamping)); })(); handleFlashlight() { if (Phaser.Input.Keyboard.JustDown(this.flashlightKey)) { this.isFlashlightOn = !this.isFlashlightOn; // Initialize zoom start time when flashlight is first turned on if (this.isFlashlightOn && !this.startZoomTime) { this.startZoomTime = this.time.now; } // Start ambient music if it's the first time turning on flashlight if (!this.hasStartedMusic && this.ambientSound) { // Start with low volume and build up this.ambientSound.setVolume(0.1); // Start at 10% volume this.ambientSound.play(); this.hasStartedMusic = true; // Gradually increase volume to 50% over 4 minutes this.tweens.add({ targets: this.ambientSound, volume: 0.5, duration: 240000, ease: 'Linear' }); } this.flashlightMessage && this.tweens.add({ targets: this.flashlightMessage, alpha: 0, duration: 500 }).on('complete', () => { this.flashlightMessage?.destroy(); this.flashlightMessage = null; }); } // Update battery level // Update total flashlight time and check for fadeout condition if (this.isFlashlightOn) { this.totalFlashlightTime += this.game.loop.delta; // Calculate remaining time const remainingTime = this.maxFlashlightTime - this.totalFlashlightTime; // Start flickering in the last 2 minutes (120000ms from 240000ms total) if (remainingTime <= 120000) { // Last 2 minutes (from minute 2 to 4) // Calculate flicker progress over 2 minutes const flickerProgress = (1 - (remainingTime / 120000)) * 0.8; // Maximum intensity of 0.8 // Gradually increase randomness of flicker const randomIntensity = Math.random() * flickerProgress; // Add occasional stronger flickers as time runs out const extraFlicker = Math.random() < flickerProgress * 0.2 ? Math.random() * 0.3 * flickerProgress : 0; // Update flicker more frequently as time runs out if (this.time.now - this.lastFlickerTime >= this.flickerRate) { // Combine regular and extra flicker effects this.flickerIntensity = randomIntensity + extraFlicker; // Adjust flicker rate based on remaining time this.flickerRate = 100 + (remainingTime / 90000) * 200; // Flicker gets more rapid this.lastFlickerTime = this.time.now; } } else { this.flickerIntensity = 0; } if (this.totalFlashlightTime >= this.maxFlashlightTime && !this.fadeOutActive) { this.fadeOutActive = true; this.startFadeOut(); } this.batteryLevel = Math.max(this.minBatteryLevel, this.batteryLevel - this.batteryDrainRate); } else { this.batteryLevel = Math.min(100, this.batteryLevel + this.batteryRechargeRate); } // Calculate dynamic ray length and intensity based on battery level const batteryFactor = (this.batteryLevel - this.minBatteryLevel) / (100 - this.minBatteryLevel); this.rayLength = this.minRayLength + (this.maxRayLength - this.minRayLength) * batteryFactor; const currentLightIntensity = this.minLightIntensity + (this.maxLightIntensity - this.minLightIntensity) * batteryFactor; if (!this.flashlight) return; // Handle gradual zoom if flashlight is on if (this.isFlashlightOn && this.startZoomTime) { const elapsedTime = Math.min(this.time.now - this.startZoomTime, this.zoomDuration); const zoomProgress = elapsedTime / this.zoomDuration; const newZoom = this.zoomLevel + ((this.maxZoomLevel - this.zoomLevel) * zoomProgress); this.cameras.main.setZoom(newZoom); } if (!this.isFlashlightOn) { this.handleObjectsVisibility(); } // Always update exit light regardless of flashlight state this.updateExitLight(); const pointer = this.input.activePointer; const worldPoint = this.cameras.main.getWorldPoint(pointer.x, pointer.y); this.maskLayer.clear() .fillStyle(0x000000, this.isFlashlightOn ? 0.999 : 1) .fillRect(-2000, -2000, 4000, 4000); const baseAngle = Phaser.Math.Angle.Between( this.player.x, this.player.y, worldPoint.x, worldPoint.y ); this.flashlight.clear(); this.visibilityMask.clear(); if (this.isFlashlightOn) { this.visibilityMask.fillStyle(0xffffff, 1); this.visibilityMask.beginPath(); this.visibilityMask.moveTo(this.player.x, this.player.y); const gameObjects = [...this.walls, ...this.doors, ...this.keys, ...this.dorctos, this.player]; gameObjects.forEach(obj => this.updateObjectVisibility(obj, baseAngle)); for (let i = 0; i < this.rayCount; i++) { this.castFlashlightRay(i, baseAngle); } this.visibilityMask.closePath(); this.visibilityMask.fillPath(); } } updateObjectVisibility(obj, baseAngle) { if (!obj || !obj.active) return; // Make player always visible if (obj === this.player) { obj.setAlpha(1); return; } const angle = Phaser.Math.Angle.Between( this.player.x, this.player.y, obj.x, obj.y ); const angleDiff = Phaser.Math.Angle.Wrap(angle - baseAngle); const distance = Phaser.Math.Distance.Between( this.player.x, this.player.y, obj.x, obj.y ); const inCone = Math.abs(angleDiff) <= this.lightAngle / 2 && distance <= this.rayLength; if (!inCone) { this.handleObjectFade(obj); return; } const bodies = this.matter.world.localWorld.bodies; let isVisible = true; for (let body of bodies) { if (!body.isStatic || body === obj.body) continue; const vertices = body.vertices; for (let j = 0, len = vertices.length; j < len; j++) { if (this.lineIntersection( this.player.x, this.player.y, obj.x, obj.y, vertices[j].x, vertices[j].y, vertices[(j + 1) % len].x, vertices[(j + 1) % len].y )) { isVisible = false; break; } } if (!isVisible) break; } if (isVisible) { obj.setAlpha(1); if (obj.keyText) obj.keyText.setAlpha(1); this.memoryObjects.set(obj, this.time.now); } else { this.handleObjectFade(obj); } } handleObjectFade = obj => { // If flashlight is off, ensure immediate invisibility if (!this.isFlashlightOn) { this.setObjectAndTextAlpha(obj, 0); this.memoryObjects.delete(obj); return; } const lastSeen = this.memoryObjects.get(obj) ?? 0; const timeSinceSeen = this.time.now - lastSeen; const MEMORY_DURATION = 5000; // Ensure complete invisibility after memory duration if (!lastSeen || timeSinceSeen >= MEMORY_DURATION) { this.setObjectAndTextAlpha(obj, 0); this.memoryObjects.delete(obj); return; } // Calculate fade with proper clamping const alpha = Math.max(0, Math.min(1, 1 - (timeSinceSeen / MEMORY_DURATION))); // Only show if there's actual visibility if (alpha > 0) { this.setObjectAndTextAlpha(obj, alpha); } else { this.setObjectAndTextAlpha(obj, 0); this.memoryObjects.delete(obj); } }; castFlashlightRay(index, baseAngle) { // Calculate ray properties const rayAngle = baseAngle - (this.lightAngle / 2) + (this.lightAngle * index / (this.rayCount - 1)); const rayX = this.player.x; const rayY = this.player.y; const rayEndX = rayX + Math.cos(rayAngle) * this.rayLength; const rayEndY = rayY + Math.sin(rayAngle) * this.rayLength; // Find closest intersection const rayDir = { x: Math.cos(rayAngle), y: Math.sin(rayAngle) }; let nearestIntersection = { point: null, distance: this.rayLength }; // Filter nearby bodies (both static and Dorctos, excluding exit) const maxDistSq = this.rayLength * this.rayLength * 1.5; const nearbyBodies = this.matter.world.localWorld.bodies.filter(body => { if (!body.isStatic && !this.dorctos.some(dorcto => dorcto.body === body)) return false; if (body.label === 'exit') return false; // Skip exit from ray collision const dx = body.position.x - rayX; const dy = body.position.y - rayY; return (dx * dx + dy * dy) <= maxDistSq; }); // Check intersections for (let body of nearbyBodies) { // Special handling for Dorcto bodies (circular) if (this.dorctos.some(dorcto => dorcto.body === body)) { const center = body.position; const radius = body.circleRadius; // Calculate intersection with circle const dx = rayEndX - rayX; const dy = rayEndY - rayY; const a = dx * dx + dy * dy; const b = 2 * ((rayX - center.x) * dx + (rayY - center.y) * dy); const c = (rayX - center.x) * (rayX - center.x) + (rayY - center.y) * (rayY - center.y) - radius * radius; const discriminant = b * b - 4 * a * c; if (discriminant >= 0) { const t = (-b - Math.sqrt(discriminant)) / (2 * a); if (t >= 0 && t <= 1) { const intersectionX = rayX + t * dx; const intersectionY = rayY + t * dy; const dist = Phaser.Math.Distance.Between(rayX, rayY, intersectionX, intersectionY); if (dist < nearestIntersection.distance) { nearestIntersection = { point: { x: intersectionX, y: intersectionY }, distance: dist }; } } } continue; } // Regular handling for other bodies const vertices = body.vertices; for (let j = 0; j < vertices.length; j++) { const v1 = vertices[j]; const v2 = vertices[(j + 1) % vertices.length]; const intersection = this.lineIntersection( rayX, rayY, rayEndX, rayEndY, v1.x, v1.y, v2.x, v2.y ); if (intersection) { const dist = Phaser.Math.Distance.Between(rayX, rayY, intersection.x, intersection.y); if (dist < nearestIntersection.distance) { nearestIntersection = { point: intersection, distance: dist }; } } } } // Draw ray const endPoint = nearestIntersection.point || { x: rayEndX, y: rayEndY }; this.flashlight .beginPath() .fillStyle(0xffffff, this.isFlashlightOn ? (this.minLightIntensity + (this.maxLightIntensity - this.minLightIntensity) * ((this.batteryLevel - this.minBatteryLevel) / (100 - this.minBatteryLevel))) * (1 - this.flickerIntensity) : // Apply flicker effect to light intensity this.minLightIntensity) .moveTo(rayX, rayY) .lineTo(endPoint.x, endPoint.y); // Add width to ray const width = 5; const perpX = -rayDir.y * width; const perpY = rayDir.x * width; this.flashlight .lineTo(endPoint.x + perpX, endPoint.y + perpY) .lineTo(endPoint.x - perpX, endPoint.y - perpY) .closePath() .fillPath(); } handleCollisions = ({ pairs } = {}) => this.player?.body && pairs?.forEach(p => { if (!p?.bodyA?.gameObject || !p?.bodyB?.gameObject) return; this.handleKeyCollection(p); this.handleNoteCollision(p); // Enhanced exit collision detection const bodyA = p.bodyA; const bodyB = p.bodyB; const playerBody = bodyA.gameObject === this.player ? bodyA : bodyB.gameObject === this.player ? bodyB : null; const exitBody = bodyA.label === 'exit' ? bodyA : bodyB.label === 'exit' ? bodyB : null; if (playerBody && exitBody && !this.isEnding) { this.startEndSequence(); return; } if (Phaser.Input.Keyboard.JustDown(this.interactKey)) { // Find nearest door within range const nearestDoor = this.doors.find(door => this.isWithinDoorRange(door)); if (nearestDoor) { this.handleDoorInteraction(nearestDoor); } } this.handleWallCollision(p); }); handleKeyCollection = (pair) => { const { bodyA, bodyB } = pair; const playerBody = bodyA.gameObject === this.player ? bodyA : bodyB.gameObject === this.player ? bodyB : null; const keyBody = bodyA.label === 'key' ? bodyA : bodyB.label === 'key' ? bodyB : null; if (!playerBody || !keyBody) return; const key = keyBody.gameObject; this.keys = this.keys.filter(k => k !== key); this.matter.world.remove(keyBody); key.keyText?.destroy(); key.destroy(); this.collectedKeys++; }; handleWallCollision = ({ bodyA, bodyB, collision }) => { const [playerBody, otherBody] = bodyA.gameObject === this.player ? [bodyA, bodyB] : [bodyB, bodyA]; if (!playerBody || !otherBody) return; // Handle pushable walls if (otherBody.gameObject?.isPushable) { const pushForce = 0.0005; // Adjust this value to control push strength const angle = Math.atan2( otherBody.position.y - playerBody.position.y, otherBody.position.x - playerBody.position.x ); this.matter.body.applyForce(otherBody, otherBody.position, { x: Math.cos(angle) * pushForce * playerBody.velocity.x, y: Math.sin(angle) * pushForce * playerBody.velocity.y }); // Create sound wave when pushing if (Math.abs(playerBody.velocity.x) > 0.5 || Math.abs(playerBody.velocity.y) > 0.5) { this.handleSoundWaves.create(1.5); } return; } // Handle regular walls playerBody && otherBody?.isStatic && !this.doors.some(d => d?.body === otherBody) && collision?.relative && (v => v > 1 && this.handleSoundWaves.create(Math.min(v / 3, 3.5)))(Math.hypot(collision.relative.x || 0, collision.relative.y || 0)); }; handleNoteCollision = (pair) => { const { bodyA, bodyB } = pair; const playerBody = bodyA.gameObject === this.player ? bodyA : bodyB.gameObject === this.player ? bodyB : null; const noteBody = bodyA.label === 'note' ? bodyA : bodyB.label === 'note' ? bodyB : null; if (!playerBody || !noteBody) return; const note = noteBody.gameObject; note.setAlpha(1); note.noteText.setAlpha(1); note.isPlayerNear = true; // Track if player is near // Show note content when player is near if (!note.dialogue) { note.dialogue = createGlitchText(this, note.x, note.y - 25, note.content) .setStyle(note.textConfig || { fontSize: '12px', color: '#ffffff', backgroundColor: '#000000', padding: { x: 6, y: 3 }, align: 'center', fixedWidth: 240, wordWrap: { width: 230 } }) .setOrigin(0.5); } }; // Check if player is on the correct side of a one-way door isValidDoorSide = (door) => { if (!this.oneWayDoors.has(door)) return true; // For one-way doors, check if player is on the right side if (door.allowedDirection === 'right') { return this.player.x > door.x; } return true; } isWithinDoorRange = door => { const range = this.lockedDoors.has(door) ? 60 : 85; return Phaser.Math.Distance.Between(this.player.x, this.player.y, door.x, door.y) <= range; } handleDoorInteraction = door => { // Validate that this is actually a door object if (!door || !this.doors.includes(door)) { return; } // Check if player is on the valid side for one-way doors if (!this.isValidDoorSide(door)) { // Visual feedback for invalid side const originalColor = door.fillColor; door.setFillStyle(0xff0000); this.time.delayedCall(100, () => { door.setFillStyle(originalColor); }); // Show blocked message for one-way doors if (this.oneWayDoors.has(door)) { // Remove existing message if there is one if (door.blockedMessage) { door.blockedMessage.destroy(); } // Create new blocked message door.blockedMessage = createGlitchText(this, door.x, door.y - 20, "*(blocked) from this (side)*") .setStyle({ fontSize: '10px', color: '#4169E1', backgroundColor: '#000000', padding: { x: 4, y: 2 }, align: 'center' }) .setDepth(1000); // Remove message after 5 seconds this.time.delayedCall(5000, () => { if (door.blockedMessage) { door.blockedMessage.destroy(); door.blockedMessage = null; } }); } return; } // Process door interaction based on type if (this.lockedDoors.has(door)) { this.handleLockedDoor(door); } else if (this.stuckDoors.has(door)) { this.handleStuckDoor(door); } else { this.handleNormalDoor(door); } }; handleLockedDoor = door => { if (this.collectedKeys > 0) { this.lockedDoors.delete(door); this.collectedKeys--; door.setFillStyle(0x8B4513); this.applyDoorForce(door, 0.001); this.doorsOpened++; } else { // Visual feedback door.setFillStyle(0xff0000); this.time.delayedCall(100, () => door.setFillStyle(0x990000)); // Remove existing message if there is one if (door.keyMessage) { door.keyMessage.destroy(); } // Create new key requirement message door.keyMessage = createGlitchText(this, door.x, door.y - 20, "*(need) a (key)*") .setStyle({ fontSize: '10px', color: '#990000', backgroundColor: '#000000', padding: { x: 4, y: 2 }, align: 'center' }) .setDepth(1000); // Remove message after 5 seconds this.time.delayedCall(5000, () => { if (door.keyMessage) { door.keyMessage.destroy(); door.keyMessage = null; } }); } }; handleStuckDoor = (door) => { const attempts = this.doorAttempts.get(door) || 0; if (attempts < 2) { // Store original position before shake const originalX = door.x; const originalY = door.y; this.doorAttempts.set(door, attempts + 1); door.setFillStyle(0xff0000); this.time.delayedCall(100, () => door.setFillStyle(0x4A3728)); // Remove existing message if there is one if (door.stuckMessage) { door.stuckMessage.destroy(); } // Create new stuck message door.stuckMessage = createGlitchText(this, door.x, door.y - 20, "*(keep) pushing... it's (stuck)*") .setStyle({ fontSize: '10px', color: '#FFD700', backgroundColor: '#000000', padding: { x: 4, y: 2 }, align: 'center' }) .setDepth(1000); // Remove message after 5 seconds this.time.delayedCall(5000, () => { if (door.stuckMessage) { door.stuckMessage.destroy(); door.stuckMessage = null; } }); this.handleSoundWaves.create(2); // Shake effect that preserves position this.tweens.add({ targets: door, x: originalX + 2, y: originalY + 2, duration: 50, yoyo: true, repeat: 2, onComplete: () => { door.setPosition(originalX, originalY); } }); } else { this.stuckDoors.delete(door); this.doorAttempts.delete(door); this.matter.body.setStatic(door.body, false); door.setFillStyle(0x8B4513); this.applyDoorForce(door, 0.003); this.doorsOpened++; } }; handleNormalDoor = (door) => { this.matter.body.setStatic(door.body, !door.body.isStatic); if (!door.body.isStatic) { this.applyDoorForce(door, 0.001); this.doorsOpened++; } }; applyDoorForce = (door, force) => { const angle = Phaser.Math.Angle.Between(this.player.x, this.player.y, door.x, door.y); this.matter.body.applyForce(door.body, door.body.position, { x: Math.cos(angle) * force, y: Math.sin(angle) * force }); }; shakeDoor = door => { const originalX = door.x; const originalY = door.y; this.tweens.add({ targets: door, x: originalX + 2, y: originalY + 2, duration: 50, yoyo: true, repeat: 2, onComplete: () => { door.setPosition(originalX, originalY); } }); }; handleObjectsVisibility() { // If flashlight is off, ensure all objects except player are invisible immediately if (!this.isFlashlightOn) { [...this.walls, ...this.doors, ...this.keys, ...this.dorctos].filter(obj => obj !== this.player).forEach(obj => { if (obj?.active) { this.setObjectAndTextAlpha(obj, 0); this.memoryObjects.delete(obj); } }); return; } const MEMORY_DURATION = 5000; const currentTime = this.time.now; // Process all game objects [...this.walls, ...this.doors, ...this.keys, ...this.dorctos].forEach(obj => { if (!obj?.active) return; const lastSeenTime = this.memoryObjects.get(obj); // If object has never been seen or memory has expired if (!lastSeenTime || (currentTime - lastSeenTime >= MEMORY_DURATION)) { this.setObjectAndTextAlpha(obj, 0); this.memoryObjects.delete(obj); return; } // Calculate fade based on time since last seen const timeSinceLastSeen = currentTime - lastSeenTime; const fadeAlpha = Math.max(0, Math.min(1, 1 - (timeSinceLastSeen / MEMORY_DURATION))); // Only show object if it has some visibility if (fadeAlpha > 0) { this.setObjectAndTextAlpha(obj, fadeAlpha); } else { this.setObjectAndTextAlpha(obj, 0); this.memoryObjects.delete(obj); } }); } setObjectAndTextAlpha = (obj, alpha) => { if (!obj) return; obj.setAlpha(alpha); obj.keyText?.setAlpha(alpha); // Update hinge visibility if it exists if (obj.hinge) { obj.hinge.setAlpha(alpha); } } startFadeOut() { this.fadeOutCount++; // Increment fade out counter // Create fade out effect layers const fadeGraphics = this.add.graphics() .setScrollFactor(0) .setDepth(1001); // Add more intense camera shake effect this.cameras.main.shake(this.fadeDuration * 0.5, 0.025, true); // Create red pulsing overlay const redOverlay = this.add.graphics() .setScrollFactor(0) .setDepth(1002); let lastGlitchTime = 0; const glitchInterval = 40; // Glitch more frequently for shorter duration // Fade out with dramatic effects // Create jump scare flash effect const jumpscareFlash = this.add.graphics() .setScrollFactor(0) .setDepth(1003); // Initial flash this.tweens.add({ targets: jumpscareFlash, alpha: { from: 0, to: 1 }, duration: 50, yoyo: true, repeat: 2, onUpdate: (tween) => { jumpscareFlash.clear() .fillStyle(0xffffff, tween.getValue()) .fillRect(0, 0, this.game.config.width, this.game.config.height); }, onComplete: () => jumpscareFlash.destroy() }); // Main fade out this.tweens.add({ targets: [fadeGraphics, this.player], alpha: { from: 0, to: 1 }, duration: this.fadeDuration, onUpdate: (tween) => { const progress = tween.progress; const alpha = tween.getValue(); // Basic fade to black fadeGraphics .clear() .fillStyle(0x000000, alpha) .fillRect(0, 0, this.game.config.width, this.game.config.height); // Add red pulsing effect const pulseIntensity = Math.sin(progress * Math.PI * 8) * 0.5 + 0.5; redOverlay .clear() .fillStyle(0xff0000, pulseIntensity * 0.3 * (1 - progress)) .fillRect(0, 0, this.game.config.width, this.game.config.height); // Add glitch effect const now = this.time.now; if (now - lastGlitchTime > glitchInterval) { lastGlitchTime = now; if (Math.random() < 0.5) { const glitchHeight = Math.random() * 20; const glitchY = Math.random() * this.game.config.height; redOverlay .fillStyle(0xffffff, 0.1) .fillRect(0, glitchY, this.game.config.width, glitchHeight); } } // Increase camera shake intensity as fade progresses if (progress > 0.5) { const shakeIntensity = 0.01 + (progress - 0.5) * 0.02; this.cameras.main.shake(100, shakeIntensity, true); } }, onComplete: () => { // Player reset position and basic state reset this.player.setPosition(this.startX, this.startY); this.matter.setVelocity(this.player, 0, 0); this.totalFlashlightTime = 0; this.batteryLevel = 100; this.fadeOutActive = false; this.player.setAlpha(1); this.isFlashlightOn = false; this.startZoomTime = null; // Reset zoom tracking this.cameras.main.setZoom(this.zoomLevel); // Reset zoom level // Show initial message again if (this.flashlightMessage) { this.flashlightMessage.destroy(); } this.flashlightMessage = createGlitchText(this, 400, 300, '*(Head throbbing)...(Darkness)...I need to turn (ON) my (F)lashlight...*') .setStyle({ fontSize: '18px', color: '#ffffff', backgroundColor: '#000000', padding: { x: 10, y: 5 }, align: 'center', fontStyle: 'italic', fixedWidth: 400, wordWrap: { width: 390 } }) .setScrollFactor(0) .setDepth(1000) .setAlpha(1); // No door state restoration needed as we're preserving states // The doors will remain in their current opened/closed states // Fade back in this.tweens.add({ targets: [fadeGraphics, redOverlay, this.player], alpha: { from: 1, to: 0 }, duration: this.fadeDuration, ease: 'Quad.easeIn', onUpdate: (tween) => { const alpha = tween.getValue(); fadeGraphics .clear() .fillStyle(0x000000, alpha) .fillRect(0, 0, this.game.config.width, this.game.config.height); }, onComplete: () => { fadeGraphics.destroy(); // Reset music and flashlight state if (this.ambientSound) { this.ambientSound.stop(); } // Reset flashlight control flag this.hasStartedMusic = false; this.isFlashlightOn = false; } }); } }); } startEndSequence() { if (this.isEnding) return; // Prevent multiple triggers this.dialogueStage = 7; // Set dialogue stage to 7 when reaching exit // Disable player movement and exit light this.matter.setVelocity(this.player, 0, 0); this.player.setStatic(true); this.exitLight.clear(); // Clear exit light this.exitLight.setActive(false); // Deactivate exit light // Create end message in R1's style const endMessage = createGlitchText( this, 400, 300, "*(trying) to leave? How... (amusing). You're not (allowed) here, until..." ).setStyle({ fontSize: '18px', color: '#ffffff', backgroundColor: '#000000', padding: { x: 10, y: 5 }, align: 'center', fontStyle: 'italic', fixedWidth: 400, wordWrap: { width: 390 } }) .setScrollFactor(0) .setDepth(1000) .setAlpha(1); // After 3 seconds, show the date this.time.delayedCall(15000, () => { endMessage.destroy(); const dateMessage = createGlitchText( this, 400, 300, "(2)/(14)/(2025)" ).setStyle({ fontSize: '36px', color: '#ff0000', backgroundColor: '#000000', fontStyle: 'bold', padding: { x: 10, y: 5 }, align: 'center', fixedWidth: 400 }) .setScrollFactor(0) .setDepth(1000) .setAlpha(1); // After 5 seconds, reset the game this.time.delayedCall(10000, () => { dateMessage.destroy(); this.isEnding = false; this.player.setStatic(false); this.exitLight.setActive(true); // Reactivate exit light after reset // Reset music and flashlight states if (this.ambientSound) { this.ambientSound.stop(); } this.hasStartedMusic = false; this.isFlashlightOn = false; this.player.setPosition(this.startX, this.startY); this.matter.setVelocity(this.player, 0, 0); this.batteryLevel = 100; this.totalFlashlightTime = 0; this.startZoomTime = null; // Reset zoom time this.cameras.main.setZoom(this.zoomLevel); // Reset zoom level this.fadeOutCount++; // Keep doorsOpened count // Keep dialogueStage this.isFlashlightOn = false; // Keep collected keys (don't reset this.collectedKeys) // Show initial flashlight message if (this.flashlightMessage) { this.flashlightMessage.destroy(); } this.flashlightMessage = createGlitchText( this, 400, 300, '*(Head throbbing)...(Darkness)...I need to turn (ON) my (F)lashlight...*' ).setStyle({ fontSize: '18px', color: '#ffffff', backgroundColor: '#000000', padding: { x: 10, y: 5 }, align: 'center', fontStyle: 'italic', fixedWidth: 400, wordWrap: { width: 390 } }) .setScrollFactor(0) .setDepth(1000) .setAlpha(1); }); }); } updateExitLight() { if (!this.exitLight || !this.exitPosition || !this.exitLight.active || this.isEnding) return; // Check if player is close enough to see the exit effects const distanceToExit = Phaser.Math.Distance.Between( this.player.x, this.player.y, this.exitPosition.x, this.exitPosition.y ); // Only show exit effects within a certain range const maxVisibilityRange = 150; // Adjust this value as needed if (distanceToExit > maxVisibilityRange) { this.exitLight.clear(); return; } const time = this.time.now; this.exitLight .clear() .setDepth(1000); // Increased depth to render above other elements // Calculate intensity based on distance and time const distanceFactor = 1 - (distanceToExit / maxVisibilityRange); const baseIntensity = 0.5 + Math.sin(time / 500) * 0.3; const pulseIntensity = baseIntensity * distanceFactor; // Calculate base angle (pointing inward from exit) const baseAngle = Math.PI; // Point light inward // Create pulsing effect const staticEffect = 0.85 + Math.sin(time / 80) * 0.4 + Math.cos(time / 120) * 0.3; // Draw light rays for (let i = 0; i < this.exitRayCount; i++) { const rayAngle = baseAngle - (this.exitLightAngle / 2) + (this.exitLightAngle * i / (this.exitRayCount - 1)) + (Math.random() - 0.5) * 0.1; // Add slight random variation const endX = this.exitPosition.x + Math.cos(rayAngle) * this.exitRayLength; const endY = this.exitPosition.y + Math.sin(rayAngle) * this.exitRayLength; // Find closest intersection with walls let nearestIntersection = null; let minDist = this.exitRayLength; for (let wall of this.walls) { if (!wall.active) continue; const vertices = wall.body.vertices; for (let j = 0; j < vertices.length; j++) { const intersection = this.lineIntersection( this.exitPosition.x, this.exitPosition.y, endX, endY, vertices[j].x, vertices[j].y, vertices[(j + 1) % vertices.length].x, vertices[(j + 1) % vertices.length].y ); if (intersection) { const dist = Phaser.Math.Distance.Between( this.exitPosition.x, this.exitPosition.y, intersection.x, intersection.y ); if (dist < minDist) { minDist = dist; nearestIntersection = intersection; } } } } const rayEndX = nearestIntersection ? nearestIntersection.x : endX; const rayEndY = nearestIntersection ? nearestIntersection.y : endY; // Draw ray with static effect // Draw outer glow // Draw outer glow with wider stroke and lower alpha this.exitLight .lineStyle(12, 0xff0000, 0.08 * pulseIntensity * staticEffect) .beginPath() .moveTo(this.exitPosition.x, this.exitPosition.y) .lineTo(rayEndX, rayEndY) .strokePath(); // Draw medium layer this.exitLight .lineStyle(6, 0xff0000, 0.15 * pulseIntensity * staticEffect) .beginPath() .moveTo(this.exitPosition.x, this.exitPosition.y) .lineTo(rayEndX, rayEndY) .strokePath(); // Draw inner bright core this.exitLight .lineStyle(2, 0xff0000, 0.4 * pulseIntensity * staticEffect) .beginPath() .moveTo(this.exitPosition.x, this.exitPosition.y) .lineTo(rayEndX, rayEndY) .strokePath(); } } } window.phaserGame = new Phaser.Game({ type: Phaser.AUTO, parent: 'renderDiv', width: 800, height: 600, scene: [MenuScene, GameScene], fps: { target: 60, forceSetTimeOut: true }, scale: { mode: Phaser.Scale.FIT, autoCenter: Phaser.Scale.CENTER_BOTH, zoom: 0.5 // Render at half resolution }, render: { pixelArt: true, antialias: false, roundPixels: true }, physics: { default: 'matter', matter: { gravity: { x: 0, y: 0 }, debug: false } } });