class PreGameScene extends Phaser.Scene { constructor() { super({ key: 'PreGameScene' }); } preload() { this.load.image('metalRock1', 'https://play.rosebud.ai/assets/MetalRock1.png?Pnce'); this.load.image('metalRock2', 'https://play.rosebud.ai/assets/MetalRock2.png?VNbV'); this.load.image('energyRock1', 'https://play.rosebud.ai/assets/EnergyRock1.png?jAjE'); this.load.image('energyRock2', 'https://play.rosebud.ai/assets/EnergyRock2.png?ZMOh'); } create() { // Add title text const title = this.add.text(this.cameras.main.centerX, 100, 'ASTEROID MINER', { fontFamily: 'Arial', fontSize: '38px', color: '#ffffff', stroke: '#333333', strokeThickness: 4 }).setOrigin(0.5); // Add scrolling metal rocks const rock1 = this.add.image(0, 200, 'metalRock1').setScale(0.2); const rock2 = this.add.image(this.cameras.main.width, 200, 'metalRock2').setScale(0.2); // Set up scrolling animation for rocks this.tweens.add({ targets: rock1, x: this.cameras.main.width + 50, duration: 8000, repeat: -1, onRepeat: () => { rock1.x = -50; } }); this.tweens.add({ targets: rock2, x: -50, duration: 12000, repeat: -1, onRepeat: () => { rock2.x = this.cameras.main.width + 50; } }); // Add instruction texts with double spacing const collectText = this.add.text(this.cameras.main.centerX, 200, 'Collect Ore to scOre', { fontFamily: 'Arial', fontSize: '24px', color: '#ffffff', stroke: '#333333', strokeThickness: 2 }).setOrigin(0.5); // Add scrolling energy rocks const energyRock1 = this.add.image(0, 300, 'energyRock1').setScale(0.2); const energyRock2 = this.add.image(this.cameras.main.width, 300, 'energyRock2').setScale(0.2); // Set up scrolling animation for energy rocks this.tweens.add({ targets: energyRock1, x: this.cameras.main.width + 50, duration: 10000, repeat: -1, onRepeat: () => { energyRock1.x = -50; } }); this.tweens.add({ targets: energyRock2, x: -50, duration: 15000, repeat: -1, onRepeat: () => { energyRock2.x = this.cameras.main.width + 50; } }); const crystalsText = this.add.text(this.cameras.main.centerX, 300, 'Crystals to Level Up', { fontFamily: 'Arial', fontSize: '24px', color: '#ffffff', stroke: '#333333', strokeThickness: 2 }).setOrigin(0.5); const consumptionText = this.add.text(this.cameras.main.centerX, 400, 'Manage Consumption', { fontFamily: 'Arial', fontSize: '24px', color: '#ffffff', stroke: '#333333', strokeThickness: 2 }).setOrigin(0.5).setDepth(1); // Add boss mortality text const bossText = this.add.text(this.cameras.main.centerX, 500, 'Boss Only Mortal in Level 1', { fontFamily: 'Arial', fontSize: '24px', color: '#ff0000', stroke: '#333333', strokeThickness: 2 }).setOrigin(0.5).setDepth(1); // Add orbiting particles around consumption text const particleCount = 6; const orbitRadius = 50; const particles = []; // Create six particles for (let i = 0; i < particleCount; i++) { const angle = (i / particleCount) * Math.PI * 2; const x = consumptionText.x + Math.cos(angle) * orbitRadius; const y = consumptionText.y + Math.sin(angle) * orbitRadius; const particle = this.add.rectangle(x, y, 6, 6, 0xFFFFFF); particle.setDepth(1); particles.push(particle); // Create orbital motion tween this.tweens.add({ targets: particle, angle: 360, duration: 3000, repeat: -1, onUpdate: (tween, target) => { const currentAngle = angle + (target.angle * Math.PI / 180); target.x = consumptionText.x + Math.cos(currentAngle) * orbitRadius; target.y = consumptionText.y + Math.sin(currentAngle) * orbitRadius; } }); // Add color flicker tween this.tweens.add({ targets: particle, fillColor: { from: 0xFFFFFF, to: 0xFFFF00 }, duration: 500, yoyo: true, repeat: -1, ease: 'Sine.easeInOut' }); } // Add start game button const startButton = this.add.text(this.cameras.main.centerX, this.cameras.main.height - 100, 'START GAME', { fontFamily: 'Arial', fontSize: '32px', color: '#00ff00', stroke: '#003300', strokeThickness: 2, padding: { x: 20, y: 10 } }).setOrigin(0.5) .setInteractive({ useHandCursor: true }); // Add hover effect startButton.on('pointerover', () => { startButton.setScale(1.1); }); startButton.on('pointerout', () => { startButton.setScale(1); }); // Add click handler to start the game startButton.on('pointerdown', () => { this.scene.start('GameScene'); }); } } class GameScene extends Phaser.Scene { constructor() { super({ key: 'GameScene' }); } preload() { this.load.image('background', 'https://play.rosebud.ai/assets/Asteroid Background.jpg?zo6n'); this.load.image('spaceship', 'https://play.rosebud.ai/assets/1000013889.png?vap0'); this.load.image('joystick', 'https://play.rosebud.ai/assets/1000013907.png?6NBQ'); this.load.image('throttle', 'https://play.rosebud.ai/assets/1000013906.png?R1Jw'); this.load.image('fireButton', 'https://play.rosebud.ai/assets/1000013905.png?mCPQ'); this.load.audio('rocketSound', 'https://play.rosebud.ai/assets/Rocket_Engine.mp3?UsDO'); this.load.audio('laserSound', 'https://play.rosebud.ai/assets/Laser_torpedo_blast (3).mp3?KKy1'); this.load.audio('backgroundMusic', 'https://play.rosebud.ai/assets/Asteroid Miner Music.mp3?3iH4'); this.load.audio('explosionSound', 'https://play.rosebud.ai/assets/Rock_exploding.mp3?Sd56'); this.load.image('largeAsteroid', 'https://play.rosebud.ai/assets/Large Asteroid.png?Kz0S'); this.load.image('largeRubble', 'https://play.rosebud.ai/assets/Large Rubble.png?NfSE'); this.load.image('mediumAsteroid', 'https://play.rosebud.ai/assets/Medium Asteroid.png?ehoz'); this.load.image('mediumRubble', 'https://play.rosebud.ai/assets/Medium Rubble.png?Lm68'); this.load.image('smallAsteroid1', 'https://play.rosebud.ai/assets/EnergyRock1.png?jAjE'); this.load.image('smallAsteroid2', 'https://play.rosebud.ai/assets/EnergyRock2.png?ZMOh'); this.load.image('smallAsteroid3', 'https://play.rosebud.ai/assets/MetalRock1.png?Pnce'); this.load.image('smallAsteroid4', 'https://play.rosebud.ai/assets/MetalRock2.png?VNbV'); this.load.image('boss', 'https://play.rosebud.ai/assets/Boss.png?Rz2K'); this.load.audio('collectSound', 'https://play.rosebud.ai/assets/Blip.mp3?wGkK'); this.load.audio('metalCollectSound', 'https://play.rosebud.ai/assets/Blip (2).mp3?bgnd'); this.load.audio('bossCollectSound', 'https://play.rosebud.ai/assets/BadBlip.mp3?FR1j'); this.load.audio('bossWarning', 'https://play.rosebud.ai/assets/Boss-WhoDares.wav?ys58'); this.load.audio('bossAwakened', 'https://play.rosebud.ai/assets/Boss-Awakened.wav?ExgM'); this.load.audio('bossThreat1', 'https://play.rosebud.ai/assets/Boss-Threat1.wav?ifpn'); this.load.audio('bossThreat2', 'https://play.rosebud.ai/assets/Boss-Threat2.wav?GP0C'); this.load.audio('bossThreat3', 'https://play.rosebud.ai/assets/Boss-Threat3.wav?K7Xg'); } create() { // Create out of energy warning text this.outOfEnergyText = this.add.text(this.cameras.main.centerX, 100, 'OUT OF ENERGY', { fontFamily: 'Arial', fontSize: '32px', color: '#ff0000', stroke: '#ffffff', strokeThickness: 4 }).setOrigin(0.5).setScrollFactor(0).setDepth(1000).setVisible(false); // Initialize game state variables this.score = 0; this.level = 1; this.crystals = 10 + (this.level - 1) * 5; // Start with 10 crystals + 5 per level this.energy = 1000; this.zeroEnergyStartTime = null; // Track when energy hits zero this.bossHealth = 0; this.warningPlayed = false; this.bossIsAlive = false; this.debugBossAnchored = false; // Allow boss to move freely // Boss movement properties this.bossSpeed = 5; // Halved from 10 this.bossSurgeSpeed = 250; // Halved from 500 this.bossNextSurgeTime = 0; this.bossSurgeInterval = Phaser.Math.Between(3000, 6000); this.bossIsSurging = false; this.bossSurgeStartTime = 0; // Track when surge starts this.bossSurgeDuration = 250; // Quarter second in milliseconds this.bossLevel = 1; this.gameEnded = false; // Create a larger world (5 times width, 3 times height) this.worldWidth = this.scale.width * 5; this.worldHeight = this.scale.height * 3; this.matter.world.setBounds(0, 0, this.worldWidth, this.worldHeight); console.log('World dimensions:', this.worldWidth, this.worldHeight); // Create world bounds as static bodies this.matter.add.rectangle(this.worldWidth / 2, -25, this.worldWidth, 50, { isStatic: true }); this.matter.add.rectangle(this.worldWidth / 2, this.worldHeight + 25, this.worldWidth, 50, { isStatic: true }); this.matter.add.rectangle(-25, this.worldHeight / 2, 50, this.worldHeight, { isStatic: true }); this.matter.add.rectangle(this.worldWidth + 25, this.worldHeight / 2, 50, this.worldHeight, { isStatic: true }); // Add a repeating background to visualize the larger world this.background = this.add.tileSprite(0, 0, this.worldWidth, this.worldHeight, 'background') .setOrigin(0) .setDepth(0) .setScrollFactor(0); // Create score display this.scoreText = this.add.text(20, 20, 'scOre: 0', { fontFamily: 'Arial', fontSize: '24px', color: '#ffffff' }).setOrigin(0, 0.5).setScrollFactor(0).setDepth(100); // Create level display this.levelText = this.add.text(this.scale.width - 20, 20, 'level: 1', { fontFamily: 'Arial', fontSize: '24px', color: '#ffffff' }).setOrigin(1, 0.5).setScrollFactor(0).setDepth(100); // Create crystal counter this.crystalText = this.add.text(this.scale.width / 2, 60, 'crystals: 0', { fontFamily: 'Arial', fontSize: '24px', color: '#00ffff' }).setOrigin(0.5, 0.5).setScrollFactor(0).setDepth(100); // Create energy bar background this.energyBarWidth = this.scale.width / 2; // Half screen width this.energyBarHeight = 4; // Thin bar this.energyBarBackground = this.add.rectangle( this.scale.width / 2, 45, this.energyBarWidth, this.energyBarHeight, 0x333333 ).setScrollFactor(0).setDepth(100); // Create energy bar this.energyBar = this.add.rectangle( this.scale.width / 2, 45, this.energyBarWidth, this.energyBarHeight, 0x00ff00 ).setScrollFactor(0).setDepth(100); // Set the origin to left for proper scaling this.energyBarBackground.setOrigin(0.5, 0.5); this.energyBar.setOrigin(0.5, 0.5); // Store the original x position as the center point this.energyBarCenterX = this.energyBar.x; // Add the spaceship to the center of the game world // Create a custom polygon shape for the spaceship const spaceshipScale = 0.125; // 1/8 of the original size const spaceshipVertices = [{ x: 7 / spaceshipScale, y: -35 / spaceshipScale }, { x: 49 / spaceshipScale, y: 5 / spaceshipScale }, { x: 4 / spaceshipScale, y: 37 / spaceshipScale }, { x: -47 / spaceshipScale, y: 7 / spaceshipScale }]; this.spaceship = this.matter.add.image(360 * 2.5, 640 * 1.5, 'spaceship', null, { shape: { type: 'fromVerts', verts: spaceshipVertices, flagInternal: true }, label: 'spaceship' }); this.spaceship.setScale(spaceshipScale); this.spaceship.setDepth(1); this.spaceship.setFixedRotation(); // Prevent rotation from collisions this.spaceship.setFrictionAir(0.001); // Set very low air friction this.spaceship.setBounce(0.8); // Set bounce to match the world bounds collision this.spaceship.setMass(1); // Set a low mass for better responsiveness this.spaceship.setFriction(0); // Remove surface friction // Function to create a large asteroid // Create shared categories for asteroids and projectiles this.asteroidCategory = this.matter.world.nextCategory(); this.projectileCategory = this.matter.world.nextCategory(); this.energyParticleCategory = this.matter.world.nextCategory(); const createAsteroid = (x, y, size) => { console.log(`Creating ${size} asteroid at:`, x, y); const visualAsteroidScale = size === 'large' ? 0.5 : 0.5; // Doubled from 0.25 to 0.5 const physicsAsteroidScale = size === 'large' ? 1.0 : 1.0; // Doubled from 0.5 to 1.0 const asteroidTexture = size === 'large' ? 'largeAsteroid' : 'mediumAsteroid'; const rubbleTexture = size === 'large' ? 'largeRubble' : 'mediumRubble'; const asteroidRadius = this.textures.get(asteroidTexture).getSourceImage().width / 2; const asteroid = this.matter.add.image(x, y, asteroidTexture, null, { shape: { type: 'circle', radius: asteroidRadius * physicsAsteroidScale }, label: 'asteroid' }); asteroid.size = size; asteroid.rubbleTexture = rubbleTexture; if (!asteroid || !asteroid.body) { console.error('Failed to create asteroid body'); return null; } asteroid.setScale(visualAsteroidScale); asteroid.setDepth(1); asteroid.setDensity(0.001); asteroid.setFrictionAir(0.0001); asteroid.setBounce(0.8); asteroid.setVelocity(Phaser.Math.Between(-2, 2), Phaser.Math.Between(-2, 2)); asteroid.setAngularVelocity(Phaser.Math.Between(-0.05, 0.05)); if (!asteroid.body) { console.warn('Asteroid body not created properly'); return null; } // Use the shared asteroid category asteroid.setCollisionCategory(this.asteroidCategory); asteroid.setCollidesWith([this.asteroidCategory, this.projectileCategory, 0x0001, 0x0002]); // Collide with other asteroids, projectiles, default category, and world bounds category // Debug log console.log('Asteroid collision category:', this.asteroidCategory); // Add health property to the asteroid asteroid.health = 100; // Add method to change sprite asteroid.changeToRubble = function() { // Store the current body properties const currentRadius = this.body.circleRadius; const currentPosition = { x: this.x, y: this.y }; const currentVelocity = { x: this.body.velocity.x, y: this.body.velocity.y }; const currentAngularVelocity = this.body.angularVelocity; // Change the texture this.setTexture(this.rubbleTexture); // Adjust the scale to fit the new texture within the same hitbox const asteroidWidth = this.scene.textures.get(this.size === 'large' ? 'largeAsteroid' : 'mediumAsteroid').getSourceImage().width; const rubbleWidth = this.scene.textures.get(this.rubbleTexture).getSourceImage().width; const newScale = (asteroidWidth / rubbleWidth) * this.scaleX; this.setScale(newScale); // Remove the doubling for medium rubble // Maintain the exact same circular body this.setCircle(currentRadius); // Restore the original position, velocity, and angular velocity this.setPosition(currentPosition.x, currentPosition.y); this.setVelocity(currentVelocity.x, currentVelocity.y); this.setAngularVelocity(currentAngularVelocity); // Preserve collision properties this.setCollisionCategory(this.scene.asteroidCategory); this.setCollidesWith([this.scene.asteroidCategory, this.scene.projectileCategory, 0x0001, 0x0002]); // Ensure the Matter.js body is updated this.scene.matter.body.set(this.body, 'label', 'asteroid'); }; // Create health bar const healthBarWidth = asteroid.width * visualAsteroidScale * 0.25; // Consistent 1/4 width for both sizes const healthBarHeight = 1; // Consistent height for both sizes const healthBar = this.add.rectangle(0, 0, healthBarWidth, healthBarHeight, 0x00ff00); healthBar.setOrigin(0.5, 0.5); healthBar.setDepth(2); // Function to update health bar const updateHealthBar = () => { const currentHealthBar = asteroid.getData('healthBar'); if (currentHealthBar && !asteroid.isBeingDestroyed) { const healthPercentage = asteroid.health / 100; currentHealthBar.width = healthBarWidth * healthPercentage; currentHealthBar.fillColor = (healthPercentage > 0.5) ? 0x00ff00 : (healthPercentage > 0.25 ? 0xffff00 : 0xff0000); } }; // Add update health bar function to asteroid asteroid.updateHealthBar = updateHealthBar; // Initial health bar update updateHealthBar(); // Make health bar follow asteroid asteroid.setDataEnabled(); asteroid.setData('healthBar', healthBar); this.events.on('update', () => { const currentHealthBar = asteroid.getData('healthBar'); if (currentHealthBar && !asteroid.isBeingDestroyed) { currentHealthBar.setPosition(asteroid.x, asteroid.y); } }); return asteroid; }; // Create asteroids this.asteroids = []; const numAsteroids = 20; // Initial number of asteroids (10 large + 10 medium) const largeAsteroidRadius = this.textures.get('largeAsteroid').getSourceImage().width / 2 * 0.5; const mediumAsteroidRadius = this.textures.get('mediumAsteroid').getSourceImage().width / 2 * 0.25; const margin = Math.max(largeAsteroidRadius * 2, mediumAsteroidRadius * 2, 50); for (let i = 0; i < numAsteroids; i++) { const x = Phaser.Math.Between(margin, this.worldWidth - margin); const y = Phaser.Math.Between(margin, this.worldHeight - margin); const size = i < 10 ? 'large' : 'medium'; // Create 10 large and 10 medium asteroids console.log(`Attempting to create ${size} asteroid at: (${x}, ${y})`); const asteroid = createAsteroid(x, y, size); if (asteroid) { this.asteroids.push(asteroid); console.log(`${size.charAt(0).toUpperCase() + size.slice(1)} asteroid created and added at: (${asteroid.x}, ${asteroid.y})`); } else { console.error(`Failed to create ${size} asteroid`); } } console.log(`Total asteroids spawned: ${this.asteroids.length}`); console.log('World dimensions:', this.worldWidth, this.worldHeight); this.asteroids.forEach((asteroid, index) => { console.log(`Asteroid ${index + 1} position:`, asteroid.x, asteroid.y); }); // Create the Boss with a custom polygon hitbox const bossWidth = 600; const bossHeight = 816; const bossScale = 0.35; const scaledWidth = bossWidth * bossScale; const scaledHeight = bossHeight * bossScale; // Define the polygon points for the boss hitbox const bossPoints = [{ x: 152, y: 62 }, { x: 84, y: 140 }, { x: 35, y: 191 }, { x: 3, y: 203 }, { x: -30, y: 189 }, { x: -79, y: 156 }, { x: -127, y: 98 }, { x: -151, y: 27 }, { x: -148, y: -59 }, { x: -105, y: -141 }, { x: -60, y: -129 }, { x: 19, y: -210 }, { x: 65, y: -126 }, { x: 100, y: -133 }, { x: 132, y: -86 }, { x: 154, y: -1 }]; // Scale the points to match the boss scale and increase size by 56.25% (25% increase on top of the previous 25%) const hitboxScaleFactor = 1.875; // 87.5% increase (20% larger than before) const scaledPoints = bossPoints.map(point => ({ x: point.x * bossScale * hitboxScaleFactor, y: point.y * bossScale * hitboxScaleFactor })); // Create the boss sprite this.boss = this.add.image(0, 0, 'boss'); this.boss.setScale(bossScale); this.boss.baseScale = bossScale; // Store the base scale for reference this.bossIsAlive = false; // Add flag to track boss alive state // Create boss health bar background this.bossHealthBarWidth = 100; this.bossHealthBarHeight = 10; this.bossHealthBarBackground = this.add.rectangle(0, 0, this.bossHealthBarWidth, this.bossHealthBarHeight, 0x222222); this.bossHealthBar = this.add.rectangle(0, 0, this.bossHealthBarWidth, this.bossHealthBarHeight, 0x444444); // Set the origin of health bars this.bossHealthBarBackground.setOrigin(0.5, 0.5); this.bossHealthBar.setOrigin(0.5, 0.5); // Create a container for the boss including the health bars this.bossContainer = this.add.container(this.worldWidth / 2, this.worldHeight / 2, [ this.boss, this.bossHealthBarBackground, this.bossHealthBar ]); this.bossContainer.setSize(scaledWidth * hitboxScaleFactor, scaledHeight * hitboxScaleFactor); // Add the container to the physics world with the custom polygon shape this.matter.add.gameObject(this.bossContainer, { shape: { type: 'fromVerts', verts: scaledPoints, flagInternal: true }, label: 'boss' // Add a label to identify the boss body }); // Set boss properties this.bossContainer.setFrictionAir(0); this.bossContainer.setBounce(1); // Create collision category for the boss this.bossCategory = this.matter.world.nextCategory(); // Apply collision category to the boss's body specifically if (this.bossContainer.body) { this.bossContainer.body.collisionFilter.category = this.bossCategory; this.bossContainer.body.collisionFilter.mask = this.asteroidCategory | this.projectileCategory | this.energyParticleCategory | 0x0001; // Remove world bounds collision category (0x0002) this.bossContainer.body.label = 'boss'; this.bossContainer.body.isSensor = true; // Make the boss a sensor for projectiles } // Ensure asteroids can collide with the boss this.asteroids.forEach(asteroid => { const currentCollidesWith = asteroid.body.collisionFilter.mask; asteroid.setCollidesWith([this.asteroidCategory, this.projectileCategory, this.bossCategory, 0x0001, 0x0002]); }); console.log('Boss created at:', this.bossContainer.x, this.bossContainer.y); console.log('Boss collision category:', this.bossCategory); // Adjust the boss's position to center it based on the new hitbox const bounds = this.bossContainer.getBounds(); const newScaledWidth = scaledWidth * hitboxScaleFactor; const newScaledHeight = scaledHeight * hitboxScaleFactor; const centerX = 0; const centerY = 0; this.boss.setPosition(centerX, centerY); // Set up Matter.js collision event this.matter.world.on('collisionstart', (event) => { event.pairs.forEach((pair) => { const { bodyA, bodyB } = pair; if (!bodyA || !bodyB) { console.warn('Invalid collision pair'); return; } // Check for boss-asteroid collision first const isBossBody = (body) => body.label === 'boss'; const asteroidBody = bodyA.label === 'asteroid' ? bodyA : (bodyB.label === 'asteroid' ? bodyB : null); if ((isBossBody(bodyA) || isBossBody(bodyB)) && asteroidBody) { const asteroid = this.asteroids.find(a => a.body === asteroidBody); if (asteroid) { this.handleBossAsteroidCollision(isBossBody(bodyA) ? bodyA : bodyB, asteroid); return; } } // Check for boss-player collision when boss is alive if (this.bossIsAlive && ((bodyA.label === 'boss' && bodyB.label === 'spaceship') || (bodyA.label === 'spaceship' && bodyB.label === 'boss'))) { this.handlePlayerDeath(); return; } // Add boss energy particle collection detection const isEnergyParticle = (body) => body.label === 'energyParticle'; // Check for boss-energy particle collision if ((isBossBody(bodyA) && isEnergyParticle(bodyB)) || (isBossBody(bodyB) && isEnergyParticle(bodyA))) { console.log('Boss collision detected with energy particle!'); console.log('BodyA:', bodyA.label); console.log('BodyB:', bodyB.label); const particleBody = isEnergyParticle(bodyA) ? bodyA : bodyB; this.handleBossEnergyParticleCollection(particleBody); return; } console.log('Collision detected between:', bodyA.label, 'and', bodyB.label); console.log('BodyA category:', bodyA.collisionFilter.category); console.log('BodyB category:', bodyB.collisionFilter.category); // Handle energy particle collisions with spaceship if ((bodyA.label === 'energyParticle' && bodyB.label === 'spaceship') || (bodyB.label === 'energyParticle' && bodyA.label === 'spaceship')) { const particleBody = bodyA.label === 'energyParticle' ? bodyA : bodyB; this.handleEnergyParticleCollection(particleBody); return; } // Handle energy particle collisions with world bounds if ((bodyA.label === 'energyParticle' && bodyB.isStatic) || (bodyB.label === 'energyParticle' && bodyA.isStatic)) { const particleBody = bodyA.label === 'energyParticle' ? bodyA : bodyB; this.handleEnergyParticleWorldBoundsCollision(particleBody); return; } // Handle energy particle collisions with asteroids if (bodyA.label === 'energyParticle' || bodyB.label === 'energyParticle') { const energyParticleBody = bodyA.label === 'energyParticle' ? bodyA : bodyB; const otherBody = bodyA.label === 'energyParticle' ? bodyB : bodyA; const asteroid = this.asteroids.find(a => a.body === otherBody); if (asteroid) { this.handleEnergyParticleAsteroidCollision(energyParticleBody, asteroid); } return; } // Check for world bounds collision if (bodyA.isStatic || bodyB.isStatic) { this.handleWorldBoundsCollision(pair); return; } // Check for boss collisions with projectiles const projectile = this.projectiles.getChildren().find(p => p.body === bodyA || p.body === bodyB); const isBossCollision = (bodyA?.label === 'boss' || bodyB?.label === 'boss'); if (isBossCollision && projectile) { this.handleBossProjectileCollision(projectile); return; } else if (isBossCollision) { this.handleBossCollisions(pair); return; } const asteroidBodyA = this.asteroids.find(a => a.body === bodyA); const asteroidBodyB = this.asteroids.find(a => a.body === bodyB); if (projectile && (asteroidBodyA || asteroidBodyB)) { console.log('Projectile-Asteroid collision detected!'); this.handleProjectileAsteroidCollision(projectile, asteroidBodyA || asteroidBodyB); } else if (bodyA === this.spaceship.body || bodyB === this.spaceship.body) { const otherBody = bodyA === this.spaceship.body ? bodyB : bodyA; const asteroid = this.asteroids.find(a => a.body === otherBody); if (asteroid) { // Check if it's a metal or energy asteroid if (asteroid.texture.key === 'smallAsteroid3') { // MetalRock1 this.score += 25; this.sound.play('metalCollectSound', { volume: 0.5 }); asteroid.destroy(); const index = this.asteroids.indexOf(asteroid); if (index > -1) { this.asteroids.splice(index, 1); } } else if (asteroid.texture.key === 'smallAsteroid4') { // MetalRock2 this.score += 50; this.sound.play('metalCollectSound', { volume: 0.5 }); asteroid.destroy(); const index = this.asteroids.indexOf(asteroid); if (index > -1) { this.asteroids.splice(index, 1); } } else if (asteroid.texture.key === 'smallAsteroid1') { // EnergyRock1 this.crystals -= 1; this.sound.play('collectSound', { volume: 0.5 }); asteroid.destroy(); const index = this.asteroids.indexOf(asteroid); if (index > -1) { this.asteroids.splice(index, 1); } // Check if player has completed the level if (this.crystals === 0) { this.handleLevelUp(); } } else if (asteroid.texture.key === 'smallAsteroid2') { // EnergyRock2 this.crystals -= 1; this.sound.play('collectSound', { volume: 0.5 }); asteroid.destroy(); const index = this.asteroids.indexOf(asteroid); if (index > -1) { this.asteroids.splice(index, 1); } // Check if player has completed the level if (this.crystals === 0) { this.handleLevelUp(); } } else { this.handleCollision(this.spaceship.body, asteroid.body); } } } else if (asteroidBodyA && asteroidBodyB) { this.handleAsteroidCollision(asteroidBodyA, asteroidBodyB); } }); }); // Set up collision with world bounds this.matter.world.setBounds(0, 0, this.worldWidth, this.worldHeight, 32, true, true, true, true); // Initial velocity and rotation are now set in the createLargeAsteroid function // Set up camera to follow the spaceship this.cameras.main.setBounds(0, 0, this.worldWidth, this.worldHeight); this.cameras.main.startFollow(this.spaceship, true, 0.09, 0.09); // Add the virtual joystick this.joystick = this.add.image(160, 1120, 'joystick'); this.joystick.setScrollFactor(0); // Fix the joystick to the camera this.joystick.setScale(0.4); // Set to 2/5 of the original size this.joystick.setAlpha(1); // Make it fully opaque this.joystick.setDepth(2); // Ensure it's above other elements this.joystick.setInteractive(); this.joystickCenter = { x: 160, y: 1120 }; this.joystickVector = { x: 0, y: 0 }; this.joystickPointer = null; this.input.addPointer(3); // Increase the number of pointers to 4 (1 default + 3 additional) this.input.on('pointerdown', (pointer) => { if (Phaser.Geom.Circle.Contains( new Phaser.Geom.Circle(this.joystickCenter.x, this.joystickCenter.y, this.joystick.displayWidth / 2), pointer.x, pointer.y ) && !this.joystickPointer) { this.joystickPointer = pointer; this.updateJoystick(pointer); } }); this.input.on('pointermove', (pointer) => { if (pointer.id === this.joystickPointer?.id) { this.updateJoystick(pointer); } }); this.input.on('pointerup', (pointer) => { if (pointer.id === this.joystickPointer?.id) { this.joystickPointer = null; this.joystick.x = this.joystickCenter.x; this.joystick.y = this.joystickCenter.y; this.joystickVector = { x: 0, y: 0 }; } }); // Add updateJoystick method this.updateJoystick = (pointer) => { let dx = pointer.x - this.joystickCenter.x; let dy = pointer.y - this.joystickCenter.y; let distance = Math.sqrt(dx * dx + dy * dy); if (distance > 10) { let angle = Math.atan2(dy, dx); dx = Math.cos(angle) * 10; dy = Math.sin(angle) * 10; } this.joystick.x = this.joystickCenter.x + dx; this.joystick.y = this.joystickCenter.y + dy; this.joystickVector.x = dx / 10; this.joystickVector.y = dy / 10; }; // Add the throttle button this.throttle = this.add.image(600, 1120, 'throttle'); this.throttle.setScrollFactor(0); // Fix the throttle to the camera this.throttle.setScale(0.4); // Doubled from 0.2 to 0.4 this.throttle.setAngle(180); // Rotate the throttle button 180 degrees this.throttle.setInteractive(new Phaser.Geom.Circle(this.throttle.width / 2, this.throttle.height / 2, this.throttle.width / 2), Phaser.Geom.Circle.Contains); this.throttle.setDepth(2); // Ensure it's above other elements // Add interaction for the throttle button this.throttlePointer = null; this.throttle.on('pointerdown', (pointer) => { this.throttlePointer = pointer; this.isThrottling = true; }); this.throttle.on('pointerup', (pointer) => { if (pointer.id === this.throttlePointer?.id) { this.throttlePointer = null; this.isThrottling = false; } }); this.throttle.on('pointerout', (pointer) => { if (pointer.id === this.throttlePointer?.id) { this.throttlePointer = null; this.isThrottling = false; } }); // Add the fire button this.fireButton = this.add.image(440, 1120, 'fireButton'); this.fireButton.setScrollFactor(0); // Fix the fire button to the camera this.fireButton.setScale(0.4); // Doubled from 0.2 to 0.4 this.fireButton.setInteractive(new Phaser.Geom.Circle(this.fireButton.width / 2, this.fireButton.height / 2, this.fireButton.width / 2), Phaser.Geom.Circle.Contains); this.fireButton.setDepth(2); // Ensure it's above other elements // Add interaction for the fire button this.firePointer = null; this.fireButton.on('pointerdown', (pointer) => { this.firePointer = pointer; this.isFiring = true; }); this.fireButton.on('pointerup', (pointer) => { if (pointer.id === this.firePointer?.id) { this.firePointer = null; this.isFiring = false; } }); this.fireButton.on('pointerout', (pointer) => { if (pointer.id === this.firePointer?.id) { this.firePointer = null; this.isFiring = false; } }); // Create particle emitter for rocket effect this.rocketParticles = this.add.particles('fireButton'); // Using fireButton as particle texture this.rocketEmitter = this.rocketParticles.createEmitter({ speed: 100, scale: { start: 0.05, end: 0.01 }, alpha: { start: 1, end: 0 }, tint: { start: 0xffff00, end: 0xff0000 }, blendMode: 'ADD', lifespan: 200, on: false // Start with the emitter off }); // Calculate the offset for the emitter based on the scaled size of the spaceship this.emitterOffsetY = this.spaceship.displayHeight * 0.6; // Slightly increased to ensure it's at the back // Move the particle system to the foreground this.rocketParticles.setDepth(3); // Set depth higher than the spaceship (which is at depth 1) // Initial position and angle will be set in the update method // Create particle emitter for projectiles this.projectileParticles = this.add.particles('fireButton'); // Using fireButton as particle texture this.projectileEmitter = this.projectileParticles.createEmitter({ speed: 750, // Increased from 500 to 750 (50% faster) scale: { start: 0.05, end: 0.05 }, // Changed from 0.1 to 0.05 (half the size) alpha: { start: 1, end: 1 }, tint: 0xff0000, // Red color blendMode: 'ADD', lifespan: 10000, // Increased lifespan on: false, collideTop: false, collideBottom: false, collideLeft: false, collideRight: false, gravityY: 0 // Explicitly set gravity to 0 }); this.projectileParticles.setDepth(4); // Create a group for projectiles this.projectiles = this.add.group(); this.projectileParticles.setDepth(4); // Variables for controlling fire rate this.lastFiredTime = 0; this.fireRate = 250; // 1/4 second in milliseconds // Add rocket sound this.rocketSound = this.sound.add('rocketSound'); this.rocketSound.setLoop(true); // Add laser sound this.laserSound = this.sound.add('laserSound'); this.laserSound.setVolume(0.25); // Set volume to 25% (half of the previous 50%) // Add and play background music this.backgroundMusic = this.sound.add('backgroundMusic', { loop: true }); this.backgroundMusic.play(); this.backgroundMusic.setVolume(0.5); // Set to half volume, adjust as needed // Add explosion sound this.explosionSound = this.sound.add('explosionSound'); this.explosionSound.setVolume(0.5); // Set to half volume } // Removed createHitboxEditor, updateHitboxShape, and logHitboxCoordinates methods drawDebugGraphics() { // Create debug graphics this.debugGraphics = this.add.graphics(); this.debugGraphics.setScrollFactor(0); this.debugGraphics.setDepth(1000); // Ensure it's drawn on top // Function to draw debug circles const drawDebugCircle = (x, y, radius) => { this.debugGraphics.lineStyle(2, 0x00ff00, 1); this.debugGraphics.strokeCircle(x, y, radius); }; // Draw debug circles for joystick, throttle, and fire button drawDebugCircle(this.joystick.x, this.joystick.y, this.joystick.displayWidth / 2); drawDebugCircle(this.throttle.x, this.throttle.y, this.throttle.displayWidth / 2); drawDebugCircle(this.fireButton.x, this.fireButton.y, this.fireButton.displayWidth / 2); } update() { // Debug: Force boss to stay in center if anchored if (this.debugBossAnchored && this.bossContainer) { this.bossContainer.setPosition(this.worldWidth / 2, this.worldHeight / 2); } // Boss movement and attacks if (this.bossIsAlive && this.bossContainer && this.spaceship) { // Calculate direction to player const dx = this.spaceship.x - this.bossContainer.x; const dy = this.spaceship.y - this.bossContainer.y; const distance = Math.sqrt(dx * dx + dy * dy); // Normalize direction const normalizedDx = dx / distance; const normalizedDy = dy / distance; // Check if it's time for a surge attack if (this.time.now >= this.bossNextSurgeTime) { this.startBossSurge(); } // Apply movement based on current state const currentSpeed = this.bossIsSurging ? this.bossSurgeSpeed : this.bossSpeed; const force = { x: normalizedDx * currentSpeed * 0.0001, y: normalizedDy * currentSpeed * 0.0001 }; this.matter.body.applyForce(this.bossContainer.body, this.bossContainer.body.position, force); // End surge if quarter second has elapsed if (this.bossIsSurging && this.time.now - this.bossSurgeStartTime >= this.bossSurgeDuration) { this.endBossSurge(); } } // Update boss scale based on health unless already alive if (!this.bossIsAlive) { const healthScale = (this.bossHealth / 100); const minScale = 0.1; // Minimum 10% of original size const currentScale = minScale + (this.boss.baseScale - minScale) * healthScale; // Play warning sound when health reaches 50% if (!this.warningPlayed && this.bossHealth >= 50) { this.sound.play('bossWarning', { volume: 1.0 }); this.warningPlayed = true; } // Scale the boss sprite this.boss.setScale(currentScale); // Scale the container and hitbox const hitboxScale = currentScale / this.boss.baseScale; this.bossContainer.setScale(hitboxScale); // Check if boss has reached full health if (this.bossHealth >= 100) { this.bossIsAlive = true; console.log('Boss is now alive!'); // Reset to full scale this.boss.setScale(this.boss.baseScale); this.bossContainer.setScale(1); // Play awakening sound this.sound.play('bossAwakened', { volume: 1.0 }); } } // Update score, crystal, and level displays this.scoreText.setText(`scOre: ${this.score}`); this.crystalText.setText(`crystals: ${this.crystals}`); this.levelText.setText(`level: ${this.level}`); // Find and update all energy particles const bodies = this.matter.world.localWorld.bodies; bodies.forEach(body => { if (body.label === 'energyParticle' && body.gameObject) { // Calculate direction to boss const directionX = this.bossContainer.x - body.position.x; const directionY = this.bossContainer.y - body.position.y; // Normalize the direction const length = Math.sqrt(directionX * directionX + directionY * directionY); const normalizedX = directionX / length; const normalizedY = directionY / length; // Apply a very gentle constant force towards the boss const baseAttractionStrength = 0.000001; const levelMultiplier = 1 + (0.10 * (this.level - 1)); // 10% increase per level const attractionStrength = baseAttractionStrength * levelMultiplier; this.matter.body.applyForce(body, body.position, { x: normalizedX * attractionStrength, y: normalizedY * attractionStrength }); } }); // Update energy bar and check zero energy condition const energyPercent = this.energy / 1000; this.energyBar.width = this.energyBarWidth * energyPercent; // Keep the energy bar centered as it shrinks this.energyBar.x = this.energyBarCenterX; // Handle zero energy tracking if (this.energy === 0) { if (this.zeroEnergyStartTime === null) { // Energy just hit zero, start tracking this.zeroEnergyStartTime = this.time.now; this.outOfEnergyText.setVisible(true); } else if (this.time.now - this.zeroEnergyStartTime >= 10000) { // Energy has been zero for 10 seconds this.handlePlayerDeath(); } else { // Flash the warning text while energy is zero this.outOfEnergyText.setVisible(Math.floor((this.time.now / 250) % 2) === 0); } } else { // Reset the zero energy timer if energy is above zero this.zeroEnergyStartTime = null; this.outOfEnergyText.setVisible(false); } // Update energy bar color if (energyPercent > 0.5) { // Green to Yellow (from 100% to 50%) const greenToYellow = Phaser.Display.Color.Interpolate.ColorWithColor( new Phaser.Display.Color(0, 255, 0), new Phaser.Display.Color(255, 255, 0), 1, (1 - energyPercent) * 2 ); this.energyBar.setFillStyle(Phaser.Display.Color.GetColor(greenToYellow.r, greenToYellow.g, greenToYellow.b)); } else { // Yellow to Red (from 50% to 0%) const yellowToRed = Phaser.Display.Color.Interpolate.ColorWithColor( new Phaser.Display.Color(255, 255, 0), new Phaser.Display.Color(255, 0, 0), 1, (0.5 - energyPercent) * 2 ); this.energyBar.setFillStyle(Phaser.Display.Color.GetColor(yellowToRed.r, yellowToRed.g, yellowToRed.b)); } // Rotate the spaceship to face the direction of the joystick if (this.joystickVector.x !== 0 || this.joystickVector.y !== 0) { const angle = Math.atan2(this.joystickVector.y, this.joystickVector.x); this.spaceship.setRotation(angle + Math.PI / 2); // Add PI/2 because the sprite is facing up } // Removed hitbox editor update code // Apply acceleration when throttle is pressed if (this.isThrottling && this.energy > 0) { // Deplete energy while using thrusters this.energy = Math.max(0, this.energy - 0.5); const force = 0.0005; // Adjust this value to change acceleration speed const forceX = Math.cos(this.spaceship.rotation - Math.PI / 2) * force; const forceY = Math.sin(this.spaceship.rotation - Math.PI / 2) * force; this.matter.body.applyForce(this.spaceship.body, this.spaceship.body.position, { x: forceX, y: forceY }); // Activate rocket particle effect this.rocketEmitter.on = true; // Play rocket sound if not already playing if (!this.rocketSound.isPlaying) { this.rocketSound.play(); } // Calculate the emitter's position relative to the spaceship (at the back center) const angleRad = this.spaceship.rotation - Math.PI / 2; // Point to the back of the spaceship const emitterX = this.spaceship.x - Math.cos(angleRad) * (this.emitterOffsetY - 18) - Math.sin(angleRad) * 5; const emitterY = this.spaceship.y - Math.sin(angleRad) * (this.emitterOffsetY - 18) + Math.cos(angleRad) * 5; // Update the emitter's position and angle this.rocketEmitter.setPosition(emitterX, emitterY); this.rocketEmitter.setAngle(Phaser.Math.RadToDeg(this.spaceship.rotation) + 90); } else { // Deactivate rocket particle effect this.rocketEmitter.on = false; // Stop rocket sound this.rocketSound.stop(); } // Apply drag to slow down the spaceship when not accelerating // Removed drag application for the spaceship // Handle projectile firing if (this.isFiring) { const currentTime = this.time.now; if (currentTime - this.lastFiredTime >= this.fireRate) { this.fireProjectile(); this.lastFiredTime = currentTime; } } // Removed drag application for the spaceship // Destroy projectiles that leave the world bounds this.projectiles.getChildren().forEach((projectile) => { const worldBounds = this.matter.world.bounds; const maxX = worldBounds && worldBounds.max ? worldBounds.max.x : this.matter.world.width; const maxY = worldBounds && worldBounds.max ? worldBounds.max.y : this.matter.world.height; if (projectile.x < 0 || projectile.x > maxX || projectile.y < 0 || projectile.y > maxY) { projectile.destroy(); this.projectiles.remove(projectile); } }); // Update asteroid positions this.asteroids.forEach(asteroid => { if (asteroid.x < 0) asteroid.x = this.matter.world.width; if (asteroid.x > this.matter.world.width) asteroid.x = 0; if (asteroid.y < 0) asteroid.y = this.matter.world.height; if (asteroid.y > this.matter.world.height) asteroid.y = 0; }); // Update background parallax if (this.spaceship && this.background) { // Calculate how much to scroll the background (1/4 of player movement) const parallaxFactor = 0.25; this.background.tilePositionX = this.spaceship.x * -parallaxFactor; this.background.tilePositionY = this.spaceship.y * -parallaxFactor; } } fireProjectile() { // Check if we have enough energy to fire if (this.energy < 10) { return; // Not enough energy to fire } // Consume energy for firing this.energy = Math.max(0, this.energy - 10); // Calculate the projectile's starting position (front of the spaceship) const angleRad = this.spaceship.rotation - Math.PI / 2; const offsetDistance = this.spaceship.displayHeight * 0.6; const projectileX = this.spaceship.x + Math.cos(angleRad) * offsetDistance; const projectileY = this.spaceship.y + Math.sin(angleRad) * offsetDistance; // Create a Matter.js projectile const projectile = this.matter.add.image(projectileX, projectileY, 'fireButton', null, { isSensor: true, // Changed to true so it doesn't cause physical reactions isStatic: false, friction: 0, frictionAir: 0, frictionStatic: 0, restitution: 0, density: 0.001, ignoreGravity: true, label: 'projectile' // Add label for better collision detection }); projectile.setScale(0.05); projectile.setTint(0xff0000); projectile.setDepth(4); // Set a smaller circular hitbox const hitboxRadius = projectile.width * projectile.scale * 0.25; // Reduced to 1/4 of the current size projectile.setCircle(hitboxRadius); const speed = 15; this.matter.body.setVelocity(projectile.body, { x: Math.cos(angleRad) * speed, y: Math.sin(angleRad) * speed }); // Set collision category for the projectile projectile.setCollisionCategory(this.projectileCategory); // Make sure the projectile collides with asteroids and boss only projectile.setCollidesWith([this.asteroidCategory, this.bossCategory]); // Debug log console.log('Projectile fired:', projectile); console.log('Projectile collision category:', this.projectileCategory); console.log('Projectile collides with:', this.asteroidCategory, 0x0002); // Add the projectile to the projectiles group this.projectiles.add(projectile); // Set a timer to destroy the projectile after it leaves the world bounds this.time.delayedCall(10000, () => { if (projectile.active) { projectile.destroy(); } }); // Play laser sound this.laserSound.play(); } handleCollision(spaceshipBody, asteroidBody) { if (!spaceshipBody || !asteroidBody) { console.warn('Invalid bodies in collision'); return; } const spaceship = this.spaceship; const asteroid = this.asteroids.find(a => a.body === asteroidBody); // Calculate relative velocity const relativeVelocity = { x: spaceship.body.velocity.x - asteroid.body.velocity.x, y: spaceship.body.velocity.y - asteroid.body.velocity.y }; // Calculate collision normal const collisionNormal = { x: asteroid.x - spaceship.x, y: asteroid.y - spaceship.y }; const magnitude = Math.sqrt(collisionNormal.x ** 2 + collisionNormal.y ** 2); collisionNormal.x /= magnitude; collisionNormal.y /= magnitude; // Calculate impulse scalar (increased for more bounce) const impulseScalar = 1.0 * (relativeVelocity.x * collisionNormal.x + relativeVelocity.y * collisionNormal.y); // Apply impulse to both bodies const impulse = { x: impulseScalar * collisionNormal.x, y: impulseScalar * collisionNormal.y }; // Calculate rebound velocity for spaceship (increased rebound factor) const reboundFactor = 1.0; const spaceshipReboundVelocity = { x: spaceship.body.velocity.x - impulse.x * reboundFactor, y: spaceship.body.velocity.y - impulse.y * reboundFactor }; // Apply rebound velocity to spaceship if (spaceship && spaceship.body && this.matter.body) { this.matter.body.setVelocity(spaceship.body, spaceshipReboundVelocity); } // Apply impulse to asteroid (slightly reduced effect) if (asteroid && asteroid.body && this.matter.body) { this.matter.body.setVelocity(asteroid.body, { x: asteroid.body.velocity.x + impulse.x * 0.5, y: asteroid.body.velocity.y + impulse.y * 0.5 }); } // Ensure the spaceship maintains its current rotation this.matter.body.setAngularVelocity(this.spaceship.body, 0); // Add a very small random rotation to the asteroid this.matter.body.setAngularVelocity(asteroid.body, asteroid.body.angularVelocity + Phaser.Math.Between(-0.005, 0.005)); } handleWorldBoundsCollision(pair) { const { bodyA, bodyB } = pair; const worldBody = bodyA.isStatic ? bodyA : bodyB; const objectBody = bodyA.isStatic ? bodyB : bodyA; if (!objectBody || !objectBody.gameObject || !objectBody.position || !objectBody.velocity) { console.warn('Invalid body in world bounds collision'); return; } const isSpaceship = objectBody === this.spaceship.body; const isAsteroid = objectBody.gameObject && objectBody.gameObject.texture && objectBody.gameObject.texture.key.includes('Asteroid'); const bounceCoefficient = isAsteroid ? 0.95 : 0.3; // Slight energy loss for asteroids // Calculate the collision normal const collisionNormal = { x: objectBody.position.x - worldBody.position.x, y: objectBody.position.y - worldBody.position.y }; const magnitude = Math.sqrt(collisionNormal.x ** 2 + collisionNormal.y ** 2); if (magnitude === 0) { console.warn('Zero magnitude collision normal'); return; } collisionNormal.x /= magnitude; collisionNormal.y /= magnitude; // Calculate the dot product of velocity and collision normal const dotProduct = objectBody.velocity.x * collisionNormal.x + objectBody.velocity.y * collisionNormal.y; // Calculate the new velocity const newVelocity = { x: objectBody.velocity.x - 2 * dotProduct * collisionNormal.x * bounceCoefficient, y: objectBody.velocity.y - 2 * dotProduct * collisionNormal.y * bounceCoefficient }; // Apply the new velocity this.matter.body.setVelocity(objectBody, newVelocity); // For the spaceship, ensure it maintains its current rotation if (isSpaceship) { this.matter.body.setAngularVelocity(objectBody, 0); } // For asteroids, add a small random rotation and reduce high angular velocities if (isAsteroid) { const currentAngularVelocity = objectBody.angularVelocity; const randomRotation = Phaser.Math.FloatBetween(-0.01, 0.01); const newAngularVelocity = currentAngularVelocity * 0.95 + randomRotation; // Reduce angular velocity if it's too high const maxAngularVelocity = 0.1; const finalAngularVelocity = Math.sign(newAngularVelocity) * Math.min(Math.abs(newAngularVelocity), maxAngularVelocity); this.matter.body.setAngularVelocity(objectBody, finalAngularVelocity); // Apply a small random velocity change to prevent getting stuck const randomVelocityChange = { x: Phaser.Math.FloatBetween(-0.5, 0.5), y: Phaser.Math.FloatBetween(-0.5, 0.5) }; objectBody.velocity.x += randomVelocityChange.x; objectBody.velocity.y += randomVelocityChange.y; } } handleProjectileAsteroidCollision(projectile, asteroid) { console.log('Handling projectile-asteroid collision'); console.log('Projectile:', projectile); console.log('Asteroid:', asteroid); // Check if projectile and asteroid are still valid if (!projectile || !projectile.body || !projectile.active || !asteroid || !asteroid.body || !asteroid.active || asteroid.isBeingDestroyed) { console.warn('Invalid, inactive, or destroying projectile or asteroid in collision'); return; } // Check if the colliding object is an asteroid or rubble and get spawn chance const asteroidTypes = { 'largeAsteroid': 0.25, // 25% chance 'largeRubble': 0.25, // 25% chance 'mediumAsteroid': 0.25, // 25% chance 'mediumRubble': 0.25, // 25% chance 'smallAsteroid1': 0.5, // 50% chance 'smallAsteroid2': 0.5, // 50% chance 'smallAsteroid3': 0.5, // 50% chance 'smallAsteroid4': 0.5 // 50% chance }; if (!asteroid.texture || !Object.keys(asteroidTypes).includes(asteroid.texture.key)) { console.warn('Collision detected with non-asteroid object'); return; } // Store asteroid position for later use const storedAsteroidPos = { x: asteroid.x, y: asteroid.y }; // Create a small explosion effect at the point of impact this.createExplosionEffect(projectile.x, projectile.y); // Random chance to spawn an energy particle based on asteroid type if (Phaser.Math.FloatBetween(0, 1) < asteroidTypes[asteroid.texture.key]) { // Create a game object rectangle for rendering const energyParticleGraphics = this.add.rectangle( projectile.x, projectile.y, 6, // width 6, // height 0xFFFFFF // white color ); // Add physics body to the rectangle const energyParticle = this.matter.add.gameObject(energyParticleGraphics, { friction: 0, frictionAir: 0, restitution: 0.8, density: 0.001, render: { fillStyle: '#FFFFFF' }, label: 'energyParticle', isStatic: false, isSensor: false }); // Set up collision properties correctly energyParticle.setCollisionCategory(this.energyParticleCategory); energyParticle.setCollidesWith([this.asteroidCategory, 0x0002, 0x0001, this.bossCategory]); // Add debug log for energy particle creation console.log('Energy particle created with collision categories:', { category: this.energyParticleCategory, collidesWith: [this.asteroidCategory, 0x0002, 0x0001, this.bossCategory], label: energyParticle.body.label }); energyParticle.setFixedRotation(); // Prevent rotation // Create a circular physics body for the energy particle const radius = 3; // Half of the width/height energyParticle.setCircle(radius); energyParticle.setFriction(0); energyParticle.setFrictionAir(0); energyParticle.setBounce(0.8); energyParticle.setDensity(0.001); energyParticle.body.label = 'energyParticle'; // Apply initial velocity const angle = Phaser.Math.FloatBetween(0, Math.PI * 2); const speed = 0.25; this.matter.body.setVelocity(energyParticle.body, { x: Math.cos(angle) * speed, y: Math.sin(angle) * speed }); // Set collision properties this.matter.body.setInertia(energyParticle, Infinity); // Prevent rotation // Give it a small random velocity // Speed was already set above, no need to set it again if (energyParticle && energyParticle.body) { this.matter.body.setVelocity(energyParticle.body, { x: Math.cos(angle) * speed, y: Math.sin(angle) * speed }); } // Create twinkling effect this.tweens.add({ targets: energyParticle, fillColor: { from: 0xFFFFFF, to: 0xFFFF00 }, // white to yellow duration: 500, yoyo: true, repeat: -1 }); // Store reference to graphics object energyParticle.graphicsObject = energyParticleGraphics; // Create twinkling effect this.tweens.add({ targets: energyParticleGraphics, fillColor: { from: 0xFFFFFF, to: 0xFFFF00 }, duration: 500, yoyo: true, repeat: -1 }); // Store reference to graphics object energyParticle.graphicsObject = energyParticleGraphics; } console.log('Projectile hit asteroid!'); console.log('Asteroid hit! Current asteroid position:', storedAsteroidPos.x, storedAsteroidPos.y); // Safely reduce asteroid health if (asteroid && typeof asteroid.health !== 'undefined') { asteroid.health -= 10; asteroid.health = Math.max(asteroid.health, 0); // Ensure health doesn't go below 0 console.log('Asteroid health:', asteroid.health); // If asteroid is destroyed if (asteroid.health <= 0) { // Set a flag to indicate the asteroid is being destroyed asteroid.isBeingDestroyed = true; // Create a larger explosion effect at the asteroid's position this.createExplosionEffect(storedAsteroidPos.x, storedAsteroidPos.y); // Remove the asteroid from the asteroids array const index = this.asteroids.indexOf(asteroid); if (index > -1) { this.asteroids.splice(index, 1); } // Destroy the health bar if it exists if (asteroid.getData && typeof asteroid.getData === 'function') { const healthBar = asteroid.getData('healthBar'); if (healthBar && typeof healthBar.destroy === 'function') { healthBar.destroy(); } } asteroid.setData('healthBar', null); // Clear the reference // Immediately remove the asteroid's body from the physics world if (asteroid.body) { this.matter.world.remove(asteroid.body); } // Determine the number of small asteroids to spawn based on the destroyed asteroid's size let smallAsteroidCount = 0; if (asteroid.texture.key === 'largeAsteroid' || asteroid.texture.key === 'largeRubble') { smallAsteroidCount = 5; } else if (asteroid.texture.key === 'mediumAsteroid' || asteroid.texture.key === 'mediumRubble') { smallAsteroidCount = 3; } // Spawn small asteroids if (smallAsteroidCount > 0) { this.spawnSmallAsteroids(storedAsteroidPos.x, storedAsteroidPos.y, smallAsteroidCount); } // Use a delayed call to destroy the asteroid this.time.delayedCall(10, () => { if (asteroid && !asteroid.destroyed) { asteroid.destroy(); } }); console.log('Asteroid scheduled for destruction'); } else if (!asteroid.isBeingDestroyed) { // Update the health bar only if the asteroid is not being destroyed if (asteroid.updateHealthBar && typeof asteroid.updateHealthBar === 'function') { asteroid.updateHealthBar(); } // Apply a small force to the asteroid only if it still exists and is active if (asteroid.body && asteroid.body.gameObject && asteroid.body.gameObject.active) { const force = 0.0005; const angle = Phaser.Math.Angle.Between(projectile.x, projectile.y, storedAsteroidPos.x, storedAsteroidPos.y); this.matter.body.applyForce(asteroid.body, storedAsteroidPos, { x: Math.cos(angle) * force, y: Math.sin(angle) * force }); } // Change sprite to rubble if health is 50 or less if (asteroid.health <= 50 && asteroid.texture.key !== asteroid.rubbleTexture && asteroid.changeToRubble && typeof asteroid.changeToRubble === 'function') { asteroid.changeToRubble(); } } } else { console.warn('Invalid asteroid object or health property'); } // Play explosion sound if (this.explosionSound && this.explosionSound.play && typeof this.explosionSound.play === 'function') { this.explosionSound.play(); } // Safely remove the projectile if (projectile && projectile.body) { // Immediately remove the projectile's body from the physics world this.matter.world.remove(projectile.body); } if (projectile && !projectile.destroyed) { projectile.destroy(); } // Remove the projectile from the projectiles group if (this.projectiles && typeof this.projectiles.remove === 'function' && projectile) { this.projectiles.remove(projectile); } console.log('Collision handling completed'); } createExplosionEffect(x, y) { const particles = this.add.particles('fireButton'); const emitter = particles.createEmitter({ x: x, y: y, speed: { min: -800, max: 800 }, angle: { min: 0, max: 360 }, scale: { start: 0.05, end: 0 }, blendMode: 'SCREEN', lifespan: 300, gravityY: 0 }); emitter.explode(20); this.time.delayedCall(300, () => { particles.destroy(); }); } handleAsteroidCollision(asteroidA, asteroidB) { if (!asteroidA || !asteroidB || !asteroidA.body || !asteroidB.body) { console.warn('Invalid asteroids in collision'); return; } // Calculate relative velocity const relativeVelocity = { x: asteroidA.body.velocity.x - asteroidB.body.velocity.x, y: asteroidA.body.velocity.y - asteroidB.body.velocity.y }; // Calculate collision normal const collisionNormal = { x: asteroidB.x - asteroidA.x, y: asteroidB.y - asteroidA.y }; const magnitude = Math.sqrt(collisionNormal.x ** 2 + collisionNormal.y ** 2); collisionNormal.x /= magnitude; collisionNormal.y /= magnitude; // Calculate impulse scalar (with 50% reduction) const impulseScalar = 0.5 * (relativeVelocity.x * collisionNormal.x + relativeVelocity.y * collisionNormal.y); // Apply impulse to both asteroids const impulse = { x: impulseScalar * collisionNormal.x, y: impulseScalar * collisionNormal.y }; // Apply velocities to asteroids this.matter.body.setVelocity(asteroidA.body, { x: asteroidA.body.velocity.x - impulse.x, y: asteroidA.body.velocity.y - impulse.y }); this.matter.body.setVelocity(asteroidB.body, { x: asteroidB.body.velocity.x + impulse.x, y: asteroidB.body.velocity.y + impulse.y }); // Calculate the speed of the collision const collisionSpeed = Math.sqrt(relativeVelocity.x ** 2 + relativeVelocity.y ** 2); // Define the maximum rotation speed and the speed threshold for maximum rotation const maxRotationSpeed = 0.025; const maxSpeedThreshold = 5; // Adjust this value based on your game's typical collision speeds // Calculate the rotation factor based on the collision speed const rotationFactor = Math.min(collisionSpeed / maxSpeedThreshold, 1); // Apply scaled random rotation to both asteroids const applyScaledRotation = (asteroid) => { const currentAngularVelocity = asteroid.body.angularVelocity; const randomRotation = Phaser.Math.FloatBetween(-maxRotationSpeed, maxRotationSpeed) * rotationFactor; const newAngularVelocity = currentAngularVelocity + randomRotation; // Reduce angular velocity if it's too high const maxAngularVelocity = 0.1; const finalAngularVelocity = Math.sign(newAngularVelocity) * Math.min(Math.abs(newAngularVelocity), maxAngularVelocity); this.matter.body.setAngularVelocity(asteroid.body, finalAngularVelocity); }; applyScaledRotation(asteroidA); applyScaledRotation(asteroidB); } spawnSmallAsteroids(x, y, count = 3) { console.log(`Spawning ${count} small asteroids at:`, x, y); if (typeof x !== 'number' || typeof y !== 'number' || isNaN(x) || isNaN(y)) { console.error('Invalid coordinates for spawning small asteroids:', x, y); return; } const smallAsteroidKeys = ['smallAsteroid1', 'smallAsteroid2', 'smallAsteroid3', 'smallAsteroid4']; const selectedKeys = Phaser.Utils.Array.Shuffle(smallAsteroidKeys).slice(0, Math.min(count, smallAsteroidKeys.length)); selectedKeys.forEach((key, index) => { const angle = (index / count) * Math.PI * 2; const distance = 30; const asteroidX = x + Math.cos(angle) * distance; const asteroidY = y + Math.sin(angle) * distance; // Get the dimensions of the sprite const texture = this.textures.get(key); const sourceImage = texture.getSourceImage(); const width = sourceImage.width; const height = sourceImage.height; // Set the visual scale to 1/4 of the original size (keep it as it was) const visualScale = 0.25; // Calculate the radius for the hitbox based on the larger dimension of the sprite const hitboxRadius = Math.max(width, height) / 2; const smallAsteroid = this.matter.add.image(asteroidX, asteroidY, key, null, { shape: { type: 'circle', radius: hitboxRadius }, label: 'smallAsteroid' }); if (smallAsteroid) { smallAsteroid.setScale(visualScale); smallAsteroid.setFrictionAir(0); smallAsteroid.setBounce(1); smallAsteroid.setVelocity( Phaser.Math.Between(-2, 2), Phaser.Math.Between(-2, 2) ); smallAsteroid.setAngularVelocity(Phaser.Math.FloatBetween(-0.05, 0.05)); smallAsteroid.setCollisionCategory(this.asteroidCategory); smallAsteroid.setCollidesWith([this.asteroidCategory, this.projectileCategory, this.bossCategory, 0x0001, 0x0002]); smallAsteroid.health = 20; // Set a lower health for small asteroids smallAsteroid.updateHealthBar = () => {}; // Small asteroids don't have health bars this.asteroids.push(smallAsteroid); console.log(`Small asteroid '${key}' created at:`, asteroidX, asteroidY, 'with hitbox radius:', hitboxRadius); } else { console.error('Failed to create small asteroid'); } }); } createExplosionEffect(x, y) { const particles = this.add.particles('fireButton'); const emitter = particles.createEmitter({ x: x, y: y, speed: { min: -800, max: 800 }, angle: { min: 0, max: 360 }, scale: { start: 0.1, end: 0 }, blendMode: 'SCREEN', lifespan: 500, gravityY: 0 }); emitter.explode(50); this.time.delayedCall(500, () => { particles.destroy(); }); } handleBossProjectileCollision(projectile) { if (!projectile) return; // Double damage when boss is alive, normal damage while growing const damageAmount = this.bossIsAlive ? 10 : 2; // 10% damage when alive (doubled from 5), 2% while growing this.bossHealth = Math.max(0, this.bossHealth - damageAmount); // Update boss health bar this.bossHealthBar.width = this.bossHealthBarWidth * (this.bossHealth / 100); // Create impact effect this.createExplosionEffect(projectile.x, projectile.y); // Remove the projectile if (projectile.body) { this.matter.world.remove(projectile.body); } projectile.destroy(); this.projectiles.remove(projectile); console.log('Boss hit by projectile! Health:', this.bossHealth); // Check for boss death if alive and health reaches 0 if (this.bossIsAlive && this.bossHealth <= 0) { this.handleBossDeath(); } } handleBossDeath() { // Prevent multiple death calls if (this.bossIsDying) return; this.bossIsDying = true; // Create a massive explosion effect const bossDeathParticles = this.add.particles('fireButton'); // Core explosion bossDeathParticles.createEmitter({ x: this.bossContainer.x, y: this.bossContainer.y, speed: { min: 400, max: 1600 }, angle: { min: 0, max: 360 }, scale: { start: 0.4, end: 0 }, blendMode: 'ADD', lifespan: 1000, tint: [0xff0000, 0xff6600, 0xffff00], quantity: 100 }).explode(100); // Secondary shockwave bossDeathParticles.createEmitter({ x: this.bossContainer.x, y: this.bossContainer.y, speed: { min: 300, max: 600 }, angle: { min: 0, max: 360 }, scale: { start: 0.2, end: 0.8 }, alpha: { start: 1, end: 0 }, blendMode: 'ADD', lifespan: 1500, tint: 0xff0000, quantity: 50 }).explode(50); // Play explosion sound with higher volume this.explosionSound.setVolume(1); this.explosionSound.play(); // Reset boss state instead of hiding/removing it this.bossHealth = 0; this.bossIsAlive = false; this.warningPlayed = false; // Award points for defeating the boss this.score += 1000 * this.level; // Show victory text // Create two-line boss defeat text const victoryText = this.add.text(this.cameras.main.centerX, this.cameras.main.centerY, 'BOSS\nDEFEATED', { fontFamily: 'Arial', fontSize: '64px', color: '#00ff00', stroke: '#ffffff', strokeThickness: 6 }).setOrigin(0.5).setScrollFactor(0).setDepth(1000); // Scale animation for victory text this.tweens.add({ targets: victoryText, scale: { from: 0, to: 1 }, duration: 1000, ease: 'Bounce.easeOut', onComplete: () => { // Wait 3 seconds then fade out and start new level this.time.delayedCall(3000, () => { this.tweens.add({ targets: victoryText, alpha: 0, duration: 500, onComplete: () => { victoryText.destroy(); // Reset boss container visibility and position for next level if (this.bossContainer) { this.bossContainer.setVisible(true); this.bossContainer.setPosition(this.worldWidth / 2, this.worldHeight / 2); } // Trigger level up sequence which will reset all necessary variables this.handleLevelUp(); } }); }); } }); } handleBossCollisions(pair) { const { bodyA, bodyB } = pair; let bossBody, otherBody; // Check which body is the boss if (bodyA === this.bossContainer.body) { bossBody = bodyA; otherBody = bodyB; } else if (bodyB === this.bossContainer.body) { bossBody = bodyB; otherBody = bodyA; } else { // If neither body is the boss, exit the function return; } // Check if the other body is an asteroid const asteroid = this.asteroids.find(a => a.body === otherBody); if (asteroid) { this.handleBossAsteroidCollision(bossBody, asteroid); } // Add more collision handlers here as needed } handleBossAsteroidCollision(bossBody, asteroid) { if (!bossBody || !asteroid || !asteroid.body || asteroid.isBeingDestroyed) { console.warn('Invalid boss or asteroid in collision'); return; } console.log('Boss-Asteroid collision detected!'); // Store asteroid position for effects const storedAsteroidPos = { x: asteroid.x, y: asteroid.y }; // Check if the colliding object is an asteroid or rubble and get spawn chance const asteroidTypes = { 'largeAsteroid': 0.25, // 25% chance 'largeRubble': 0.25, // 25% chance 'mediumAsteroid': 0.25, // 25% chance 'mediumRubble': 0.25, // 25% chance 'smallAsteroid1': 0.5, // 50% chance 'smallAsteroid2': 0.5, // 50% chance 'smallAsteroid3': 0.5, // 50% chance 'smallAsteroid4': 0.5 // 50% chance }; // Random chance to spawn an energy particle based on asteroid type if (Phaser.Math.FloatBetween(0, 1) < asteroidTypes[asteroid.texture.key]) { // Create a game object rectangle for rendering const energyParticleGraphics = this.add.rectangle( asteroid.x, asteroid.y, 6, // width 6, // height 0xFFFFFF // white color ); // Add physics body to the rectangle const energyParticle = this.matter.add.gameObject(energyParticleGraphics, { friction: 0, frictionAir: 0, restitution: 0.8, density: 0.001, render: { fillStyle: '#FFFFFF' }, label: 'energyParticle', isStatic: false, isSensor: false }); // Set up collision properties correctly energyParticle.setCollisionCategory(this.energyParticleCategory); energyParticle.setCollidesWith([this.asteroidCategory, 0x0002, 0x0001, this.bossCategory]); energyParticle.setFixedRotation(); // Prevent rotation // Create a circular physics body for the energy particle const radius = 3; // Half of the width/height energyParticle.setCircle(radius); energyParticle.setFriction(0); energyParticle.setFrictionAir(0); energyParticle.setBounce(0.8); energyParticle.setDensity(0.001); energyParticle.body.label = 'energyParticle'; // Apply initial velocity const angle = Phaser.Math.FloatBetween(0, Math.PI * 2); const speed = 0.25; this.matter.body.setVelocity(energyParticle.body, { x: Math.cos(angle) * speed, y: Math.sin(angle) * speed }); // Create twinkling effect this.tweens.add({ targets: energyParticle, fillColor: { from: 0xFFFFFF, to: 0xFFFF00 }, // white to yellow duration: 500, yoyo: true, repeat: -1 }); // Store reference to graphics object energyParticle.graphicsObject = energyParticleGraphics; // Create twinkling effect for graphics object this.tweens.add({ targets: energyParticleGraphics, fillColor: { from: 0xFFFFFF, to: 0xFFFF00 }, duration: 500, yoyo: true, repeat: -1 }); } // Calculate collision point const collisionPoint = { x: (bossBody.position.x + asteroid.x) / 2, y: (bossBody.position.y + asteroid.y) / 2 }; // Create explosion effect at collision point this.createExplosionEffect(collisionPoint.x, collisionPoint.y); // Damage asteroid (same as projectile damage) if (typeof asteroid.health !== 'undefined') { asteroid.health -= 10; asteroid.health = Math.max(asteroid.health, 0); console.log('Asteroid health:', asteroid.health); // Handle asteroid destruction if (asteroid.health <= 0) { asteroid.isBeingDestroyed = true; this.createExplosionEffect(storedAsteroidPos.x, storedAsteroidPos.y); // Remove from asteroids array const index = this.asteroids.indexOf(asteroid); if (index > -1) { this.asteroids.splice(index, 1); } // Clean up health bar if (asteroid.getData && typeof asteroid.getData === 'function') { const healthBar = asteroid.getData('healthBar'); if (healthBar) healthBar.destroy(); } asteroid.setData('healthBar', null); // Remove physics body if (asteroid.body) { this.matter.world.remove(asteroid.body); } // Spawn small asteroids based on destroyed asteroid size let smallAsteroidCount = 0; if (asteroid.texture.key === 'largeAsteroid' || asteroid.texture.key === 'largeRubble') { smallAsteroidCount = 5; } else if (asteroid.texture.key === 'mediumAsteroid' || asteroid.texture.key === 'mediumRubble') { smallAsteroidCount = 3; } if (smallAsteroidCount > 0) { this.spawnSmallAsteroids(storedAsteroidPos.x, storedAsteroidPos.y, smallAsteroidCount); } // Destroy asteroid with delay this.time.delayedCall(10, () => { if (asteroid && !asteroid.destroyed) { asteroid.destroy(); } }); } else { // Update health bar if asteroid still exists if (asteroid.updateHealthBar && typeof asteroid.updateHealthBar === 'function') { asteroid.updateHealthBar(); } // Change to rubble sprite if health is low if (asteroid.health <= 50 && asteroid.texture.key !== asteroid.rubbleTexture && asteroid.changeToRubble && typeof asteroid.changeToRubble === 'function') { asteroid.changeToRubble(); } } } // Play explosion sound if (this.explosionSound) { this.explosionSound.play(); } // Calculate bounce effect for surviving asteroids if (!asteroid.isBeingDestroyed) { const collisionNormal = { x: asteroid.x - this.bossContainer.x, y: asteroid.y - this.bossContainer.y }; const magnitude = Math.sqrt(collisionNormal.x ** 2 + collisionNormal.y ** 2); collisionNormal.x /= magnitude; collisionNormal.y /= magnitude; const bounceCoefficient = 1.2; const force = 0.0005; // Apply force to asteroid this.matter.body.applyForce(asteroid.body, asteroid.body.position, { x: collisionNormal.x * force, y: collisionNormal.y * force }); // Add random rotation const randomRotation = Phaser.Math.FloatBetween(-0.05, 0.05); this.matter.body.setAngularVelocity(asteroid.body, asteroid.body.angularVelocity + randomRotation); } } handleEnergyParticleWorldBoundsCollision(particleBody) { if (!particleBody || !particleBody.gameObject) return; const speed = 0.25; // Keep consistent with initial speed const velocity = particleBody.velocity; // Determine which boundary was hit and reverse the appropriate velocity component if (particleBody.position.x <= 0 || particleBody.position.x >= this.worldWidth) { velocity.x = -velocity.x; } if (particleBody.position.y <= 0 || particleBody.position.y >= this.worldHeight) { velocity.y = -velocity.y; } // Normalize and apply consistent speed const currentSpeed = Math.sqrt(velocity.x * velocity.x + velocity.y * velocity.y); if (currentSpeed !== 0) { velocity.x = (velocity.x / currentSpeed) * speed; velocity.y = (velocity.y / currentSpeed) * speed; } this.matter.body.setVelocity(particleBody, velocity); } handleEnergyParticleAsteroidCollision(particleBody, asteroid) { if (!particleBody || !particleBody.gameObject || !asteroid) { return; } const particle = particleBody.gameObject; // Calculate collision response const collisionNormal = { x: asteroid.x - particle.x, y: asteroid.y - particle.y }; const magnitude = Math.sqrt(collisionNormal.x ** 2 + collisionNormal.y ** 2); collisionNormal.x /= magnitude; collisionNormal.y /= magnitude; // Calculate new velocity for the particle (perfect elastic collision) const speed = 0.25; // Keep consistent with initial speed const newVelocity = { x: -collisionNormal.x * speed, y: -collisionNormal.y * speed }; // Apply the new velocity to the particle this.matter.body.setVelocity(particleBody, newVelocity); } handleEnergyParticleCollection(particleBody) { if (!particleBody || !particleBody.gameObject) return; // Play collection sound this.sound.play('collectSound', { volume: 0.5 }); // Increase spaceship energy this.energy = Math.min(1000, this.energy + 100); // Create a collection effect const particle = particleBody.gameObject; const collectionEffect = this.add.particles('fireButton'); const emitter = collectionEffect.createEmitter({ x: particle.x, y: particle.y, speed: { min: 50, max: 100 }, scale: { start: 0.05, end: 0 }, alpha: { start: 1, end: 0 }, tint: 0x00ff00, blendMode: 'ADD', lifespan: 200 }); // Explode and destroy the effect emitter.explode(10); this.time.delayedCall(200, () => { collectionEffect.destroy(); }); // Remove the energy particle if (particle.graphicsObject) { particle.graphicsObject.destroy(); } this.matter.world.remove(particleBody); particle.destroy(); } handleBossEnergyParticleCollection(particleBody) { if (!particleBody || !particleBody.gameObject) { console.warn('Invalid particle in boss collection'); return; } console.log('Boss collecting energy particle'); // Play boss collection sound this.sound.play('bossCollectSound', { volume: 0.5 }); // Increase boss health by 10% (only if not already alive) if (!this.bossIsAlive) { this.bossHealth = Math.min(100, this.bossHealth + 10); console.log('Boss health increased to:', this.bossHealth); } // Update boss health bar this.bossHealthBar.width = this.bossHealthBarWidth * (this.bossHealth / 100); // Create a collection effect const particle = particleBody.gameObject; const collectionEffect = this.add.particles('fireButton'); const emitter = collectionEffect.createEmitter({ x: particle.x, y: particle.y, speed: { min: 50, max: 100 }, scale: { start: 0.05, end: 0 }, alpha: { start: 1, end: 0 }, tint: 0xff0000, // Red tint for boss collection blendMode: 'ADD', lifespan: 200 }); // Explode and destroy the effect emitter.explode(10); this.time.delayedCall(200, () => { collectionEffect.destroy(); }); // Remove the energy particle if (particle.graphicsObject) { particle.graphicsObject.destroy(); } this.matter.world.remove(particleBody); particle.destroy(); } startBossSurge() { if (!this.bossIsAlive) return; this.bossIsSurging = true; this.bossSurgeStartTime = this.time.now; // Randomly select and play one of the three threat sounds const threatSound = Phaser.Math.RND.pick(['bossThreat1', 'bossThreat2', 'bossThreat3']); this.sound.play(threatSound, { volume: 0.7 }); // Calculate next surge time const minInterval = Math.max(1500, 6000 - (this.bossLevel * 500)); const maxInterval = Math.max(3000, 12000 - (this.bossLevel * 750)); this.bossNextSurgeTime = this.time.now + Phaser.Math.Between(minInterval, maxInterval); } endBossSurge() { this.bossIsSurging = false; } handlePlayerDeath() { if (this.gameEnded) return; // Prevent multiple calls this.gameEnded = true; // Get the current high score from localStorage or default to 0 let highScore = parseInt(localStorage.getItem('highScore')) || 0; // Update high score if current score is higher if (this.score > highScore) { highScore = this.score; localStorage.setItem('highScore', highScore); } // Reset thrust and fire inputs this.isThrottling = false; this.isFiring = false; this.throttlePointer = null; this.firePointer = null; // Play explosion sound only once at death if (this.explosionSound && !this.explosionSound.isPlaying) { this.explosionSound.setVolume(0.8); this.explosionSound.play(); } // Create an intense particle explosion effect const deathParticles = this.add.particles('fireButton'); // Create multiple emitters for a more complex effect // Core explosion deathParticles.createEmitter({ x: this.spaceship.x, y: this.spaceship.y, speed: { min: 300, max: 1200 }, angle: { min: 0, max: 360 }, scale: { start: 0.2, end: 0 }, blendMode: 'ADD', lifespan: 800, tint: [0xff0000, 0xff6600, 0xffff00], quantity: 50 }).explode(50); // Secondary shockwave deathParticles.createEmitter({ x: this.spaceship.x, y: this.spaceship.y, speed: { min: 200, max: 400 }, angle: { min: 0, max: 360 }, scale: { start: 0.1, end: 0.4 }, alpha: { start: 1, end: 0 }, blendMode: 'ADD', lifespan: 1000, tint: 0x0066ff, quantity: 20 }).explode(20); // Hide the spaceship this.spaceship.setVisible(false); // Stop background music and other continuous sounds if (this.backgroundMusic) this.backgroundMusic.stop(); if (this.rocketSound) this.rocketSound.stop(); // Play explosion sound with higher volume if (this.explosionSound) { this.explosionSound.setVolume(1); this.explosionSound.play(); } // Create game over text const gameOverText = this.add.text(this.cameras.main.centerX, this.cameras.main.centerY, 'GAME OVER', { fontFamily: 'Arial', fontSize: '64px', color: '#ff0000', stroke: '#ffffff', strokeThickness: 6 }).setOrigin(0.5).setScrollFactor(0).setDepth(1000); // Add score texts below const finalScoreText = this.add.text(this.cameras.main.centerX, this.cameras.main.centerY + 80, `Final Score: ${this.score}`, { fontFamily: 'Arial', fontSize: '32px', color: '#ffffff' }).setOrigin(0.5).setScrollFactor(0).setDepth(1000); // Add high score text with different color if it's a new high score const highScoreColor = this.score >= highScore ? '#ffff00' : '#ffffff'; const highScorePrefix = this.score >= highScore ? 'New High Score: ' : 'High Score: '; const highScoreText = this.add.text(this.cameras.main.centerX, this.cameras.main.centerY + 120, `${highScorePrefix}${highScore}`, { fontFamily: 'Arial', fontSize: '32px', color: highScoreColor }).setOrigin(0.5).setScrollFactor(0).setDepth(1000); // If it's a new high score, add a celebratory effect if (this.score >= highScore) { this.tweens.add({ targets: highScoreText, scale: { from: 1, to: 1.2 }, duration: 500, yoyo: true, repeat: -1 }); } // Scale animation for game over text this.tweens.add({ targets: gameOverText, scale: { from: 0, to: 1 }, duration: 1000, ease: 'Bounce.easeOut' }); // Disable all controls this.joystick.removeInteractive(); this.throttle.removeInteractive(); this.fireButton.removeInteractive(); // Clean up physics if (this.spaceship.body) { this.matter.world.remove(this.spaceship.body); } // Optional: Add a restart button after a delay this.time.delayedCall(2000, () => { const restartButton = this.add.text(this.cameras.main.centerX, this.cameras.main.centerY + 160, 'Tap to Restart', { fontFamily: 'Arial', fontSize: '24px', color: '#ffffff' }).setOrigin(0.5).setScrollFactor(0).setDepth(1000) .setInteractive(); restartButton.on('pointerdown', () => { this.scene.restart(); }); // Add blinking animation to the restart text this.tweens.add({ targets: restartButton, alpha: { from: 1, to: 0.5 }, duration: 500, yoyo: true, repeat: -1 }); }); } createAsteroid(x, y, size) { console.log(`Creating ${size} asteroid at:`, x, y); if (typeof x !== 'number' || typeof y !== 'number' || isNaN(x) || isNaN(y)) { console.error('Invalid coordinates for creating asteroid:', x, y); return null; } const visualAsteroidScale = size === 'large' ? 0.5 : 0.5; const physicsAsteroidScale = size === 'large' ? 1.0 : 1.0; const asteroidTexture = size === 'large' ? 'largeAsteroid' : 'mediumAsteroid'; const rubbleTexture = size === 'large' ? 'largeRubble' : 'mediumRubble'; const asteroidRadius = this.textures.get(asteroidTexture).getSourceImage().width / 2; const asteroid = this.matter.add.image(x, y, asteroidTexture, null, { shape: { type: 'circle', radius: asteroidRadius * physicsAsteroidScale }, label: 'asteroid' }); asteroid.size = size; asteroid.rubbleTexture = rubbleTexture; if (!asteroid || !asteroid.body) { console.error('Failed to create asteroid body'); return null; } asteroid.setScale(visualAsteroidScale); asteroid.setDepth(1); asteroid.setDensity(0.001); asteroid.setFrictionAir(0.0001); asteroid.setBounce(0.8); asteroid.setVelocity(Phaser.Math.Between(-2, 2), Phaser.Math.Between(-2, 2)); asteroid.setAngularVelocity(Phaser.Math.Between(-0.05, 0.05)); if (!asteroid.body) { console.warn('Asteroid body not created properly'); return null; } // Use the shared asteroid category asteroid.setCollisionCategory(this.asteroidCategory); asteroid.setCollidesWith([this.asteroidCategory, this.projectileCategory, this.bossCategory, 0x0001, 0x0002]); // Add health property to the asteroid asteroid.health = 100; // Add method to change sprite asteroid.changeToRubble = function() { const currentRadius = this.body.circleRadius; const currentPosition = { x: this.x, y: this.y }; const currentVelocity = { x: this.body.velocity.x, y: this.body.velocity.y }; const currentAngularVelocity = this.body.angularVelocity; this.setTexture(this.rubbleTexture); const asteroidWidth = this.scene.textures.get(this.size === 'large' ? 'largeAsteroid' : 'mediumAsteroid').getSourceImage().width; const rubbleWidth = this.scene.textures.get(this.rubbleTexture).getSourceImage().width; const newScale = (asteroidWidth / rubbleWidth) * this.scaleX; this.setScale(newScale); this.setCircle(currentRadius); this.setPosition(currentPosition.x, currentPosition.y); this.setVelocity(currentVelocity.x, currentVelocity.y); this.setAngularVelocity(currentAngularVelocity); this.setCollisionCategory(this.scene.asteroidCategory); this.setCollidesWith([this.scene.asteroidCategory, this.scene.projectileCategory, 0x0001, 0x0002]); this.scene.matter.body.set(this.body, 'label', 'asteroid'); }; // Create health bar const healthBarWidth = asteroid.width * visualAsteroidScale * 0.25; const healthBarHeight = 1; const healthBar = this.add.rectangle(0, 0, healthBarWidth, healthBarHeight, 0x00ff00); healthBar.setOrigin(0.5, 0.5); healthBar.setDepth(2); // Function to update health bar const updateHealthBar = () => { const currentHealthBar = asteroid.getData('healthBar'); if (currentHealthBar && !asteroid.isBeingDestroyed) { const healthPercentage = asteroid.health / 100; currentHealthBar.width = healthBarWidth * healthPercentage; currentHealthBar.fillColor = (healthPercentage > 0.5) ? 0x00ff00 : (healthPercentage > 0.25 ? 0xffff00 : 0xff0000); } }; // Add update health bar function to asteroid asteroid.updateHealthBar = updateHealthBar; // Initial health bar update updateHealthBar(); // Make health bar follow asteroid asteroid.setDataEnabled(); asteroid.setData('healthBar', healthBar); this.events.on('update', () => { const currentHealthBar = asteroid.getData('healthBar'); if (currentHealthBar && !asteroid.isBeingDestroyed) { currentHealthBar.setPosition(asteroid.x, asteroid.y); } }); return asteroid; } handleLevelUp() { // Prevent multiple level-up calls if (this.isLevelingUp) return; this.isLevelingUp = true; // Increase level this.level += 1; // Create level up announcement text const levelText = this.add.text(this.cameras.main.centerX, this.cameras.main.centerY, `LEVEL ${this.level}`, { fontFamily: 'Arial', fontSize: '64px', color: '#00ff00', stroke: '#ffffff', strokeThickness: 6 }).setOrigin(0.5).setScrollFactor(0).setDepth(1000); // Scale animation for level text this.tweens.add({ targets: levelText, scale: { from: 0, to: 1 }, duration: 1000, ease: 'Bounce.easeOut' }); // Wait 3 seconds then start new level this.time.delayedCall(3000, () => { // Fade out level text this.tweens.add({ targets: levelText, alpha: 0, duration: 500, onComplete: () => { levelText.destroy(); this.startNewLevel(); } }); }); } startNewLevel() { // Reset crystal count for new level (10 + 5 per level above 1) this.crystals = 10 + (this.level - 1) * 5; // Reset energy to full this.energy = 1000; // Reset boss parameters this.bossHealth = 0; this.bossIsAlive = false; this.warningPlayed = false; this.bossLevel = this.level; // Clear existing asteroids this.asteroids.forEach(asteroid => { if (asteroid.getData) { const healthBar = asteroid.getData('healthBar'); if (healthBar) healthBar.destroy(); } asteroid.destroy(); }); this.asteroids = []; // Spawn new asteroids const numAsteroids = 20 + (this.level - 1) * 8; // Start with 20 and add 8 per level const largeAsteroidRadius = this.textures.get('largeAsteroid').getSourceImage().width / 2 * 0.5; const mediumAsteroidRadius = this.textures.get('mediumAsteroid').getSourceImage().width / 2 * 0.25; const margin = Math.max(largeAsteroidRadius * 2, mediumAsteroidRadius * 2, 50); for (let i = 0; i < numAsteroids; i++) { const x = Phaser.Math.Between(margin, this.worldWidth - margin); const y = Phaser.Math.Between(margin, this.worldHeight - margin); const size = i < numAsteroids / 2 ? 'large' : 'medium'; const asteroid = this.createAsteroid(x, y, size); if (asteroid) { this.asteroids.push(asteroid); } } // Reset level up flag this.isLevelingUp = false; } } const config = { type: Phaser.AUTO, parent: 'renderDiv', scale: { mode: Phaser.Scale.FIT, autoCenter: Phaser.Scale.CENTER_BOTH, width: 720, height: 1280 }, physics: { default: 'matter', matter: { debug: false, gravity: { y: 0 }, enableSleeping: false } }, backgroundColor: '#000000', scene: [PreGameScene, GameScene] }; window.phaserGame = new Phaser.Game(config);