class TitleScreen extends Phaser.Scene { static devOptions = { speedBoost: false, invincible: false, startNearEnd: false, instantLoss: false }; constructor() { super('TitleScreen'); PlatformerLevel.runningTotal = 0; // Reset running total when title screen is created } preload() { // Create monkey sprite using code const monkeyGraphics = this.add.graphics(); // Body (brown oval) monkeyGraphics.fillStyle(0x8B4513); monkeyGraphics.fillEllipse(32, 24, 20, 16); // Head (brown circle) monkeyGraphics.fillStyle(0x8B4513); monkeyGraphics.fillCircle(32, 12, 12); // Face (lighter brown circle) monkeyGraphics.fillStyle(0xFFB6C1); monkeyGraphics.fillCircle(32, 12, 9); // Smile (curved line) monkeyGraphics.lineStyle(2, 0x000000); monkeyGraphics.beginPath(); monkeyGraphics.arc(32, 12, 6, 0.2, 2.9, false); monkeyGraphics.strokePath(); // Eyes (black circles with white highlights) monkeyGraphics.fillStyle(0x000000); monkeyGraphics.fillCircle(28, 10, 2.5); monkeyGraphics.fillCircle(36, 10, 2.5); monkeyGraphics.fillStyle(0xFFFFFF); monkeyGraphics.fillCircle(28.5, 9.5, 1); monkeyGraphics.fillCircle(36.5, 9.5, 1); // Tail (curved monkey tail) monkeyGraphics.lineStyle(5, 0x8B4513); monkeyGraphics.beginPath(); monkeyGraphics.moveTo(24, 24); monkeyGraphics.lineTo(18, 22); monkeyGraphics.lineTo(14, 18); monkeyGraphics.lineTo(12, 12); monkeyGraphics.lineTo(14, 6); monkeyGraphics.lineTo(18, 2); monkeyGraphics.lineTo(22, 0); monkeyGraphics.strokePath(); // Generate texture monkeyGraphics.generateTexture('monkeySprite', 64, 36); monkeyGraphics.destroy(); } create() { // Add dancing monkeys this.dancingMonkeys = []; // Create player monkey on the far left const playerMonkey = this.add.sprite(100, 500, 'monkeySprite'); this.dancingMonkeys.push(playerMonkey); // Create 3 enemy monkeys symmetrically positioned const enemyTypes = ['red', 'magenta', 'cyan', 'pink', 'green', 'yellow']; const positions = [{ x: 200, y: 500 }, // Near left { x: 600, y: 500 }, { x: 700, y: 500 } // Far right pair ]; // Create 3 enemy monkeys for (let i = 0; i < 3; i++) { const enemy = this.add.sprite(positions[i].x, positions[i].y, 'monkeySprite'); const randomType = Phaser.Math.RND.pick(enemyTypes); switch (randomType) { case 'red': enemy.setTint(0xFF0000); break; // Basic enemy case 'magenta': enemy.setTint(0xFF00FF); break; // Jumping enemy case 'cyan': enemy.setTint(0x00FFFF); break; // Shooting enemy case 'pink': enemy.setTint(0xFF69B4); break; // Floating enemy case 'green': enemy.setTint(0x00FF00); break; // Dancing enemy case 'yellow': enemy.setTint(0xFFFF00); break; // Throwing enemy } this.dancingMonkeys.push(enemy); } // Add dance animation to all monkeys this.dancingMonkeys.forEach((monkey, index) => { // Set initial scale and rotation monkey.setScale(1.5); // Add bouncing animation this.tweens.add({ targets: monkey, y: monkey.y - 30, duration: 500, yoyo: true, repeat: -1, ease: 'Sine.easeInOut', delay: index * 167 // Offset each monkey's animation }); // Add rotation animation this.tweens.add({ targets: monkey, angle: { from: -15, to: 15 }, duration: 1000, yoyo: true, repeat: -1, ease: 'Sine.easeInOut', delay: index * 167 // Offset each monkey's animation }); }); // Create large monkey face graphic const faceGraphics = this.add.graphics(); // Head (brown circle) - larger size faceGraphics.fillStyle(0x8B4513); faceGraphics.fillCircle(400, 60, 48); // Face (lighter brown circle) - larger size faceGraphics.fillStyle(0xFFB6C1); faceGraphics.fillCircle(400, 60, 36); // Smile (curved line) - larger size faceGraphics.lineStyle(8, 0x000000); faceGraphics.beginPath(); faceGraphics.arc(400, 60, 24, 0.2, 2.9, false); faceGraphics.strokePath(); // Eyes (black circles with white highlights) - larger size faceGraphics.fillStyle(0x000000); faceGraphics.fillCircle(384, 52, 10); faceGraphics.fillCircle(416, 52, 10); faceGraphics.fillStyle(0xFFFFFF); faceGraphics.fillCircle(386, 50, 4); faceGraphics.fillCircle(418, 50, 4); // Set solid black background this.cameras.main.setBackgroundColor('#000066'); // Slightly darker blue background // Create input element for difficulty const inputElement = document.createElement('input'); inputElement.type = 'text'; inputElement.value = '17'; inputElement.style.width = '80px'; inputElement.style.textAlign = 'center'; inputElement.style.fontSize = '24px'; inputElement.style.padding = '5px'; inputElement.maxLength = 3; // Add the input element to the game's parent const gameContainer = this.game.canvas.parentElement; const inputContainer = document.createElement('div'); inputContainer.style.position = 'absolute'; inputContainer.style.left = '50%'; inputContainer.style.top = '275px'; inputContainer.style.transform = 'translate(-50%, 0)'; inputContainer.style.zIndex = '1'; const labelText = document.createElement('span'); labelText.textContent = 'Starting Difficulty: '; labelText.style.color = 'white'; labelText.style.fontFamily = 'Arial'; labelText.style.fontSize = '24px'; const enemiesText = document.createElement('span'); enemiesText.textContent = ' enemies'; enemiesText.style.color = 'white'; enemiesText.style.fontFamily = 'Arial'; enemiesText.style.fontSize = '16px'; // Add container for round length input const roundLengthContainer = document.createElement('div'); roundLengthContainer.style.marginTop = '20px'; const roundLengthLabel = document.createElement('span'); roundLengthLabel.textContent = 'Round Length: '; roundLengthLabel.style.color = 'white'; roundLengthLabel.style.fontFamily = 'Arial'; roundLengthLabel.style.fontSize = '24px'; const roundLengthInput = document.createElement('input'); roundLengthInput.type = 'text'; roundLengthInput.value = '5'; roundLengthInput.style.width = '80px'; roundLengthInput.style.textAlign = 'center'; roundLengthInput.style.fontSize = '24px'; roundLengthInput.style.padding = '5px'; roundLengthInput.maxLength = 2; const levelsText = document.createElement('span'); levelsText.textContent = ' levels'; levelsText.style.color = 'white'; levelsText.style.fontFamily = 'Arial'; levelsText.style.fontSize = '16px'; roundLengthContainer.appendChild(roundLengthLabel); roundLengthContainer.appendChild(roundLengthInput); roundLengthContainer.appendChild(levelsText); inputContainer.appendChild(labelText); inputContainer.appendChild(inputElement); inputContainer.appendChild(enemiesText); inputContainer.appendChild(roundLengthContainer); gameContainer.appendChild(inputContainer); // Add input validation inputElement.addEventListener('input', (e) => { let value = e.target.value.replace(/[^0-9]/g, ''); // Remove non-numbers if (value.length > 0) { if (value === '0') { value = '1'; } else { value = value.replace(/^0+/, ''); // Remove leading zeros if (value === '') value = '17'; // If all zeros, set to 17 } } if (value.length > 3) value = value.slice(0, 3); // Limit to 3 digits e.target.value = value; // Don't force '28' while typing }); // Add click event listener to document document.addEventListener('click', (e) => { // Check if click is outside the input element if (!inputElement.contains(e.target) && document.activeElement !== inputElement) { if (!inputElement.value) { inputElement.value = '17'; } } }); // Add blur event listener to handle when input loses focus inputElement.addEventListener('blur', (e) => { if (!e.target.value) { e.target.value = '17'; } }); // Add input validation for round length roundLengthInput.addEventListener('input', (e) => { let value = e.target.value.replace(/[^0-9]/g, ''); // Remove non-numbers if (value.length > 0) { if (value === '0') { value = '1'; } else { value = value.replace(/^0+/, ''); // Remove leading zeros if (value === '') value = '5'; // If all zeros, set to 5 } } if (value.length > 2) value = value.slice(0, 2); // Limit to 2 digits e.target.value = value; }); // Add blur event listener for round length roundLengthInput.addEventListener('blur', (e) => { if (!e.target.value) { e.target.value = '5'; } }); // Add click event listener to handle round length input document.addEventListener('click', (e) => { if (!roundLengthInput.contains(e.target) && document.activeElement !== roundLengthInput) { if (!roundLengthInput.value) { roundLengthInput.value = '5'; } } }); // Store input element reference for cleanup this.difficultyInput = inputContainer; // No debug options // Title text with shadow const title = this.add.text(400, 180, 'Mini Monkey Buddies', { fontSize: '64px', fill: '#fff', fontStyle: 'bold' }).setOrigin(0.5); // Add shadow to title title.setShadow(3, 3, '#000000', 5, true, true); // Animated start button const startButton = this.add.rectangle(400, 500, 200, 60, 0x4682B4).setOrigin(0.5); // Add scoring explanation below start button this.add.text(400, 570, 'Your final score will be the sum of all successfully beaten levels/difficulty numbers in the round.', { fontSize: '16px', fill: '#fff', align: 'center', wordWrap: { width: 780 } }).setOrigin(0.5); const buttonText = this.add.text(400, 500, 'Start Game', { fontSize: '32px', fill: '#fff' }).setOrigin(0.5); // Make button interactive startButton.setInteractive(); // Button hover effects startButton.on('pointerover', () => { startButton.setFillStyle(0x6CA6CD); buttonText.setScale(1.1); }); startButton.on('pointerout', () => { startButton.setFillStyle(0x4682B4); buttonText.setScale(1); }); // No dev options configuration // Start game on click startButton.on('pointerdown', () => { const inputValue = this.difficultyInput.querySelector('input').value; const difficulty = inputValue ? parseInt(inputValue) : 17; this.cameras.main.fade(500, 0, 0, 0); // Clean up input elements this.difficultyInput.remove(); const roundLength = parseInt(roundLengthInput.value) || 5; this.scene.start('PlatformerLevel', { totalEnemies: difficulty, currentRound: 1, totalRounds: roundLength }); }); // Button pulse animation this.tweens.add({ targets: [startButton, buttonText], scaleX: 1.05, scaleY: 1.05, duration: 1000, yoyo: true, repeat: -1, ease: 'Sine.easeInOut' }); } } class PlatformerLevel extends Phaser.Scene { static runningTotal = 0; // Add static property to track running total constructor() { super('PlatformerLevel'); this.platforms = null; this.player = null; this.throwingMonkeyEnemies = null; this.throwingMonkeyBombs = null; this.purpleBlocks = null; // New group for purple blocks this.playerLocked = false; this.bossMonkey = null; this.bossMonkeyGroup = null; this.bossCurrentMove = null; this.bossMoveCooldown = false; this.bossBaseScale = 3.5; this.bodyOffsetX = 32; this.bodyOffsetX = 32; // Define bodyOffsetX as a class property this.enemyMultiplier = 1; this.totalEnemies = 17; // Starting number of enemies this.minEnemies = 1; // Minimum number of enemies this.difficultyDisplay = null; this.bestClearDisplay = null; this.bestClearLevel = 0; this.progressPerLife = []; this.currentLifeProgress = 0; this.startX = 100; this.goalX = 14 * 800 + 400; // Assuming the sparkly object is in the middle of the last screen this.cursors = null; this.floatingEnemies = null; this.screenWidth = 800; this.isJumping = false; this.jumpTimer = 0; this.maxJumpTime = 250; // Maximum jump time in milliseconds this.levelWidth = this.screenWidth * 15.5; // Extend level width to include the extra half screen this.safeZoneWidth = 500; this.groundHeight = 32; this.maxPlatformHeight = 100; this.devMode = false; this.playerSpeed = 329; this.playerAcceleration = 1500; this.playerDeceleration = 625; this.minPlatformDifference = 10; this.playerHealth = 219; // Half the original health this.maxPlayerHealth = 219; // Half the original health this.healthBar = null; this.healthBarBg = null; this.lives = 5; this.livesDisplay = null; this.enemies = null; this.jumpingEnemies = null; this.shootingEnemies = null; this.floatingEnemies = null; this.dancingEnemies = null; this.flyingBomberEnemies = null; this.throwingMonkeyEnemies = null; this.projectiles = null; this.gameOver = false; this.sparklyObject = null; this.isHealthLocked = false; this.livesInCurrentSet = 5; } initAudio() { this.audioContext = new(window.AudioContext || window.webkitAudioContext)(); this.masterGain = this.audioContext.createGain(); this.masterGain.connect(this.audioContext.destination); this.masterGain.gain.setValueAtTime(0.2, this.audioContext.currentTime); this.notes = [60, 62, 64, 65, 67, 69, 71, 72]; // C major scale this.createInstruments(); this.startGenerativeMusic(); } createInstruments() { this.piano = { oscillator: this.audioContext.createOscillator(), gain: this.audioContext.createGain() }; this.piano.oscillator.type = 'sine'; this.piano.oscillator.connect(this.piano.gain); this.piano.gain.connect(this.masterGain); this.piano.gain.gain.setValueAtTime(0, this.audioContext.currentTime); this.piano.oscillator.start(); this.bass = { oscillator: this.audioContext.createOscillator(), gain: this.audioContext.createGain() }; this.bass.oscillator.type = 'triangle'; this.bass.oscillator.connect(this.bass.gain); this.bass.gain.connect(this.masterGain); this.bass.gain.gain.setValueAtTime(0, this.audioContext.currentTime); this.bass.oscillator.start(); this.flute = { oscillator: this.audioContext.createOscillator(), gain: this.audioContext.createGain(), modulator: this.audioContext.createOscillator(), modulatorGain: this.audioContext.createGain() }; this.flute.oscillator.type = 'sine'; this.flute.modulator.type = 'sine'; this.flute.modulator.frequency.setValueAtTime(5, this.audioContext.currentTime); this.flute.modulatorGain.gain.setValueAtTime(10, this.audioContext.currentTime); this.flute.modulator.connect(this.flute.modulatorGain); this.flute.modulatorGain.connect(this.flute.oscillator.frequency); this.flute.oscillator.connect(this.flute.gain); this.flute.gain.connect(this.masterGain); this.flute.gain.gain.setValueAtTime(0, this.audioContext.currentTime); this.flute.oscillator.start(); this.flute.modulator.start(); } startGenerativeMusic() { this.musicLoop = this.time.addEvent({ delay: 2000, callback: this.generateMusicPattern, callbackScope: this, loop: true }); } generateMusicPattern() { const currentTime = this.audioContext.currentTime; // Piano melody for (let i = 0; i < 4; i++) { const note = Phaser.Math.RND.pick(this.notes); const startTime = currentTime + i * 0.5; this.playNote(this.piano, note, startTime, 0.4); } // Bass line const bassNote = this.notes[0] - 12; // One octave lower this.playNote(this.bass, bassNote, currentTime, 1.8); // Occasional flute part if (Phaser.Math.RND.between(0, 100) < 50) { // 50% chance of flute playing const flutePattern = Phaser.Math.RND.pick([ this.playFluteArpeggio, this.playFluteMelody, this.playFluteChords ]); flutePattern.call(this, currentTime); } } playFluteArpeggio(startTime) { const duration = Phaser.Math.RND.between(4, 8); for (let i = 0; i < duration; i++) { const fluteNote = this.notes[i % this.notes.length] + 12; this.playNote(this.flute, fluteNote, startTime + i * 0.25, 0.2, 0.15); } } playFluteMelody(startTime) { const duration = Phaser.Math.RND.between(3, 6); for (let i = 0; i < duration; i++) { const fluteNote = Phaser.Math.RND.pick(this.notes) + 12; this.playNote(this.flute, fluteNote, startTime + i * 0.5, 0.4, 0.15); } } playFluteChords(startTime) { const chordNotes = Phaser.Math.RND.shuffle(this.notes).slice(0, 3); for (let i = 0; i < 3; i++) { this.playNote(this.flute, chordNotes[i] + 12, startTime, 1.5, 0.1); } } playNote(instrument, midiNote, startTime, duration, volume = 0.2) { const freq = this.midiToFreq(midiNote); instrument.oscillator.frequency.setValueAtTime(freq, startTime); instrument.gain.gain.setValueAtTime(0, startTime); if (instrument === this.flute) { // Add some randomness to the flute's attack and release const attackTime = 0.02 + Math.random() * 0.03; const releaseTime = 0.1 + Math.random() * 0.1; instrument.gain.gain.linearRampToValueAtTime(volume, startTime + attackTime); instrument.gain.gain.setTargetAtTime(0, startTime + duration - releaseTime, releaseTime / 3); } else { instrument.gain.gain.linearRampToValueAtTime(volume, startTime + 0.01); instrument.gain.gain.linearRampToValueAtTime(0, startTime + duration); } } midiToFreq(midiNote) { return 440 * Math.pow(2, (midiNote - 69) / 12); } preload() { this.load.image('ground', 'https://labs.phaser.io/assets/sprites/platform.png'); // Create monkey sprite using code // Create a larger canvas for the monkey sprite to accommodate the tail const monkeyGraphics = this.add.graphics(); // Move the body drawing position to allow space for the tail // Body (brown oval) monkeyGraphics.fillStyle(0x8B4513); monkeyGraphics.fillEllipse(this.bodyOffsetX, 24, 20, 16); // Head (brown circle) monkeyGraphics.fillStyle(0x8B4513); monkeyGraphics.fillCircle(this.bodyOffsetX, 12, 12); // Face (lighter brown circle) monkeyGraphics.fillStyle(0xFFB6C1); monkeyGraphics.fillCircle(this.bodyOffsetX, 12, 9); // Smile (curved line) monkeyGraphics.lineStyle(2, 0x000000); monkeyGraphics.beginPath(); monkeyGraphics.arc(this.bodyOffsetX, 12, 6, 0.2, 2.9, false); monkeyGraphics.strokePath(); // Eyes (black circles with white highlights) monkeyGraphics.fillStyle(0x000000); monkeyGraphics.fillCircle(this.bodyOffsetX - 4, 10, 2.5); monkeyGraphics.fillCircle(this.bodyOffsetX + 4, 10, 2.5); monkeyGraphics.fillStyle(0xFFFFFF); monkeyGraphics.fillCircle(this.bodyOffsetX - 3.5, 9.5, 1); monkeyGraphics.fillCircle(this.bodyOffsetX + 4.5, 9.5, 1); // Tail (thinner curved monkey tail) monkeyGraphics.lineStyle(5, 0x8B4513); // Reduced thickness from 8 to 5 monkeyGraphics.beginPath(); monkeyGraphics.moveTo(this.bodyOffsetX - 8, 24); monkeyGraphics.lineTo(this.bodyOffsetX - 14, 22); monkeyGraphics.lineTo(this.bodyOffsetX - 18, 18); monkeyGraphics.lineTo(this.bodyOffsetX - 20, 12); monkeyGraphics.lineTo(this.bodyOffsetX - 18, 6); monkeyGraphics.lineTo(this.bodyOffsetX - 14, 2); monkeyGraphics.lineTo(this.bodyOffsetX - 10, 0); monkeyGraphics.strokePath(); // Add tail highlight (thinner) monkeyGraphics.lineStyle(2, 0x9B6533); // Reduced highlight thickness from 4 to 2 monkeyGraphics.beginPath(); monkeyGraphics.moveTo(this.bodyOffsetX - 8, 24); monkeyGraphics.lineTo(this.bodyOffsetX - 14, 22); monkeyGraphics.lineTo(this.bodyOffsetX - 18, 18); monkeyGraphics.strokePath(); // Arms (repositioned and thicker) monkeyGraphics.fillStyle(0x8B4513); monkeyGraphics.fillRect(this.bodyOffsetX - 12, 16, 5, 8); monkeyGraphics.fillRect(this.bodyOffsetX + 7, 16, 5, 8); // Hands (same color as face, raised position) monkeyGraphics.fillStyle(0xFFB6C1); monkeyGraphics.fillCircle(this.bodyOffsetX - 10, 22, 4); monkeyGraphics.fillCircle(this.bodyOffsetX + 10, 22, 4); // Feet (same color as face) monkeyGraphics.fillStyle(0xFFB6C1); monkeyGraphics.fillRect(this.bodyOffsetX - 8, 31, 6, 4); monkeyGraphics.fillRect(this.bodyOffsetX + 2, 31, 6, 4); // Generate texture from graphics (with larger width to accommodate tail) monkeyGraphics.generateTexture('player', 64, 36); // Further reduced height from 40 to 36 monkeyGraphics.destroy(); this.load.image('sparkle', 'https://labs.phaser.io/assets/particles/blue.png'); } create(data) { // Set initial difficulty and invincibility from title screen if (data) { if (data.totalEnemies) { this.totalEnemies = data.totalEnemies; } if (data.invincible) { this.isHealthLocked = true; this.playerHealth = this.maxPlayerHealth; } } // Add space bar handler for instant loss this.input.keyboard.on('keydown-SPACE', () => { if (TitleScreen.devOptions?.instantLoss && !this.gameOver && !this.isHealthLocked) { this.playerHealth = 0; this.updateHealthBar(); this.handlePlayerDeath(); } }); // Ensure player is not locked at level start this.playerLocked = false; // Initialize audio this.initAudio(); // Add a silent sound trigger to immediately resume the audio context const silentSound = this.audioContext.createBufferSource(); silentSound.buffer = this.audioContext.createBuffer(1, 1, 22050); silentSound.connect(this.audioContext.destination); silentSound.start(0); // Ensure audio context is resumed on user interaction if (this.audioContext.state === 'suspended') { const resumeAudio = () => { this.audioContext.resume(); document.removeEventListener('click', resumeAudio); document.removeEventListener('keydown', resumeAudio); }; document.addEventListener('click', resumeAudio); document.addEventListener('keydown', resumeAudio); } // Reset game state this.gameOver = false; this.playerHealth = 219; // Half the original health this.lives = 5; this.livesInCurrentSet = 5; this.isHealthLocked = false; this.progressPerLife = []; // Initialize empty progress array for the new set this.currentLifeProgress = 0; // Reset progress for the new level // Reset totalEnemies to default if not specified if (data && data.totalEnemies) { this.totalEnemies = Math.max(this.minEnemies, Math.round(data.totalEnemies)); } else { this.totalEnemies = 17; // Always reset to default at the start of a new game } this.updateDifficultyDisplay(); this.add.rectangle(0, 0, this.levelWidth, 600, 0x6CA6CD).setOrigin(0, 0); this.platforms = this.physics.add.staticGroup(); this.enemies = this.physics.add.group(); this.throwingMonkeyEnemies = this.physics.add.group(); this.throwingMonkeyBombs = this.physics.add.group(); // Initialize purple blocks with specific physics properties this.purpleBlocks = this.physics.add.group({ allowGravity: true, collideWorldBounds: false, bounceX: 0, bounceY: 0 }); // Configure default properties for all purple blocks this.physics.world.on('worldbounds', (body) => { const gameObject = body.gameObject; if (this.purpleBlocks.contains(gameObject) && gameObject.y > this.cameras.main.height) { gameObject.destroy(); } }); this.jumpingEnemies = this.physics.add.group(); this.shootingEnemies = this.physics.add.group(); this.floatingEnemies = this.physics.add.group(); this.dancingEnemies = this.physics.add.group(); this.flyingBomberEnemies = this.physics.add.group(); this.scalingMonkeyEnemies = this.physics.add.group(); this.projectiles = this.physics.add.group(); this.generateLevel(); this.player = this.physics.add.sprite(100, 450, 'player').setOrigin(0.5, 1); // Set physics body to only include the main body, not the tail this.player.body.setSize(24, 34); this.player.body.setOffset(20, 0); // Align with the main body, ignoring tail area // Apply modifications based on checkbox selections after player is created if (data) { this.devMode = data.devMode || false; if (data.speedBoost) { this.playerSpeed = 329 * 3; // Triple speed } if (data.invincible) { this.isHealthLocked = true; // Make invincible } if (data.startNearEnd) { this.player.setPosition(12 * this.screenWidth + 100, 450); // Start on third-to-last screen } } this.physics.world.setBounds(0, 0, this.levelWidth, 600, true, true, false, true); this.player.setCollideWorldBounds(true); this.player.body.onWorldBounds = true; this.cameras.main.setBounds(0, 0, this.levelWidth, 600); this.cameras.main.startFollow(this.player, true, 1, 1); this.physics.add.collider(this.player, this.platforms); this.cursors = this.input.keyboard.createCursorKeys(); this.player.setDragX(this.playerDeceleration * 0.8); // Reduced drag for better air control this.createHealthBar(); this.updateHealthBar(); this.updateLives(); this.updateDifficultyDisplay(); // Add collision detection for projectiles with player this.physics.add.overlap(this.player, this.projectiles, this.handlePlayerProjectileCollision, null, this); this.physics.add.collider(this.enemies, this.platforms, this.handleEnemyPlatformCollision, null, this); this.physics.add.collider(this.jumpingEnemies, this.platforms, this.handleJumpingEnemyPlatformCollision, null, this); this.physics.add.collider(this.shootingEnemies, this.platforms); this.physics.add.collider(this.projectiles, this.platforms, this.handleProjectilePlatformCollision, null, this); this.physics.add.overlap(this.player, this.projectiles, this.handlePlayerProjectileCollision, null, this); this.physics.add.overlap(this.player, this.floatingEnemies, this.handlePlayerEnemyCollision, null, this); this.physics.add.collider(this.player, this.throwingMonkeyBombs, (player, bomb) => { if (!player.isInvulnerable) { const angle = Phaser.Math.Angle.Between(player.x, player.y, bomb.x, bomb.y); const pushForce = 200; const playerRecoilForce = pushForce * 0.3; bomb.setVelocity( Math.cos(angle) * pushForce, Math.sin(angle) * pushForce ); player.setVelocity( Math.cos(angle) * -playerRecoilForce, Math.sin(angle) * -playerRecoilForce ); if (!this.devMode) { this.playerHealth -= 15; this.updateHealthBar(); if (this.playerHealth <= 0) { this.handlePlayerDeath(); } } player.isInvulnerable = true; this.time.delayedCall(500, () => { player.isInvulnerable = false; }); } }, null, this); this.physics.add.overlap(this.player, this.throwingMonkeyEnemies, this.handlePlayerEnemyCollision, null, this); this.physics.add.collider(this.dancingEnemies, this.platforms); this.physics.add.overlap(this.player, this.dancingEnemies, this.handlePlayerEnemyCollision, null, this); // Add collision detection for sparkly object this.physics.add.overlap(this.player, this.sparklyObject, this.handleSparklyObjectCollection, null, this); } handleSparklyObjectCollection(player, sparklyObject) { if (sparklyObject && sparklyObject.destroy) sparklyObject.destroy(); this.cameras.main.fade(1000, 255, 255, 255); this.stopMusic(); // Update running total when level is cleared PlatformerLevel.runningTotal += this.totalEnemies; // Calculate new enemy count based on remaining lives const increase = { 5: 13, 4: 10, 3: 8, 2: 5, 1: 3 }; // Get the increase amount based on remaining lives, default to 0 if not found const increment = increase[this.lives] || 0; const nextLevelEnemies = this.totalEnemies + increment; // Update best clear level this.bestClearLevel = Math.max(this.bestClearLevel, this.totalEnemies); this.time.delayedCall(1000, () => { this.scene.start('LevelClearScreen', { remainingLives: this.lives, nextLevelEnemies: nextLevelEnemies, currentLevelEnemies: this.totalEnemies, currentRound: this.scene.settings.data.currentRound, totalRounds: this.scene.settings.data.totalRounds }); }); } clearAllEnemies() { [this.enemies, this.jumpingEnemies, this.shootingEnemies, this.floatingEnemies, this.dancingEnemies, this.flyingBomberEnemies].forEach(group => { if (group && group.clear) { group.clear(true, true); } }); if (this.updateEnemies) { this.updateEnemies = []; } // Clear any ongoing enemy timers or events if (this.time && this.time.removeAllEvents) { this.time.removeAllEvents(); } } updateDifficultyDisplay() { if (this.difficultyDisplay) { this.difficultyDisplay.destroy(); } this.difficultyDisplay = this.add.text(20, 60, `Level: ${this.totalEnemies}`, { fontSize: '24px', fill: '#fff' }).setScrollFactor(0); this.updateBestClearDisplay(); } updateBestClearDisplay() { if (this.bestClearDisplay) { this.bestClearDisplay.destroy(); } const bestClearText = this.bestClearLevel > 0 ? `${this.bestClearLevel}` : '-'; this.bestClearDisplay = this.add.text(20, 90, `Best Clear: ${bestClearText}`, { fontSize: '24px', fill: '#fff' }).setScrollFactor(0); } generateLevel() { // Create ground platforms for all screens including the extra half screen for (let i = 0; i < 16; i++) { this.platforms.create(i * this.screenWidth + this.screenWidth / 2, 600 - this.groundHeight / 2, 'ground').setScale(2, 1).refreshBody(); } // Create boss monkey just before the final screen // Create boss monkey just before the final screen const bossX = 13 * this.screenWidth + (this.screenWidth * 0.75); const bossY = 450; this.bossMonkey = this.createBossMonkey(bossX, bossY); // Add a darker background for the final screen, moved half a screen further this.add.rectangle(14.5 * this.screenWidth, 0, this.screenWidth, 600, 0x000000, 0.5).setOrigin(0, 0); // Define boss safe zone const bossSafeZoneStart = 13 * this.screenWidth; const bossSafeZoneEnd = 14 * this.screenWidth; for (let i = 0; i < 14; i++) { // Skip platform generation in boss safe zone if (i === 13) continue; // Skip the screen where the boss is let screenStartX = i * this.screenWidth; let platformCount = Phaser.Math.Between(3, 5); let existingPlatforms = []; for (let j = 0; j < platformCount; j++) { let x, y, width, height; let isOverlapping; do { isOverlapping = false; x = screenStartX + Phaser.Math.Between(100, this.screenWidth - 100); height = Phaser.Math.Between(32, this.maxPlatformHeight); y = 600 - this.groundHeight - height / 2; width = Phaser.Math.Between(50, 150); for (let existingPlatform of existingPlatforms) { if (Math.abs(x - existingPlatform.x) < Math.max(width, existingPlatform.width) / 2) { if (Math.abs(y - existingPlatform.y) < Math.max(height, existingPlatform.height) / 2) { if (Math.abs(width - existingPlatform.width) < this.minPlatformDifference || Math.abs(height - existingPlatform.height) < this.minPlatformDifference) { isOverlapping = true; break; } } } } } while (x < (i === 0 ? this.screenWidth * 0.5 : 0) || isOverlapping); let platform = this.platforms.create(x, y, 'ground').setScale(width / 400, height / 32).refreshBody(); existingPlatforms.push({ x: x, y: y, width: width, height: height }); } // If it's the first screen, ensure at least one platform is in the last half if (i === 0 && existingPlatforms.every(p => p.x < this.screenWidth * 0.5)) { let x, y, width, height; do { x = Phaser.Math.Between(this.screenWidth * 0.5, this.screenWidth - 100); height = Phaser.Math.Between(32, this.maxPlatformHeight); y = 600 - this.groundHeight - height / 2; width = Phaser.Math.Between(50, 150); } while (existingPlatforms.some(p => Math.abs(x - p.x) < Math.max(width, p.width) / 2 && Math.abs(y - p.y) < Math.max(height, p.height) / 2 )); let platform = this.platforms.create(x, y, 'ground').setScale(width / 400, height / 32).refreshBody(); existingPlatforms.push({ x, y, width, height }); } // Enemy spawning logic const enemyFieldStart = this.screenWidth * 0.75; // 75% across the first screen const enemyFieldEnd = this.screenWidth * 13; // 100% across the second-to-last screen const enemyFieldWidth = enemyFieldEnd - enemyFieldStart; // Ensure no enemies spawn in the final screens if (i >= 13) continue; // Skip enemy spawning for the last two screens // Calculate exact positions for all enemies const enemyPositions = []; for (let j = 0; j < this.totalEnemies; j++) { const enemyProgress = (j + 0.5) / this.totalEnemies; const enemyX = enemyFieldStart + enemyProgress * enemyFieldWidth; enemyPositions.push(enemyX); } // Determine which enemies belong to this screen const screenStart = i * this.screenWidth; const screenEnd = (i + 1) * this.screenWidth; const screenEnemies = enemyPositions.filter(x => x >= screenStart && x < screenEnd); let lastEnemyType = -1; // Initialize with an invalid enemy type for (const enemyX of screenEnemies) { let enemyType; do { enemyType = Phaser.Math.Between(0, 6); } while (enemyType === lastEnemyType); lastEnemyType = enemyType; // Find the highest platform at this X position let highestPlatform = 600 - this.groundHeight; this.platforms.getChildren().forEach(platform => { if (Math.abs(platform.x - enemyX) < platform.width / 2) { const platformTop = platform.y - (platform.height * platform.scaleY) / 2; highestPlatform = Math.min(highestPlatform, platformTop); } }); // Set enemy Y position based on type and platform height let enemyY = highestPlatform - 34; // Account for enemy height if (enemyType === 4) enemyY = 0; // Dancing enemy starts at the top switch (enemyType) { case 0: this.createEnemy(enemyX, enemyY); break; case 1: this.createJumpingEnemy(enemyX, enemyY); break; case 2: this.createShootingEnemy(enemyX, enemyY); break; case 3: this.createDancingEnemy(enemyX, enemyY); break; case 4: this.createFlyingBomberEnemy(enemyX, 100); break; case 5: this.createThrowingMonkeyEnemy(enemyX, enemyY); break; case 6: this.createFloatingEnemy(enemyX, enemyY); break; } } } // Add sparkly object on the last screen const lastScreenX = 14.5 * this.screenWidth; const sparklyObjectX = lastScreenX + this.screenWidth / 2; const sparklyObjectY = 400; this.createSparklyObject(sparklyObjectX, sparklyObjectY); // Ensure world bounds include the full level width including the extra half screen this.physics.world.setBounds(0, 0, this.levelWidth, 600); } createEnemy(enemyX, enemyY) { const enemy = this.physics.add.sprite(enemyX, enemyY, 'player'); enemy.setTint(0xFF0000); // Tint the enemy red enemy.body.setSize(24, 34); enemy.body.setOffset(20, 0); enemy.spawnX = enemyX; enemy.spawnY = enemyY; this.enemies.add(enemy); enemy.body.setCollideWorldBounds(true); enemy.body.onWorldBounds = true; enemy.isActive = false; enemy.body.enable = false; enemy.updateMovement = () => { if (enemy.isActive) { enemy.setVelocityX(Phaser.Math.Between(-200, 200)); } }; enemy.activate = () => { enemy.body.enable = true; enemy.updateMovement(); }; enemy.deactivate = () => { enemy.body.enable = false; enemy.setVelocity(0, 0); if (enemy.currentFlash && enemy.currentFlash.destroy) { enemy.currentFlash.destroy(); enemy.currentFlash = null; } enemy.isFlashing = false; enemy.lastFlashTime = 0; }; this.time.addEvent({ delay: 1500, callback: enemy.updateMovement, loop: true }); } createJumpingEnemy(enemyX, enemyY) { const enemy = this.physics.add.sprite(enemyX, enemyY, 'player'); enemy.setTint(0xFF00FF); // Tint the jumping enemy magenta enemy.spawnX = enemyX; enemy.spawnY = enemyY; this.jumpingEnemies.add(enemy); enemy.body.setSize(24, 34); enemy.body.setOffset(20, 0); enemy.setVelocityX(150); enemy.body.setCollideWorldBounds(true); enemy.body.onWorldBounds = true; enemy.jumpTimer = 0; enemy.jumpDelay = 2000; // Time between jumps enemy.updateMovement = () => { if (enemy.active && this.isEnemyActive(enemy)) { // Update jump timer enemy.jumpTimer += 16; // Assuming 60 FPS (1000/60 ≈ 16) if (enemy.body.touching.down && enemy.jumpTimer >= enemy.jumpDelay) { enemy.jumpTimer = 0; enemy.setVelocityY(-700); // Set horizontal movement direction when jumping const direction = enemy.body.velocity.x > 0 ? 1 : -1; enemy.setVelocityX(150 * direction); } // Change direction when hitting world bounds if (enemy.body.touching.right) { enemy.setVelocityX(-150); } else if (enemy.body.touching.left) { enemy.setVelocityX(150); } } else if (!this.isEnemyActive(enemy)) { enemy.setVelocity(0, 0); enemy.jumpTimer = enemy.jumpDelay; // Reset jump timer when inactive } }; this.time.addEvent({ delay: 16, // Update every frame for smoother movement callback: enemy.updateMovement, loop: true }); } handleEnemyPlatformCollision(enemy, platform) { if (enemy.body.touching.right || enemy.body.blocked.right) { enemy.setVelocityX(-100); } else if (enemy.body.touching.left || enemy.body.blocked.left) { enemy.setVelocityX(100); } } handleJumpingEnemyPlatformCollision(enemy, platform) { if (enemy.body.touching.right || enemy.body.blocked.right) { enemy.setVelocityX(-150); } else if (enemy.body.touching.left || enemy.body.blocked.left) { enemy.setVelocityX(150); } } handlePlayerEnemyCollision(player, enemy) { if (this.gameOver) return; // Calculate angle once for all knockback effects const angle = Phaser.Math.Angle.Between(enemy.x, enemy.y, player.x, player.y); // Apply knockback to player regardless of DEV MODE // Apply knockback to player const playerKnockbackForce = 200; player.setVelocity( Math.cos(angle) * playerKnockbackForce, Math.sin(angle) * playerKnockbackForce ); // Only apply damage if NOT in DEV MODE and NOT invincible if (!this.devMode && !this.isHealthLocked) { let damage = 15; // Set specific damage for floating enemies and boss if (this.floatingEnemies.contains(enemy)) { damage = 7; // Fixed damage value for floating enemies } else if (this.bossMonkeyGroup.contains(enemy)) { damage = 80; // Doubled damage for boss collision (40 * 2) } this.playerHealth -= damage; this.updateHealthBar(); if (this.playerHealth <= 0) { this.handlePlayerDeath(); } } // For shooting enemies, stop their movement after a short delay if (this.shootingEnemies.contains(enemy)) { this.time.delayedCall(100, () => { enemy.setVelocity(0, 0); }); } // Prevent rapid collisions player.isInvulnerable = true; this.time.delayedCall(500, () => { player.isInvulnerable = false; }); if (this.playerHealth <= 0) { this.lives--; this.updateLives(); // Record progress for the life that just ended this.progressPerLife.push(this.currentLifeProgress); if (this.lives > 0) { this.playerHealth = this.maxPlayerHealth; this.updateHealthBar(); this.resetPlayerAndEnemies(); this.currentLifeProgress = 0; // Reset progress for new life } else { this.gameOver = true; this.player.setTint(0xff0000); this.player.setVelocity(0, 0); this.stopMusic(); this.calculateAverageProgressAndAdjustDifficulty(); } } } createHealthBar() { // Create lives display this.livesText = this.add.text(10, 10, `Lives: ${this.lives}`, { fontSize: '16px', fill: '#fff' }).setScrollFactor(0); // Progress display this.progressDisplay = this.add.text(10, 30, 'Progress: 0%', { fontSize: '16px', fill: '#fff' }).setScrollFactor(0); // Health bar this.healthBarBg = this.add.rectangle(650, 20, 200, 20, 0x000000); this.healthBarBg.setScrollFactor(0); this.healthBar = this.add.rectangle(650, 20, 200, 20, 0x800080); this.healthBar.setScrollFactor(0); } updateDifficultyDisplay() { if (this.difficultyDisplay) { this.difficultyDisplay.destroy(); } this.difficultyDisplay = this.add.text(10, 50, `Difficulty: ${this.totalEnemies}`, { fontSize: '16px', fill: '#fff' }).setScrollFactor(0); this.updateBestClearDisplay(); } updateBestClearDisplay() { if (this.bestClearDisplay) { this.bestClearDisplay.destroy(); } const bestClearText = this.bestClearLevel > 0 ? `${this.bestClearLevel}` : '-'; // Move instruction text up to where best clear was this.add.text(10, 70, 'Arrow keys to move/jump', { fontSize: '14px', fill: '#fff' }).setScrollFactor(0); } updateHealthBar() { // Keep original bar width of 200 pixels while using halved health values if (this.devMode) { this.healthBar.width = 200; // Always show full health in DEV MODE } else { this.healthBar.width = Math.max(0, (this.playerHealth / this.maxPlayerHealth) * 200); } } updateLives() { this.livesText.setText(`Lives: ${Math.max(0, this.lives)}`); } update() { if (this.gameOver || this.isLevelClearing) return; this.updateEnemyActivity(); this.checkFlyingBomberEnemies(); // Check all enemies for bottom of screen [ this.enemies, this.jumpingEnemies, this.shootingEnemies, this.floatingEnemies, this.dancingEnemies, this.throwingMonkeyEnemies ].forEach(group => { if (group) { group.getChildren().forEach(enemy => { if (enemy.y >= this.cameras.main.height - 34) { // Account for enemy height // Respawn at top of screen at same x position enemy.setPosition(enemy.x, 0); enemy.setVelocity(0, 0); // If the enemy has specific reset behavior, call it if (enemy.resetPosition) { enemy.resetPosition(); } } }); } }); // Update projectiles if (this.updateProjectiles) { this.updateProjectiles = this.updateProjectiles.filter(projectile => { if (projectile && projectile.active) { projectile.update(); return true; } return false; }); } // Update boss monkey collision if (this.bossMonkey && !this.player.isInvulnerable) { this.physics.overlap(this.player, this.bossMonkeyGroup, this.handlePlayerEnemyCollision, null, this); } // Check for collisions with scaling monkey enemies if (!this.player.isInvulnerable) {} // Update shooting enemies if (this.updateEnemies) { this.updateEnemies = this.updateEnemies.filter(enemy => enemy && enemy.body); this.updateEnemies.forEach(enemy => { if (enemy && enemy.updateMovement) { enemy.updateMovement(); } }); } // Ensure shooting enemies move regardless of activation state this.shootingEnemies.getChildren().forEach(enemy => { if (enemy && enemy.updateMovement) { enemy.updateMovement(); } }); // Update player progress const newProgress = Math.min(1, (this.player.x - this.startX) / (this.goalX - this.startX)); this.currentLifeProgress = Math.min(1, Math.max(this.currentLifeProgress, newProgress)); // Update progress display const progressPercentage = Math.min(100, Math.floor(this.currentLifeProgress * 100)); this.progressDisplay.setText(`Progress: ${progressPercentage}%`); // Only check for collisions if the player is not invulnerable if (!this.player.isInvulnerable) { this.physics.overlap(this.player, this.enemies, this.handlePlayerEnemyCollision, null, this); this.physics.overlap(this.player, this.jumpingEnemies, this.handlePlayerEnemyCollision, null, this); this.physics.overlap(this.player, this.shootingEnemies, this.handlePlayerEnemyCollision, null, this); this.physics.overlap(this.player, this.floatingEnemies, this.handlePlayerEnemyCollision, null, this); this.physics.overlap(this.player, this.scalingMonkeyEnemies, this.handlePlayerEnemyCollision, null, this); } // Update floating enemies this.floatingEnemies.getChildren().forEach(enemy => enemy.updateMovement()); // Player movement if (!this.playerLocked) { if (this.cursors.left.isDown) { this.player.setAccelerationX(-this.playerAcceleration); } else if (this.cursors.right.isDown) { this.player.setAccelerationX(this.playerAcceleration); } else { this.player.setAccelerationX(0); } this.player.setMaxVelocity(this.playerSpeed, this.player.body.maxVelocity.y); // Jump logic if (this.cursors.up.isDown && this.player.body.touching.down && !this.isJumping) { this.isJumping = true; this.jumpTimer = 0; this.player.setVelocityY(-675); // Initial jump velocity } if (this.isJumping) { if (this.cursors.up.isDown && this.jumpTimer < this.maxJumpTime) { this.jumpTimer += this.game.loop.delta; this.player.setVelocityY(-675); // Maintain jump velocity while button is held } else { this.isJumping = false; } } if (!this.cursors.up.isDown && this.player.body.velocity.y < 0) { this.player.setVelocityY(this.player.body.velocity.y * 0.9); // Reduce upward velocity when button is released } } else { // If player is locked, stop all movement this.player.setVelocity(0, 0); this.player.setAcceleration(0, 0); } if (this.player.body.velocity.y > 0) { this.player.setAccelerationY(1200); // Increased fall acceleration } else { this.player.setAccelerationY(0); } if (this.player.body.touching.down) { this.isJumping = false; // Reset jumping state when player lands } if (this.player.y > 600) { this.player.setPosition(100, 450); this.player.setVelocity(0, 0); } } updateEnemyActivity() { const playerX = this.player.x; const activeRange = this.screenWidth * 1.25; // 1.25 screen widths this.enemies.getChildren() .concat(this.jumpingEnemies.getChildren()) .concat(this.throwingMonkeyEnemies.getChildren()) .concat(this.shootingEnemies.getChildren()) .concat(this.floatingEnemies.getChildren()) .concat(this.dancingEnemies.getChildren()) .concat(this.flyingBomberEnemies.getChildren()) .forEach(enemy => { const wasActive = enemy.isActive; enemy.isActive = Math.abs(enemy.x - playerX) <= activeRange; if (wasActive !== enemy.isActive) { if (enemy.isActive) { this.activateEnemy(enemy); } else { this.deactivateEnemy(enemy); } } }); } activateEnemy(enemy) { enemy.body.enable = true; if (enemy.activate) { enemy.activate(); } } deactivateEnemy(enemy) { enemy.body.enable = false; enemy.setVelocity(0, 0); if (enemy.deactivate) { enemy.deactivate(); } } isEnemyActive(enemy) { return enemy.isActive; } createShootingEnemy(enemyX, enemyY) { const enemy = this.physics.add.sprite(enemyX, enemyY, 'player'); enemy.setTint(0x00FFFF); // Tint the shooting enemy cyan enemy.body.setSize(24, 34); enemy.body.setOffset(20, 0); enemy.spawnX = enemyX; enemy.spawnY = enemyY; this.shootingEnemies.add(enemy); enemy.body.setCollideWorldBounds(true); enemy.body.onWorldBounds = true; enemy.hasLanded = false; enemy.hasMoved = false; enemy.walkDistance = 75; enemy.lastFireTime = 0; enemy.nextFireDelay = () => Phaser.Math.Between(750, 2000); // Random delay between 0.75 and 2 seconds enemy.fireDelay = enemy.nextFireDelay(); // Set initial delay // Create a graphics object for the fireball // Create larger graphics for electric effect const fireballGraphics = this.add.graphics(); // Create outer glow fireballGraphics.fillStyle(0x00FFFF, 0.5); // Cyan outer glow fireballGraphics.fillCircle(10, 10, 10); // Create core fireballGraphics.fillStyle(0x0000FF, 1); // Blue core fireballGraphics.fillCircle(10, 10, 7); fireballGraphics.generateTexture('fireball', 20, 20); fireballGraphics.destroy(); enemy.shootFireball = () => { if (!enemy.active || !this.isEnemyActive(enemy)) return; const currentTime = this.time.now; if (currentTime - enemy.lastFireTime < enemy.fireDelay) return; enemy.lastFireTime = currentTime; enemy.fireDelay = enemy.nextFireDelay(); // Set new random delay for next shot const fireball = this.physics.add.sprite(enemy.x, enemy.y, 'fireball'); fireball.body.setCircle(10); // Add flashing/electric effect this.tweens.add({ targets: fireball, alpha: 0.7, scale: { from: 0.9, to: 1.1 }, duration: 100, yoyo: true, repeat: -1, ease: 'Linear' }); fireball.body.setAllowGravity(false); // Calculate direction to player's current position const angle = Phaser.Math.Angle.Between( enemy.x, enemy.y, this.player.x, this.player.y ); const speed = 300; fireball.setVelocity( Math.cos(angle) * speed, Math.sin(angle) * speed ); // Add collision with player only this.physics.add.overlap(fireball, this.player, (fireball, player) => { if (!player.isInvulnerable) { if (!this.devMode && !this.isHealthLocked) { this.playerHealth -= 40; // Doubled from 20 to 40 this.updateHealthBar(); if (this.playerHealth <= 0) { this.handlePlayerDeath(); } } // Make player briefly invulnerable player.isInvulnerable = true; this.time.delayedCall(500, () => { player.isInvulnerable = false; }); } fireball.destroy(); }); // Destroy fireball after 3 seconds this.time.delayedCall(3000, () => { if (fireball && fireball.active) { fireball.destroy(); } }); }; enemy.updateMovement = () => { if (enemy.body && enemy.body.touching && enemy.body.touching.down && !enemy.hasMoved) { enemy.hasMoved = true; enemy.setVelocityX(75); this.time.delayedCall(800, () => { if (enemy.body) { enemy.setVelocityX(0); // Start shooting once in position this.time.addEvent({ delay: enemy.fireDelay, callback: enemy.shootFireball, loop: true }); } }); } }; enemy.resetPosition = () => { enemy.hasLanded = false; enemy.hasMoved = false; enemy.body.reset(enemy.spawnX, enemy.spawnY); }; // Add this enemy to the scene's update loop this.updateEnemies = this.updateEnemies || []; this.updateEnemies.push(enemy); } createFloatingEnemy(enemyX, enemyY) { const enemy = this.physics.add.sprite(enemyX, this.cameras.main.height * 0.5, 'player'); enemy.setTint(0xFF69B4); // Tint the floating enemy pink enemy.body.setSize(24, 34); enemy.body.setOffset(20, 0); enemy.spawnX = enemyX; enemy.spawnY = this.cameras.main.height * 0.5; this.floatingEnemies.add(enemy); enemy.body.setAllowGravity(false); enemy.body.setCollideWorldBounds(true); enemy.body.onWorldBounds = true; enemy.lungeTimer = 0; enemy.isLunging = false; enemy.updateMovement = () => { if (enemy.active && this.isEnemyActive(enemy) && !enemy.isLunging) { const distanceToPlayer = Phaser.Math.Distance.Between(enemy.x, enemy.y, this.player.x, this.player.y); if (distanceToPlayer < 200 && enemy.lungeTimer <= 0) { enemy.isLunging = true; const angle = Phaser.Math.Angle.Between(enemy.x, enemy.y, this.player.x, this.player.y); const lungeSpeed = 225; // Original speed for smoother movement enemy.setVelocity( Math.cos(angle) * lungeSpeed, Math.sin(angle) * lungeSpeed ); this.time.delayedCall(750, () => { enemy.isLunging = false; enemy.setVelocity(0, 0); enemy.lungeTimer = 2000; }); } else { enemy.lungeTimer = Math.max(0, enemy.lungeTimer - 16); const targetY = this.cameras.main.height * 0.5; const verticalMovement = (targetY - enemy.y) * 0.1; enemy.setVelocity( Math.sin(this.time.now / 1000) * 50, verticalMovement + Math.cos(this.time.now / 1000) * 30 ); } } else if (!this.isEnemyActive(enemy)) { enemy.setVelocity(0, 0); } }; } createDancingEnemy(enemyX, enemyY) { const enemy = this.physics.add.sprite(enemyX, enemyY, 'player'); enemy.setTint(0x00FF00); // Tint the dancing enemy green enemy.body.setSize(24, 34); enemy.body.setOffset(20, 0); enemy.spawnX = enemyX; enemy.spawnY = enemyY; this.dancingEnemies.add(enemy); enemy.body.setCollideWorldBounds(true); enemy.body.onWorldBounds = true; enemy.originalX = enemyX; enemy.flopTimer = 0; enemy.flopDirection = 1; enemy.flop = () => { if (enemy.active && this.isEnemyActive(enemy)) { enemy.flopTimer += 16; // Assuming 60 FPS if (enemy.body.touching.down) { // Flop upwards when touching the ground enemy.setVelocityY(-300); enemy.flopDirection = Phaser.Math.Between(0, 1) ? -1 : 1; } // Horizontal movement enemy.setVelocityX(100 * enemy.flopDirection); // Spinning enemy.angle += 10 * enemy.flopDirection; // Occasional direction change if (Phaser.Math.Between(1, 100) === 1) { enemy.flopDirection *= -1; } } else if (!this.isEnemyActive(enemy)) { enemy.setVelocity(0, 0); enemy.angle = 0; } }; this.time.addEvent({ delay: 16, // Update every frame callback: enemy.flop, loop: true }); } isEnemyOnScreen(enemy) { const camera = this.cameras.main; return enemy.x >= camera.scrollX - enemy.width && enemy.x <= camera.scrollX + camera.width + enemy.width; } handleProjectilePlatformCollision(projectile) { // Don't destroy projectiles on platform collision return; } handlePlayerProjectileCollision(player, projectile) { // Always destroy the projectile projectile.destroy(); // Only apply damage if NOT in DEV MODE and NOT invincible if (!this.devMode && !this.isHealthLocked) { const minDamage = 15; const damage = Math.max(minDamage, 10); this.playerHealth -= damage; this.updateHealthBar(); } // Knock the player back with 1.5x force const knockbackForce = 300; // Increased from 200 to 300 const angle = Phaser.Math.Angle.Between(projectile.x, projectile.y, player.x, player.y); player.setVelocity( Math.cos(angle) * knockbackForce, Math.sin(angle) * knockbackForce ); if (this.playerHealth <= 0 && !this.gameOver) { this.lives--; this.livesInCurrentSet--; this.updateLives(); this.progressPerLife.push(this.currentLifeProgress); if (this.lives > 0) { this.playerHealth = this.maxPlayerHealth; this.updateHealthBar(); this.resetPlayerAndEnemies(); this.currentLifeProgress = 0; // Reset progress for the new life if (this.livesInCurrentSet === 0) { // End of a set of 5 lives this.calculateAverageProgressAndAdjustDifficulty(); this.livesInCurrentSet = 5; this.progressPerLife = []; } } else { this.gameOver = true; this.player.setTint(0xff0000); this.player.setVelocity(0, 0); this.stopMusic(); this.calculateAverageProgressAndAdjustDifficulty(); } } // Delay the projectile destruction this.time.delayedCall(50, () => { projectile.destroy(); }); } createSparklyObject(x, y) { const particles = this.add.particles('sparkle'); const emitter = particles.createEmitter({ x: x, y: y, speed: { min: -100, max: 100 }, scale: { start: 0.5, end: 0 }, blendMode: 'ADD', lifespan: 1000 }); this.sparklyObject = this.physics.add.staticImage(x, y, 'sparkle'); this.sparklyObject.setScale(0.5); this.sparklyObject.setAlpha(0.8); this.tweens.add({ targets: this.sparklyObject, alpha: 1, scale: 0.75, duration: 1000, yoyo: true, repeat: -1 }); return this.sparklyObject; } resetPlayerAndEnemies() { // Teleport player to start this.player.setPosition(100, 450); this.player.setVelocity(0, 0); // Temporarily lock player movement this.playerLocked = true; this.isLevelClearing = false; this.isHealthLocked = false; // Reset progress this.currentLifeProgress = 0; this.progressDisplay.setText('Progress: 0%'); // Reset and activate all enemies [ this.enemies, this.jumpingEnemies, this.shootingEnemies, this.floatingEnemies, this.dancingEnemies, this.flyingBomberEnemies ].forEach(group => { group.getChildren().forEach(enemy => { this.resetEnemy(enemy); enemy.isActive = false; if (enemy.activate) { enemy.activate(); } }); }); // Unlock player after short delay this.time.delayedCall(500, () => { this.playerLocked = false; }); } resetEnemy(enemy) { enemy.setPosition(enemy.spawnX, enemy.spawnY); enemy.setVelocity(0, 0); enemy.body.enable = true; if (enemy.resetPosition) { enemy.resetPosition(); } // Reset specific enemy types if (this.flyingBomberEnemies.contains(enemy)) { enemy.setVelocityX(-50); } else if (this.shootingEnemies.contains(enemy)) { enemy.hasLanded = false; enemy.hasMoved = false; this.time.delayedCall(100, () => { enemy.updateMovement(); }); } else if (this.enemies.contains(enemy)) { enemy.isActive = true; this.time.delayedCall(100, () => { if (enemy.updateMovement) enemy.updateMovement(); }); } } createFlyingBomberEnemy(enemyX, enemyY) { const enemy = this.physics.add.sprite(enemyX, enemyY, 'player'); enemy.setTint(0xA9A9A9); // Lighter gray color (DarkGray) enemy.body.setSize(24, 34); enemy.body.setOffset(20, 0); enemy.spawnX = enemyX; enemy.spawnY = enemyY; this.flyingBomberEnemies.add(enemy); enemy.body.setAllowGravity(false); enemy.body.setCollideWorldBounds(false); enemy.setVelocityX(-50); // Constant left movement enemy.lastFireTime = 0; enemy.fireDelay = 2000; // Fire every 2 seconds // Create larger graphics for projectile const projectileGraphics = this.add.graphics(); // Create outer glow (larger) projectileGraphics.fillStyle(0x00FFFF, 0.5); // Cyan outer glow projectileGraphics.fillCircle(15, 15, 15); // 1.5x larger than original // Create core (larger) projectileGraphics.fillStyle(0x0000FF, 1); // Blue core projectileGraphics.fillCircle(15, 15, 10); // 1.5x larger than original projectileGraphics.generateTexture('flyingBomberProjectile', 30, 30); projectileGraphics.destroy(); enemy.shootProjectile = () => { if (!enemy.active || !this.isEnemyActive(enemy)) return; const currentTime = this.time.now; if (currentTime - enemy.lastFireTime < enemy.fireDelay) return; enemy.lastFireTime = currentTime; const projectile = this.physics.add.sprite(enemy.x, enemy.y, 'flyingBomberProjectile'); projectile.body.setCircle(15); // Add flashing/electric effect this.tweens.add({ targets: projectile, alpha: 0.7, scale: { from: 0.9, to: 1.1 }, duration: 100, yoyo: true, repeat: -1, ease: 'Linear' }); projectile.body.setAllowGravity(false); projectile.setVelocity(0, 300); // Fire straight down // Add collision with player this.physics.add.overlap(projectile, this.player, (projectile, player) => { if (!player.isInvulnerable) { if (!this.devMode && !this.isHealthLocked) { this.playerHealth -= 40; this.updateHealthBar(); if (this.playerHealth <= 0) { this.handlePlayerDeath(); } } // Make player briefly invulnerable player.isInvulnerable = true; this.time.delayedCall(500, () => { player.isInvulnerable = false; }); } projectile.destroy(); }); // Destroy projectile after 3 seconds this.time.delayedCall(3000, () => { if (projectile && projectile.active) { projectile.destroy(); } }); }; enemy.activate = () => { enemy.setVelocityX(-50); // Start shooting when activated this.time.addEvent({ delay: enemy.fireDelay, callback: enemy.shootProjectile, loop: true }); }; enemy.deactivate = () => { enemy.setVelocityX(0); }; } handlePlayerBombCollision(player, bomb) { // Always destroy the bomb bomb.destroy(); // Only proceed with damage if NOT in DEV MODE if (this.devMode) return; // Check for actual visual contact const playerBounds = player.getBounds(); const bombBounds = bomb.getBounds(); if (Phaser.Geom.Intersects.RectangleToRectangle(playerBounds, bombBounds)) { const damage = 20; this.playerHealth -= damage; this.updateHealthBar(); // Knock the player back const knockbackForce = 300; const angle = Phaser.Math.Angle.Between(bomb.x, bomb.y, player.x, player.y); player.setVelocity( Math.cos(angle) * knockbackForce, Math.sin(angle) * knockbackForce ); bomb.destroy(); } if (this.playerHealth <= 0 && !this.gameOver) { this.lives--; this.updateLives(); if (this.lives > 0) { this.playerHealth = this.maxPlayerHealth; this.updateHealthBar(); this.resetPlayerAndEnemies(); } else { this.gameOver = true; this.player.setTint(0xff0000); this.player.setVelocity(0, 0); this.stopMusic(); // Include the progress of the last life this.progressPerLife.push(this.currentLifeProgress); // Calculate average progress and adjust difficulty this.calculateAverageProgressAndAdjustDifficulty(); } } } stopMusic() { if (this.musicLoop) { this.musicLoop.remove(); } if (this.audioContext) { this.masterGain.gain.linearRampToValueAtTime(0, this.audioContext.currentTime + 1); } } checkFlyingBomberEnemies() { this.flyingBomberEnemies.getChildren().forEach(enemy => { if (enemy.x < 0) { enemy.x = this.levelWidth; } if (enemy.isActive) { enemy.setVelocityX(-50); } else { enemy.setVelocityX(0); } }); } calculateAverageProgressAndAdjustDifficulty() { const currentLevel = this.totalEnemies; const avgProgress = this.progressPerLife.reduce((a, b) => a + b, 0) / this.progressPerLife.length; const progressPercent = avgProgress * 100; let reduction = 13; if (progressPercent >= 90) reduction = 1; else if (progressPercent >= 80) reduction = 3; else if (progressPercent >= 70) reduction = 4; else if (progressPercent >= 60) reduction = 5; else if (progressPercent >= 50) reduction = 7; else if (progressPercent >= 40) reduction = 8; else if (progressPercent >= 30) reduction = 9; else if (progressPercent >= 20) reduction = 11; else if (progressPercent >= 10) reduction = 12; else reduction = 13; const newLevel = this.lives <= 0 ? Math.max(this.minEnemies, currentLevel - reduction) : currentLevel + ({ 5: 13, 4: 10, 3: 8, 2: 5, 1: 3 } [this.lives] || 0); const avgProgressPercent = Math.round(avgProgress * 100); this.time.delayedCall(1000, () => { this.scene.start('LevelClearScreen', { remainingLives: this.lives, nextLevelEnemies: newLevel, currentLevelEnemies: currentLevel, averageProgress: avgProgressPercent, isLoss: this.lives <= 0, currentRound: this.scene.settings.data.currentRound, totalRounds: this.scene.settings.data.totalRounds }); }); } createScalingMonkeyEnemy(enemyX, enemyY) { // Set spawn height to 100 pixels from top const spawnY = 100; const enemy = this.physics.add.sprite(enemyX, spawnY, 'player'); enemy.setTint(0x9932CC); // DarkOrchid purple tint for the scaling monkey enemy.body.setSize(24, 34); enemy.body.setOffset(20, 0); enemy.spawnX = enemyX; enemy.spawnY = spawnY; this.scalingMonkeyEnemies.add(enemy); enemy.body.setCollideWorldBounds(true); enemy.body.onWorldBounds = true; enemy.scalePhase = 0; enemy.body.setImmovable(false); enemy.body.setAllowGravity(true); enemy.isHopping = false; enemy.nextHopTime = this.time.now + Phaser.Math.Between(1000, 2500); enemy.previousX = enemyX; enemy.previousY = spawnY; enemy.activate = () => { enemy.body.enable = true; }; enemy.deactivate = () => { enemy.body.enable = false; enemy.setScale(1); }; enemy.hop = () => { if (!enemy.isHopping && enemy.body.touching.down) { enemy.isHopping = true; enemy.setVelocity(0, -1200); // Adjusted upward velocity for lower jump height enemy.body.setGravityY(600); // Keeping same reduced gravity for longer hang time // Reset hopping state and gravity after a longer delay this.time.delayedCall(800, () => { enemy.isHopping = false; enemy.setVelocityX(0); enemy.body.setGravityY(1200); // Reset to scene's default gravity }); // Set next hop time to exactly 5 seconds enemy.nextHopTime = this.time.now + 5000; } }; enemy.updateMovement = () => { if (!enemy.active || !this.isEnemyActive(enemy)) { return; } // Store current position before updates // Store current position before updates enemy.x = enemy.x; enemy.y = enemy.y; // Check if it's time for a hop (every 5 seconds) if (this.time.now >= enemy.nextHopTime) { enemy.hop(); } // Calculate scale using sine wave const scale = 2.4 * Math.sin(enemy.scalePhase); const finalScale = Math.max(0.4, Math.min(3.6, 1 + Math.abs(scale))); enemy.scalePhase += 0.012; // Apply the scale enemy.setScale(finalScale); }; enemy.resetPosition = () => { enemy.x = enemy.spawnX; enemy.y = enemy.spawnY; enemy.scalePhase = 0; enemy.setScale(1); enemy.setVelocity(0, 0); }; this.time.addEvent({ delay: 16, // Update every frame callback: enemy.updateMovement, loop: true }); // Add collision with platforms this.physics.add.collider(enemy, this.platforms); } createThrowingMonkeyEnemy(enemyX, enemyY) { const enemy = this.physics.add.sprite(enemyX, enemyY, 'player'); enemy.setTint(0xFFFF00); // Plain yellow color enemy.body.setSize(24, 34); enemy.body.setOffset(20, 0); enemy.spawnX = enemyX; enemy.spawnY = enemyY; this.throwingMonkeyEnemies.add(enemy); enemy.body.setCollideWorldBounds(true); enemy.body.onWorldBounds = true; enemy.hasLanded = false; enemy.hasMoved = false; enemy.updateMovement = () => { if (enemy.active && this.isEnemyActive(enemy)) { // Initial movement logic if (enemy.body && enemy.body.touching && enemy.body.touching.down && !enemy.hasMoved) { enemy.hasMoved = true; enemy.setVelocityX(75); // Move right this.time.delayedCall(800, () => { // Stop after 800ms if (enemy.body) { enemy.setVelocityX(0); } }); } } }; enemy.throwBomb = () => { if (enemy.active && this.isEnemyActive(enemy)) { const bombSize = 30; const bombGraphics = this.add.graphics(); bombGraphics.fillStyle(0x8B4513, 1); bombGraphics.fillCircle(0, 0, bombSize / 2); bombGraphics.generateTexture('monkeyBomb', bombSize, bombSize); bombGraphics.destroy(); const bomb = this.purpleBlocks.create(enemy.x, enemy.y, 'monkeyBomb'); bomb.setCircle(bombSize / 2); bomb.body.checkCollision.none = true; // Disable ALL collisions bomb.setCollideWorldBounds(false); // Don't collide with world bounds // Calculate angle and distance to player const angle = Phaser.Math.Angle.Between(enemy.x, enemy.y, this.player.x, this.player.y); const distance = Phaser.Math.Distance.Between(enemy.x, enemy.y, this.player.x, this.player.y); // Calculate initial velocity for arc trajectory const velocity = 400; const vx = Math.cos(angle) * velocity; const vy = Math.sin(angle) * velocity - 200; // Add upward component for arc bomb.setVelocity(vx, vy); // Set physics properties for the purple block bomb.body.checkCollision.none = true; // Disable all collisions bomb.body.setAllowGravity(true); // Enable gravity bomb.body.setBounce(0); // No bounce // Check for bottom of screen to destroy the block this.time.addEvent({ delay: 16, callback: () => { if (bomb && bomb.active && bomb.y > this.cameras.main.height) { bomb.destroy(); } }, loop: true }); } }; // Update movement and throw bombs periodically // Add update event for movement this.time.addEvent({ delay: 16, callback: enemy.updateMovement, loop: true }); // Initialize first hop cycle enemy.nextHopTime = this.time.now + 2500; // Start first hop after 2.5 seconds this.time.addEvent({ delay: 2000, callback: enemy.throwBomb, loop: true }); // Add collision with platforms this.physics.add.collider(enemy, this.platforms); } createThrowingMonkeyEnemy(enemyX, enemyY) { const enemy = this.physics.add.sprite(enemyX, enemyY, 'player'); enemy.setTint(0xFFFF00); // Yellow tint enemy.body.setSize(24, 34); enemy.body.setOffset(20, 0); enemy.spawnX = enemyX; enemy.spawnY = enemyY; this.throwingMonkeyEnemies.add(enemy); enemy.body.setCollideWorldBounds(true); enemy.body.onWorldBounds = true; // Add properties for hopping behavior enemy.isHopping = false; enemy.hopCount = 0; enemy.hopDirection = -1; // Start with left hops enemy.nextHopTime = 0; enemy.waitTime = 0; // Add hop method enemy.hop = () => { if (!enemy.isHopping && enemy.body.touching.down) { enemy.isHopping = true; enemy.setVelocityY(-250); // Upward velocity for short hop enemy.setVelocityX(enemy.hopDirection * 150); // Horizontal movement // Reset hopping state when landed this.time.delayedCall(400, () => { enemy.isHopping = false; enemy.hopCount++; // After two hops, wait and change direction if (enemy.hopCount >= 2) { enemy.hopCount = 0; enemy.waitTime = this.time.now + 2500; // Wait 2.5 seconds enemy.hopDirection *= -1; // Change direction } else { enemy.nextHopTime = this.time.now + 200; // Short delay between hops } }); } }; // Add movement update method enemy.updateMovement = () => { if (enemy.active && this.isEnemyActive(enemy)) { const currentTime = this.time.now; // Check if waiting period is over if (currentTime >= enemy.waitTime && !enemy.isHopping && currentTime >= enemy.nextHopTime) { enemy.hop(); } } }; enemy.throwBomb = () => { if (enemy.active && this.isEnemyActive(enemy)) { // Determine which side the player is on and spawn bomb on opposite side const playerDirection = this.player.x < enemy.x ? -1 : 1; // Direction TO player const spawnOffsetX = -playerDirection * 30; // Spawn opposite of player const throwOffsetY = -20; // Slightly above the head // Create a circle graphics object for the bomb const bombRadius = 17; // Same size as monkey const bombGraphics = this.add.graphics(); bombGraphics.fillStyle(0x000000); bombGraphics.fillCircle(bombRadius, bombRadius, bombRadius); const bombTexture = 'bomb' + Date.now(); // Unique texture name bombGraphics.generateTexture(bombTexture, bombRadius * 2, bombRadius * 2); bombGraphics.destroy(); // Create the bomb sprite with the circle texture const bomb = this.throwingMonkeyBombs.create( enemy.x + spawnOffsetX, enemy.y + throwOffsetY, bombTexture ); // Set up physics for the bomb bomb.setCircle(bombRadius); bomb.setBounce(0.4); bomb.setCollideWorldBounds(true); bomb.setMass(1); bomb.setFriction(0.8); bomb.setDrag(50); // Set velocity for 45-degree angle throw towards player const velocity = 300; // Halved from 600 to 300 const angleInRadians = Math.PI / 4; // 45 degrees in radians // Calculate velocity components (always throw towards player) const vx = playerDirection * (velocity * Math.cos(angleInRadians)); // Use playerDirection for velocity const vy = -velocity * Math.sin(angleInRadians); // Always throw upward bomb.setVelocity(vx, vy); // Simply destroy the bomb after a longer delay (no explosion) const destroyTimer = this.time.delayedCall(2500, () => { if (bomb && bomb.active) { bomb.destroy(); } }); // Add check for off-screen destruction const checkOffScreen = this.time.addEvent({ delay: 16, callback: () => { if (bomb && bomb.active) { if (bomb.y > this.cameras.main.height + 100 || bomb.x < -100 || bomb.x > this.levelWidth + 100) { destroyTimer.remove(); checkOffScreen.remove(); bomb.destroy(); } } }, loop: true }); } }; // Throw bombs periodically this.time.addEvent({ delay: 3000, callback: enemy.throwBomb, loop: true }); // Add collision with platforms and player this.physics.add.collider(enemy, this.platforms); // Add platform collision for the throwing monkey's bombs this.physics.add.collider(this.throwingMonkeyBombs, this.platforms); // Add collision detection for purple blocks in create() method // Use collider instead of overlap to handle physics properly // Remove any existing collision handlers this.physics.world.colliders.getActive() .filter(collider => collider.object1 === this.throwingMonkeyBombs && collider.object2 === this.player) .forEach(collider => collider.destroy()); // Add new collision handler that keeps bombs active this.physics.add.collider(this.throwingMonkeyBombs, this.player, (bomb, player) => { if (!bomb.active || !player.active || player.isInvulnerable) return; // Calculate collision angle and forces const angle = Phaser.Math.Angle.Between(player.x, player.y, bomb.x, bomb.y); const pushForce = 200; const playerRecoilForce = pushForce * 0.3; // Apply velocities based on collision bomb.setVelocity( Math.cos(angle) * pushForce, Math.sin(angle) * pushForce ); player.setVelocity( Math.cos(angle) * -playerRecoilForce, Math.sin(angle) * -playerRecoilForce ); // Apply triple damage if not in dev mode if (!this.devMode && !this.isHealthLocked) { this.playerHealth -= 45; // Triple the original 15 damage this.updateHealthBar(); // Check for player death if (this.playerHealth <= 0) { this.handlePlayerDeath(); } } // Make player briefly invulnerable player.isInvulnerable = true; this.time.delayedCall(500, () => { player.isInvulnerable = false; }); }, null, this); } handlePlayerDeath() { this.lives--; this.updateLives(); this.progressPerLife.push(this.currentLifeProgress); if (this.lives > 0) { this.playerHealth = this.maxPlayerHealth; this.updateHealthBar(); this.resetPlayerAndEnemies(); this.currentLifeProgress = 0; } else { if (!this.gameOver) { this.gameOver = true; this.player.setTint(0xff0000); this.player.setVelocity(0, 0); this.stopMusic(); this.calculateAverageProgressAndAdjustDifficulty(); } } } createBossMonkey(x, y) { const boss = this.physics.add.sprite(x, y, 'player'); boss.setScale(this.bossBaseScale); boss.setTint(0x2ECC71); // Monster shade of green (emerald green) boss.body.setSize(24, 34); boss.body.setOffset(20, 0); boss.spawnX = x; boss.spawnY = y; boss.body.setImmovable(false); boss.body.setFrictionX(0.154); boss.isActive = false; boss.actionTimer = 0; boss.nextActionDelay = Phaser.Math.Between(1500, 2500); boss.currentAction = null; boss.isCharging = false; boss.isMeleeing = false; boss.chargeSpeed = 400; boss.returnSpeed = 200; this.bossMonkeyGroup = this.physics.add.group(); this.bossMonkeyGroup.add(boss); boss.body.setCollideWorldBounds(true); // Setup attack timers and flags boss.lastAttackTime = 0; boss.attackDelay = 2750; // Attack every 2.75 seconds // Create larger electric bullet graphics const bulletGraphics = this.add.graphics(); bulletGraphics.fillStyle(0x00FFFF, 0.5); // Cyan outer glow bulletGraphics.fillCircle(20, 20, 20); // Twice as large bulletGraphics.fillStyle(0x0000FF, 1); // Blue core bulletGraphics.fillCircle(20, 20, 14); // Twice as large bulletGraphics.generateTexture('bossBullet', 40, 40); bulletGraphics.destroy(); boss.updateBehavior = () => { if (!boss.active) return; const distanceToPlayer = Phaser.Math.Distance.Between( boss.x, boss.y, this.player.x, this.player.y ); const activationDistance = this.screenWidth * 1.5; const shouldActivate = distanceToPlayer <= activationDistance; // Activate boss and start attacks when player is close enough if (!boss.isActive && shouldActivate) { boss.isActive = true; boss.setVelocityX(0); } // Handle attacks when active if (boss.isActive) { const currentTime = this.time.now; if (currentTime - boss.lastAttackTime >= boss.attackDelay) { boss.lastAttackTime = currentTime; // Randomly choose attack type if (Phaser.Math.Between(0, 1) === 0) { // Fire electric bullet const bullet = this.physics.add.sprite(boss.x, boss.y, 'bossBullet'); bullet.body.setCircle(20); bullet.body.setAllowGravity(false); // Add flashing effect this.tweens.add({ targets: bullet, alpha: 0.7, scale: { from: 0.9, to: 1.1 }, duration: 100, yoyo: true, repeat: -1, ease: 'Linear' }); // Calculate angle to player const angle = Phaser.Math.Angle.Between( boss.x, boss.y, this.player.x, this.player.y ); // Set bullet velocity const speed = 225; // Reduced from 300 for slower bullets bullet.setVelocity( Math.cos(angle) * speed, Math.sin(angle) * speed ); // Add collision with player this.physics.add.overlap(bullet, this.player, (bullet, player) => { if (!player.isInvulnerable) { if (!this.devMode && !this.isHealthLocked) { this.playerHealth -= 40; // Same as normal enemy bullet damage this.updateHealthBar(); if (this.playerHealth <= 0) { this.handlePlayerDeath(); } } player.isInvulnerable = true; this.time.delayedCall(500, () => { player.isInvulnerable = false; }); } bullet.destroy(); }); // Destroy bullet after 3 seconds this.time.delayedCall(3000, () => { if (bullet && bullet.active) { bullet.destroy(); } }); } else { // Throw large bomb const bombRadius = 34; // Twice the size const bombGraphics = this.add.graphics(); bombGraphics.fillStyle(0x000000); bombGraphics.fillCircle(bombRadius, bombRadius, bombRadius); const bombTexture = 'bossBomb' + Date.now(); bombGraphics.generateTexture(bombTexture, bombRadius * 2, bombRadius * 2); bombGraphics.destroy(); const playerDirection = this.player.x < boss.x ? -1 : 1; const bomb = this.throwingMonkeyBombs.create( boss.x + (-playerDirection * 60), boss.y - 40, bombTexture ); bomb.setOrigin(0.5, 0.5); bomb.setCircle(bombRadius); bomb.setBounce(0.4); bomb.setCollideWorldBounds(true); bomb.setMass(2); bomb.setFriction(0.8); bomb.setDrag(50); // Add collision with platforms for the bomb this.physics.add.collider(bomb, this.platforms); const velocity = 300; // Halved from 600 to 300 for slower bombs const angleInRadians = Math.PI / 4; const vx = playerDirection * (velocity * Math.cos(angleInRadians)); const vy = -velocity * Math.sin(angleInRadians); bomb.setVelocity(vx, vy); // Set up bomb explosion // Simply destroy the bomb after a longer delay (no explosion) const destroyTimer = this.time.delayedCall(3500, () => { if (bomb && bomb.active) { bomb.destroy(); } }); } } } }; this.physics.add.collider(boss, this.platforms); this.time.addEvent({ delay: 16, callback: boss.updateBehavior, loop: true }); return boss; } } class LevelClearScreen extends Phaser.Scene { constructor() { super('LevelClearScreen'); } create(data) { const { remainingLives, nextLevelEnemies, currentLevelEnemies, currentRound, totalRounds } = data; // Check if this is the final round if (currentRound >= totalRounds) { // If it's the final round, go to the RoundOverScreen this.scene.start('RoundOverScreen', { totalRounds: totalRounds }); return; } // Set background color this.cameras.main.setBackgroundColor('#000000'); // Add running total display in yellow this.add.text(400, 100, `Running Total: ${PlatformerLevel.runningTotal}`, { fontSize: '32px', fill: '#ffff00', align: 'center' }).setOrigin(0.5); // Create the message based on remaining lives let message; if (data.isLoss) { if (nextLevelEnemies === currentLevelEnemies) { message = `Your average progress this level was ${data.averageProgress}%,\nso we'll keep the difficulty the same for now.`; } else { message = `Your average progress this level was ${data.averageProgress}%,\nso we'll lower the level to ${nextLevelEnemies}.`; } } else { const multiplier = 1 + (remainingLives * 0.1); if (nextLevelEnemies === currentLevelEnemies) { message = `You beat the level with ${remainingLives} ${remainingLives === 1 ? 'life' : 'lives'} remaining,\nbut the difficulty will stay at ${currentLevelEnemies}.`; } else { message = `You beat the level with ${remainingLives} ${remainingLives === 1 ? 'life' : 'lives'} remaining,\nso we'll raise the level to ${nextLevelEnemies}.\n\nGood job!`; } } // Add the message text with smaller font size and width check const text = this.add.text(400, 300, message, { fontSize: '28px', fill: '#ffffff', align: 'center', wordWrap: { width: 780 } // Ensure text wraps before reaching screen edges }).setOrigin(0.5); // Add encouragement text when needed if (data.isLoss || nextLevelEnemies === currentLevelEnemies) { this.add.text(400, 400, 'Keep at it! You can do it!', { fontSize: '28px', fill: '#ffffff', align: 'center' }).setOrigin(0.5); } // Add "Press ENTER to continue" text const continueText = this.add.text(400, 500, 'Press ENTER to continue', { fontSize: '28px', fill: '#00ff00', align: 'center', wordWrap: { width: 780 } // Add word wrap here too for consistency }).setOrigin(0.5); // Add ENTER key handler to start the next level this.input.keyboard.once('keydown-ENTER', () => { this.scene.stop(); this.scene.start('PlatformerLevel', { totalEnemies: nextLevelEnemies, startNewLevel: true, speedBoost: TitleScreen.devOptions?.speedBoost || false, invincible: TitleScreen.devOptions?.invincible || false, startNearEnd: TitleScreen.devOptions?.startNearEnd || false, currentRound: data.currentRound + 1, totalRounds: data.totalRounds }); }); } } class RoundOverScreen extends Phaser.Scene { constructor() { super('RoundOverScreen'); } create(data) { // Set background color this.cameras.main.setBackgroundColor('#000000'); // Display "ROUND OVER" this.add.text(400, 200, 'ROUND OVER', { fontSize: '64px', fill: '#ffffff', align: 'center' }).setOrigin(0.5); // Display final score this.add.text(400, 300, `Final score: ${PlatformerLevel.runningTotal}`, { fontSize: '32px', fill: '#ffff00', align: 'center' }).setOrigin(0.5); // Display round length this.add.text(400, 350, `Round length: ${data.totalRounds}`, { fontSize: '28px', fill: '#ffffff', align: 'center' }).setOrigin(0.5); // Display best clear level const bestClearText = this.scene.get('PlatformerLevel').bestClearLevel > 0 ? `Level ${this.scene.get('PlatformerLevel').bestClearLevel}` : '-'; this.add.text(400, 400, `Best Clear: ${bestClearText}`, { fontSize: '24px', fill: '#ffffff', align: 'center' }).setOrigin(0.5); // Display thank you message this.add.text(400, 450, 'Thanks for playing!', { fontSize: '32px', fill: '#ffffff', align: 'center' }).setOrigin(0.5); // Display replay instruction this.add.text(400, 550, 'Refresh page to replay', { fontSize: '24px', fill: '#00ff00', align: 'center' }).setOrigin(0.5); } } const config = { type: Phaser.AUTO, parent: 'renderDiv', width: 800, height: 600, scene: [TitleScreen, PlatformerLevel, LevelClearScreen, RoundOverScreen], scale: { mode: Phaser.Scale.FIT, autoCenter: Phaser.Scale.CENTER_BOTH, }, physics: { default: 'arcade', arcade: { gravity: { y: 1200 }, debug: false } } }; window.phaserGame = new Phaser.Game(config);