class PlatformerLevel extends Phaser.Scene { constructor() { super('PlatformerLevel'); this.platforms = null; this.player = null; this.playerLocked = false; // New property to track if player is locked this.enemyMultiplier = 1; this.totalEnemies = 28; // 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; this.safeZoneWidth = 500; this.groundHeight = 32; this.maxPlatformHeight = 100; this.playerSpeed = 249; this.playerAcceleration = 1000; this.playerDeceleration = 500; this.minPlatformDifference = 10; this.playerHealth = 438; this.maxPlayerHealth = 438; 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.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'); this.load.image('player', 'https://labs.phaser.io/assets/sprites/phaser-dude.png'); this.load.image('sparkle', 'https://labs.phaser.io/assets/particles/blue.png'); } create(data) { // 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 = 438; 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 = 28; // 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.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.projectiles = this.physics.add.group(); this.generateLevel(); this.player = this.physics.add.sprite(100, 450, 'player'); 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, 0.05, 0.05); this.physics.add.collider(this.player, this.platforms); this.cursors = this.input.keyboard.createCursorKeys(); this.player.setDragX(this.playerDeceleration); this.createHealthBar(); this.updateHealthBar(); this.updateLives(); this.updateDifficultyDisplay(); 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.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 (this.isLevelClearing) return; // Prevent multiple calls this.isLevelClearing = true; this.isHealthLocked = true; if (sparklyObject && sparklyObject.destroy) sparklyObject.destroy(); this.cameras.main.fade(1000, 255, 255, 255); this.stopMusic(); // Clear all enemies this.clearAllEnemies(); // Update best clear level this.bestClearLevel = Math.max(this.bestClearLevel, this.totalEnemies); // Calculate new enemy count const newMultiplier = 1 + Math.max(0, (this.lives - 1) / 10); this.totalEnemies = Math.round(this.totalEnemies * newMultiplier); this.totalEnemies = Math.max(this.minEnemies, this.totalEnemies); // Use a try-catch block to catch and log any errors try { this.time.delayedCall(1000, () => { this.isHealthLocked = false; this.isLevelClearing = false; this.scene.restart({ totalEnemies: this.totalEnemies }); }); } catch (error) { console.error("Error in handleSparklyObjectCollection:", error); } } 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() { for (let i = 0; i < 15; i++) { this.platforms.create(i * this.screenWidth + this.screenWidth / 2, 600 - this.groundHeight / 2, 'ground').setScale(2, 1).refreshBody(); } // Add a darker background for the final screen this.add.rectangle(14 * this.screenWidth, 0, this.screenWidth, 600, 0x000000, 0.5).setOrigin(0, 0); for (let i = 0; i < 14; i++) { 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; // 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, 5); } while (enemyType === lastEnemyType); lastEnemyType = enemyType; let enemyY = 300; 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.createFloatingEnemy(enemyX, enemyY); break; case 4: this.createDancingEnemy(enemyX, enemyY); break; case 5: this.createFlyingBomberEnemy(enemyX, 100); // Flying higher break; } } } // Add sparkly object on the last screen const lastScreenX = 14 * this.screenWidth; const sparklyObjectX = lastScreenX + this.screenWidth / 2; const sparklyObjectY = 400; // Lowered from 300 to 400 (remember, y increases downward) this.createSparklyObject(sparklyObjectX, sparklyObjectY); } createEnemy(enemyX, enemyY) { const enemy = this.physics.add.sprite(enemyX, enemyY, 'player'); enemy.setTint(0xFF0000); // Tint the enemy red 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(-100, 100)); } }; enemy.activate = () => { enemy.body.enable = true; enemy.updateMovement(); }; enemy.deactivate = () => { enemy.body.enable = false; enemy.setVelocity(0, 0); }; this.time.addEvent({ delay: 2000, 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.setVelocityX(150); enemy.body.setCollideWorldBounds(true); enemy.body.onWorldBounds = true; enemy.updateMovement = () => { if (enemy.active && this.isEnemyActive(enemy) && enemy.body.touching.down) { enemy.setVelocityY(-700); // Increased jump height enemy.setVelocityX(Phaser.Math.Between(-180, 180)); // Slightly increased horizontal movement } else if (!this.isEnemyActive(enemy)) { enemy.setVelocity(0, 0); } }; this.time.addEvent({ delay: 1500, 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 || this.isHealthLocked) return; const minDamage = 15; // Increased minimum damage const damage = Math.max(minDamage, 10); // Ensure at least minDamage is dealt this.playerHealth -= damage; this.updateHealthBar(); this.playerHealth -= damage; this.updateHealthBar(); // Knock the player back const playerKnockbackForce = 200; const angle = Phaser.Math.Angle.Between(enemy.x, enemy.y, player.x, player.y); player.setVelocity( Math.cos(angle) * playerKnockbackForce, Math.sin(angle) * playerKnockbackForce ); // Knock the enemy back const enemyKnockbackForce = this.shootingEnemies.contains(enemy) ? 50 : 150; enemy.setVelocity( Math.cos(angle) * -enemyKnockbackForce, Math.sin(angle) * -enemyKnockbackForce ); // 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}` : '-'; this.bestClearDisplay = this.add.text(10, 70, `Best Clear: ${bestClearText}`, { fontSize: '16px', fill: '#fff' }).setScrollFactor(0); // Move instruction text down this.add.text(10, 90, 'Arrow keys to move/jump', { fontSize: '14px', fill: '#fff' }).setScrollFactor(0); } updateHealthBar() { this.healthBar.width = Math.max(0, (this.playerHealth / this.maxPlayerHealth) * 200); } updateLives() { this.livesText.setText(`Lives: ${this.lives}`); } update() { if (this.gameOver || this.isLevelClearing) return; this.updateEnemyActivity(); this.checkFlyingBomberEnemies(); // 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 = (this.player.x - this.startX) / (this.goalX - this.startX); this.currentLifeProgress = Math.max(this.currentLifeProgress, newProgress); // Update progress display const progressPercentage = 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); } // 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.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.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; // Tripled from 25 to 75 enemy.shoot = () => { if (enemy.active && this.isEnemyActive(enemy) && this.isEnemyOnScreen(enemy)) { const projectile = this.add.graphics(); projectile.fillStyle(0xFFFF00, 1); // Yellow color projectile.fillCircle(0, 0, 11.25); // 11.25px radius circle (2.25x larger) projectile.generateTexture('bullet', 23, 23); // 23x23 texture (2.25x larger) projectile.destroy(); const bulletSprite = this.projectiles.create(enemy.x, enemy.y, 'bullet'); bulletSprite.setCircle(7.5); // Increase collision circle size // Calculate angle to player's current position const angle = Phaser.Math.Angle.Between(enemy.x, enemy.y, this.player.x, this.player.y); // Set bullet speed (25% slower) const bulletSpeed = 337.5; // Reduced from 450 (75% of original speed) // Set velocity towards the player this.physics.velocityFromRotation(angle, bulletSpeed, bulletSprite.body.velocity); // Disable gravity for the bullet bulletSprite.body.setAllowGravity(false); bulletSprite.setActive(true); bulletSprite.setVisible(true); bulletSprite.body.setCollideWorldBounds(true); bulletSprite.body.onWorldBounds = true; bulletSprite.body.world.on('worldbounds', (body) => { if (body.gameObject === bulletSprite) { bulletSprite.destroy(); } }); } }; enemy.updateMovement = () => { if (enemy.body && enemy.body.touching && enemy.body.touching.down && !enemy.hasMoved) { enemy.hasMoved = true; enemy.setVelocityX(75); // Increased speed from 50 to 75 for faster movement this.time.delayedCall(800, () => { // Doubled time from 400 to 800 to match the increased distance if (enemy.body) { // Check if enemy still exists enemy.setVelocityX(0); } }); } }; enemy.resetPosition = () => { enemy.hasLanded = false; enemy.hasMoved = false; enemy.body.reset(enemy.spawnX, enemy.spawnY); }; this.time.addEvent({ delay: 2000, callback: enemy.shoot, loop: true }); // 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(0xFFA500); // Tint the floating enemy orange 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; // Reduced from 300 (25% slower) enemy.setVelocity( Math.cos(angle) * lungeSpeed, Math.sin(angle) * lungeSpeed ); this.time.delayedCall(500, () => { 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.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) { projectile.destroy(); } handlePlayerProjectileCollision(player, projectile) { if (this.isHealthLocked) return; const minDamage = 15; // Increased minimum damage const damage = Math.max(minDamage, 10); // Ensure at least minDamage is dealt 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); // Lock player movement this.playerLocked = true; // Reset progress for the new life this.currentLifeProgress = 0; this.progressDisplay.setText('Progress: 0%'); // Reset all enemies to their spawn points this.enemies.getChildren().forEach(this.resetEnemy, this); this.jumpingEnemies.getChildren().forEach(this.resetEnemy, this); this.shootingEnemies.getChildren().forEach(this.resetEnemy, this); this.floatingEnemies.getChildren().forEach(this.resetEnemy, this); this.dancingEnemies.getChildren().forEach(this.resetEnemy, this); this.flyingBomberEnemies.getChildren().forEach(this.resetEnemy, this); // Set a timer to unlock the player after a short delay this.time.delayedCall(1000, () => { // 1000ms delay, adjust as needed this.playerLocked = false; }); } resetEnemy(enemy) { enemy.setPosition(enemy.spawnX, enemy.spawnY); enemy.setVelocity(0, 0); if (enemy.resetPosition) { enemy.resetPosition(); } // Specific reset behavior for flying bomber enemies if (this.flyingBomberEnemies.contains(enemy)) { enemy.setVelocityX(-50); // Restore constant left movement } // Specific reset behavior for shooting enemies if (this.shootingEnemies.contains(enemy)) { enemy.hasLanded = false; this.time.delayedCall(100, () => { // Small delay to ensure the enemy is on the ground enemy.updateMovement(); }); } } createFlyingBomberEnemy(enemyX, enemyY) { const enemy = this.physics.add.sprite(enemyX, enemyY, 'player'); enemy.setTint(0xA9A9A9); // Lighter gray color (DarkGray) 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.dropBomb = () => { if (enemy.active && enemy.isActive && this.isEnemyOnScreen(enemy)) { const bombWidth = 30; const bombHeight = 40; const bombGraphic = this.add.graphics(); bombGraphic.fillStyle(0x4B0082, 1); // Dark purple color (Indigo) for the bomb bombGraphic.fillRect(0, 0, bombWidth, bombHeight); bombGraphic.generateTexture('bomb', bombWidth, bombHeight); bombGraphic.destroy(); const bomb = this.projectiles.create(enemy.x, enemy.y, 'bomb'); bomb.setSize(bombWidth, bombHeight); bomb.body.setAllowGravity(true); bomb.body.setCollideWorldBounds(true); bomb.body.onWorldBounds = true; this.physics.add.collider(bomb, this.platforms, (bomb) => { bomb.destroy(); }); this.physics.add.overlap(this.player, bomb, this.handlePlayerBombCollision, null, this); } }; enemy.activate = () => { enemy.setVelocityX(-50); }; enemy.deactivate = () => { enemy.setVelocityX(0); }; this.time.addEvent({ delay: 2000, callback: enemy.dropBomb, loop: true }); } handlePlayerBombCollision(player, bomb) { if (this.isHealthLocked) 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() { // Calculate average progress const averageProgress = this.progressPerLife.reduce((a, b) => a + b, 0) / this.progressPerLife.length; // Adjust difficulty based on average progress const divider = 2 - averageProgress; // This maps 0% to 2 and 100% to 1 const newEnemyCount = Math.max(this.minEnemies, Math.round(this.totalEnemies / divider)); this.totalEnemies = newEnemyCount; this.time.delayedCall(1000, () => { this.scene.restart({ totalEnemies: this.totalEnemies }); }); } } const config = { type: Phaser.AUTO, parent: 'renderDiv', width: 800, height: 600, scale: { mode: Phaser.Scale.FIT, autoCenter: Phaser.Scale.CENTER_BOTH, }, physics: { default: 'arcade', arcade: { gravity: { y: 1200 // Increased from 800 to 1200 }, debug: false } }, scene: PlatformerLevel }; window.phaserGame = new Phaser.Game(config);