class Fighter { constructor(scene, x, y, isPlayer = false) { this.scene = scene; this.color = isPlayer ? 0xff0000 : 0x0000ff; // Red for player, Blue for opponent this.globalCooldownTime = isPlayer ? 60 : 120; // 1 second for player, 2 seconds for AI this.masterCooldown = isPlayer ? 0 : 120; // Only used for AI, initially 2 seconds this.body = scene.matter.add.rectangle(x, y, 40, 80, { restitution: 0.1, friction: 0.2, frictionAir: 0.01, chamfer: { radius: 5 }, collisionFilter: { category: 0x0002, mask: 0x0001 | 0x0004 // Can collide with ground and particles } }); this.health = 1000; // Increased the initial health to 1000 this.spikeColor = isPlayer ? 0xFFFF00 : 0x00FF00; // Yellow for player, Green for opponent this.attackCooldown = 0; this.attackCooldownTime = 45; // 0.75 second cooldown for particle attack this.electricCircleCooldown = 0; this.electricCircleCooldownTime = 120; // 2 second cooldown for electric circle this.moveDirection = 1; // 1 for right, -1 for left this.movementSpeed = 2; this.isAttacking = false; this.isPlayer = isPlayer; this.isJumping = false; this.facing = isPlayer ? 1 : -1; // 1 for right, -1 for left this.spikesExtended = false; this.spikesEjected = false; this.spikesCooldown = 0; this.spikes = []; this.healthText = null; // New property to store the health text object this.activeMissile = null; // New property to track the active missile this.globalCooldown = 0; // New property for global cooldown this.bombCooldown = 0; // New property for bomb cooldown this.lightningCooldown = 0; // New property for lightning cooldown this.lastLightningStrike = 0; // New property to track the last lightning strike this.fireworkCooldown = 0; // New property for firework cooldown this.missileCooldown = 0; // New property for missile cooldown this.spikedBallCooldown = 0; // New property for spiked ball cooldown this.bouncingBallCooldown = 0; // New property for bouncing ball cooldown this.bouncingBallCooldownTime = 120; // 2 seconds cooldown (assuming 60 FPS) this.bouncingBallCooldown = 0; // New property for bouncing ball cooldown this.bugCooldown = 0; // New property for bug cooldown this.bugCooldownTime = 180; // 3 seconds cooldown (assuming 60 FPS) // Remove this line entirely } resetCooldowns() { this.attackCooldown = 0; this.electricCircleCooldown = 0; this.spikesCooldown = 0; this.globalCooldown = 0; this.bombCooldown = 0; this.lightningCooldown = 0; this.fireworkCooldown = 0; this.missileCooldown = 0; this.spikedBallCooldown = 0; this.bouncingBallCooldown = 0; this.bugCooldown = 0; } launchBouncingBall() { if (this.bouncingBallCooldown > 0 || this.globalCooldown > 0) { console.log("Cannot launch bouncing ball: on cooldown"); return; } this.bouncingBallCooldown = this.bouncingBallCooldownTime; this.globalCooldown = 30; // 0.5 seconds global cooldown const { x, y } = this.body.position; const ballRadius = 10; const ballX = x + (this.facing * 30); // Start 30 pixels in front of the fighter const ballY = y - 20; // Start slightly above the fighter's center const ball = { x: ballX, y: ballY, radius: ballRadius, velocityX: this.facing * 5, // Initial horizontal velocity velocityY: -8, // Initial upward velocity bounceFactor: 0.8, // How much velocity is retained after bouncing owner: this, isBouncingBall: true, fillColor: this.isPlayer ? 0xFFAA00 : 0x00FF00, // Orange for player, Green for AI creationTime: this.scene.time.now, update: function(scene) { // Check if 2.25 seconds have passed if (scene.time.now - this.creationTime > 2250) { return false; // Remove the ball } // Apply gravity this.velocityY += 0.3; // Update position this.x += this.velocityX; this.y += this.velocityY; // Bounce off walls if (this.x - this.radius < 0 || this.x + this.radius > scene.game.config.width) { this.velocityX *= -this.bounceFactor; this.x = Phaser.Math.Clamp(this.x, this.radius, scene.game.config.width - this.radius); } // Bounce off ceiling and floor if (this.y - this.radius < 0 || this.y + this.radius > scene.game.config.height - 50) { // 50 is ground height this.velocityY *= -this.bounceFactor; this.y = Phaser.Math.Clamp(this.y, this.radius, scene.game.config.height - 50 - this.radius); } // Check for collision with opposing fighter const opposingFighter = this.owner.isPlayer ? scene.fighter2 : scene.fighter1; const dx = this.x - opposingFighter.body.position.x; const dy = this.y - opposingFighter.body.position.y; const distance = Math.sqrt(dx * dx + dy * dy); if (distance < this.radius + 40) { // 40 is approximate fighter size // Deal damage to the opposing fighter const damage = 50; opposingFighter.health -= damage; console.log(`Bouncing ball hit! Damage: ${damage}, Remaining health: ${opposingFighter.health}`); // Remove the bouncing ball return false; // Returning false will remove this ball from the update loop } return true; // Keep updating this ball } }; // Add the bouncing ball to a new array in the scene for tracking and updating if (!this.scene.bouncingBalls) { this.scene.bouncingBalls = []; } this.scene.bouncingBalls.push(ball); } draw() { const { x, y } = this.body.position; // Draw electric circle if active if (this.electricCircle) { // Main electric field this.scene.graphics.fillStyle(0x00ffff, 0.2); this.scene.graphics.fillCircle(x, y, this.electricCircle.radius); // Lightning effect this.scene.graphics.lineStyle(2, 0x00ffff, 0.8); for (let i = 0; i < 8; i++) { const angle = Math.random() * Math.PI * 2; const length = Math.random() * this.electricCircle.radius; const endX = x + Math.cos(angle) * length; const endY = y + Math.sin(angle) * length; this.scene.graphics.beginPath(); this.scene.graphics.moveTo(x, y); this.scene.graphics.lineTo(endX, endY); this.scene.graphics.strokePath(); } // Particle effect for (let i = 0; i < 5; i++) { const particleAngle = Math.random() * Math.PI * 2; const particleRadius = Math.random() * this.electricCircle.radius; const particleX = x + Math.cos(particleAngle) * particleRadius; const particleY = y + Math.sin(particleAngle) * particleRadius; this.scene.graphics.fillStyle(0x00ffff, Math.random() * 0.5 + 0.5); this.scene.graphics.fillCircle(particleX, particleY, Math.random() * 3 + 1); } } // Draw the fighter this.scene.graphics.fillStyle(this.color); this.scene.graphics.fillRect(x - 20, y - 40, 40, 80); // Draw the eye this.scene.graphics.fillStyle(0xFFFFFF); const eyeX = x + (this.facing * 10); // 10 pixels from the edge const eyeY = y - 20; // Halfway up the body this.scene.graphics.fillCircle(eyeX, eyeY, 5); // Draw the half smile this.scene.graphics.lineStyle(2, 0xFFFFFF); const smileWidth = 15; const smileY = y; const smileStartX = x + (this.facing * 5); const smileEndX = x + (this.facing * (5 + smileWidth)); const smileCurveY = smileY + 5; this.scene.graphics.beginPath(); this.scene.graphics.moveTo(smileStartX, smileY); // Use a series of lineTo commands to approximate a curve const steps = 10; for (let i = 1; i <= steps; i++) { const t = i / steps; const curveX = smileStartX + (smileEndX - smileStartX) * t; const curveY = smileY + Math.sin(Math.PI * t) * 5; this.scene.graphics.lineTo(curveX, curveY); } this.scene.graphics.strokePath(); // Draw spikes if extended or ejected if (this.spikesExtended || this.spikesEjected) { this.scene.graphics.fillStyle(this.spikeColor); this.spikes.forEach(spike => { let spikeX = spike.x; let spikeY = spike.y; let spikeFacing = spike.facing; if (!this.spikesEjected) { spikeX = x - (this.facing * 20); spikeY = y + spike.offsetY; spikeFacing = this.facing; } this.scene.graphics.fillTriangle( spikeX, spikeY, spikeX - (spikeFacing * 20), spikeY + 7, spikeX, spikeY + 15 ); }); this.scene.graphics.setDepth(this.scene.DEPTH.PROJECTILE); } } shootParticle() { if (this.attackCooldown <= 0 && this.globalCooldown <= 0) { this.isAttacking = true; this.attackCooldown = this.attackCooldownTime; this.globalCooldown = this.globalCooldownTime; const { x, y } = this.body.position; const particleX = x + (this.facing * 25); // 25 pixels in front of the fighter const particle = this.scene.matter.add.circle(particleX, y - 20, 10, { // Doubled size from 5 to 10 friction: 0, frictionAir: 0, restitution: 1, isSensor: true, collisionFilter: { category: 0x0004, mask: 0x0002 // Can only collide with fighters } }); particle.depth = this.scene.DEPTH.PROJECTILE; const speed = 10; this.scene.matter.body.setVelocity(particle, { x: this.facing * speed, y: 0 }); // Set particle color and owner particle.color = this.color; particle.owner = this; // Set bullet ball color based on the fighter's color particle.fillColor = this.color; // Destroy particle after 2 seconds this.scene.time.delayedCall(2000, () => { this.scene.matter.world.remove(particle); }); } } createElectricCircle() { if (this.electricCircleCooldown <= 0 && this.globalCooldown <= 0) { this.isAttacking = true; this.electricCircleCooldown = this.electricCircleCooldownTime; this.globalCooldown = this.globalCooldownTime; this.electricCircle = { radius: 60, duration: 60 // Duration increased to 1 second (60 frames) }; } } extendSpikes() { if (!this.spikesExtended && !this.spikesEjected && this.spikesCooldown <= 0 && this.globalCooldown <= 0) { this.spikesExtended = true; this.spikes = []; this.globalCooldown = this.globalCooldownTime; for (let i = 0; i < 3; i++) { this.spikes.push({ x: this.body.position.x - (this.facing * 20), y: this.body.position.y - 35 + i * 30, offsetY: -35 + i * 30, facing: this.facing }); } this.scene.time.delayedCall(500, () => { this.ejectSpikes(); }); // Set the cooldown timer when spikes are extended this.spikesCooldown = 90; // 1.5 seconds cooldown for spikes } } ejectSpikes() { this.spikesExtended = false; this.spikesEjected = true; const { x, y } = this.body.position; this.spikes.forEach(spike => { spike.x = x - (this.facing * 20); spike.y = y + spike.offsetY; spike.velocityX = -this.facing * 5; spike.velocityY = 0; spike.facing = this.facing; }); this.scene.time.delayedCall(750, () => { this.destroySpikes(); }); } destroySpikes() { this.spikesEjected = false; this.spikes = []; // We're not resetting the cooldown here anymore } checkCollisions(otherFighter) { this.scene.matter.world.getAllBodies().forEach(body => { if ((body.circleRadius === 10 || body.circleRadius === 4 || (body.width && body.height)) && body.owner !== this) { const projectileX = body.position.x; const projectileY = body.position.y; const fighterLeft = this.body.position.x - 25; const fighterRight = this.body.position.x + 25; const fighterTop = this.body.position.y - 45; const fighterBottom = this.body.position.y + 45; if (projectileX >= fighterLeft && projectileX <= fighterRight && projectileY >= fighterTop && projectileY <= fighterBottom) { let damage; if (body.circleRadius === 10) { // Regular particle (spit ball) damage = Phaser.Math.Between(12, 28); // Increased by 15% (rounded to integers) console.log(`Spit ball hit! Damage: ${damage} (15% stronger), Remaining health: ${this.health}`); this.scene.matter.world.remove(body); } else if (body.width && body.height) { // Homing missile damage = Phaser.Math.Between(30, 50); console.log(`Missile hit! Damage: ${damage}, Remaining health: ${this.health}`); if (body.owner) { body.owner.destroyMissile(body); } } else if (body.circleRadius === 4) { // Firework particle damage = Phaser.Math.Between(5, 10); console.log(`Firework particle hit! Damage: ${damage}, Remaining health: ${this.health}`); this.scene.matter.world.remove(body); } this.health -= damage; } } }); } checkSpikeCollision(otherFighter) { const fighterLeft = otherFighter.body.position.x - 20; const fighterRight = otherFighter.body.position.x + 20; const fighterTop = otherFighter.body.position.y - 40; const fighterBottom = otherFighter.body.position.y + 40; if (this.spikesExtended && !this.spikesEjected) { const dx = this.body.position.x - otherFighter.body.position.x; const dy = this.body.position.y - otherFighter.body.position.y; const distance = Math.sqrt(dx * dx + dy * dy); if (distance < 60) { // Adjust this value based on your fighter sizes otherFighter.health -= 2.79456; // Increased damage by 42%, then reduced by 18% (3.408 * 0.82 = 2.79456) console.log(`Extended spikes hit! Damage: 3.408, Remaining health: ${otherFighter.health}`); } } else if (this.spikesEjected) { this.spikes = this.spikes.filter(spike => { const spikeLeft = spike.x - 10; const spikeRight = spike.x + 10; const spikeTop = spike.y - 7; const spikeBottom = spike.y + 7; if (spikeRight >= fighterLeft && spikeLeft <= fighterRight && spikeBottom >= fighterTop && spikeTop <= fighterBottom) { otherFighter.health -= 13.9728; // Increased damage by 42%, then reduced by 18% (17.04 * 0.82 = 13.9728) console.log(`Ejected spike hit! Damage: 17.04, Remaining health: ${otherFighter.health}`); return false; // Remove this spike } return true; // Keep this spike }); if (this.spikes.length === 0) { this.spikesEjected = false; } } } checkElectricCircleCollision(otherFighter) { if (this.electricCircle) { const circleX = this.body.position.x; const circleY = this.body.position.y; const circleRadius = this.electricCircle.radius; const fighterWidth = 40; // Assuming fighter width is 40 const fighterHeight = 80; // Assuming fighter height is 80 // Check collision for each corner and the center of the fighter const points = [{ x: otherFighter.body.position.x - fighterWidth / 2, y: otherFighter.body.position.y - fighterHeight / 2 }, { x: otherFighter.body.position.x + fighterWidth / 2, y: otherFighter.body.position.y - fighterHeight / 2 }, { x: otherFighter.body.position.x - fighterWidth / 2, y: otherFighter.body.position.y + fighterHeight / 2 }, { x: otherFighter.body.position.x + fighterWidth / 2, y: otherFighter.body.position.y + fighterHeight / 2 }, { x: otherFighter.body.position.x, y: otherFighter.body.position.y }]; let collision = false; for (let point of points) { const dx = circleX - point.x; const dy = circleY - point.y; const distance = Math.sqrt(dx * dx + dy * dy); if (distance < circleRadius) { collision = true; break; } } if (collision) { const damage = Math.round(3 * 0.7); // Reduce damage by 30% otherFighter.health -= damage; console.log(`Electric circle hit! Damage: ${damage}, Remaining health: ${otherFighter.health}`); } } } update(otherFighter) { // Reset isJumping flag if the fighter is on the ground if (this.isOnGround()) { this.isJumping = false; } if (!this.isPlayer) { // Use the master cooldown for the AI this.globalCooldownTime = this.masterCooldown; // Enhanced AI logic const dx = otherFighter.body.position.x - this.body.position.x; const dy = otherFighter.body.position.y - this.body.position.y; const distance = Math.sqrt(dx * dx + dy * dy); // Check for nearby bombs and jump if necessary if (this.isNearBomb() && this.isOnGround()) { this.jump(); } // Analyze player's health and adapt strategy const playerHealthPercentage = otherFighter.health / 1000; const aiHealthPercentage = this.health / 1000; if (aiHealthPercentage < 0.3) { this.defensiveBehavior(otherFighter, distance); } else if (playerHealthPercentage < 0.3) { this.aggressiveBehavior(otherFighter, distance); } else { this.balancedBehavior(otherFighter, distance); } // Improved dodging this.improvedDodge(otherFighter); // Improved jumping strategy this.intelligentJumping(otherFighter); // Predict player's movement and aim accordingly this.predictiveAiming(otherFighter); // Check if AI has been stationary if (!this.lastX) { this.lastX = this.body.position.x; this.stationaryTime = 0; } else if (Math.abs(this.body.position.x - this.lastX) < 1) { this.stationaryTime++; } else { this.lastX = this.body.position.x; this.stationaryTime = 0; } // Encourage movement if stationary for too long if (this.stationaryTime > 60) { // If stationary for more than 1 second (assuming 60 FPS) const moveDirection = Math.random() < 0.5 ? -1 : 1; this.moveTowards({ body: { position: { x: this.body.position.x + moveDirection * 100 } } }); } else { // Improved dodging this.improvedDodge(otherFighter); // Analyze player's health and adapt strategy const playerHealthPercentage = otherFighter.health / 1000; const aiHealthPercentage = this.health / 1000; if (aiHealthPercentage < 0.3) { // Defensive behavior when AI health is low this.defensiveBehavior(otherFighter, distance); } else if (playerHealthPercentage < 0.3) { // Aggressive behavior when player health is low this.aggressiveBehavior(otherFighter, distance); } else { // Balanced behavior this.balancedBehavior(otherFighter, distance); } } // Improved jumping strategy this.intelligentJumping(otherFighter); // Predict player's movement and aim accordingly this.predictiveAiming(otherFighter); } else { // Player logic remains unchanged // Player logic const cursors = this.scene.cursors; const moveForce = 0.005; // Increased by ~43% if (cursors.left.isDown) { this.scene.matter.body.applyForce(this.body, this.body.position, { x: -moveForce, y: 0 }); this.facing = -1; } else if (cursors.right.isDown) { this.scene.matter.body.applyForce(this.body, this.body.position, { x: moveForce, y: 0 }); this.facing = 1; } else { // Apply a small opposing force to slow down the fighter when not moving const slowDownForce = 0.001; const opposingForce = -Math.sign(this.body.velocity.x) * slowDownForce; this.scene.matter.body.applyForce(this.body, this.body.position, { x: opposingForce, y: 0 }); } if (Phaser.Input.Keyboard.JustDown(cursors.up) && !this.isJumping) { this.scene.matter.body.setVelocity(this.body, { x: this.body.velocity.x, y: -10 }); this.isJumping = true; } if (Phaser.Input.Keyboard.JustDown(this.scene.key3)) { this.extendSpikes(); } } // Common updates for both AI and player if (this.attackCooldown > 0) { this.attackCooldown--; } if (this.electricCircleCooldown > 0) { this.electricCircleCooldown--; } if (this.spikesCooldown > 0) { this.spikesCooldown--; } if (this.globalCooldown > 0) { this.globalCooldown--; } if (this.bombCooldown > 0) { this.bombCooldown--; } if (this.lightningCooldown > 0) { this.lightningCooldown--; } if (this.missileCooldown > 0) { this.missileCooldown--; } if (this.spikedBallCooldown > 0) { this.spikedBallCooldown--; } if (this.bugCooldown > 0) { this.bugCooldown--; } this.checkElectricCircleCollision(otherFighter); this.checkSpikeCollision(otherFighter); // Update electric circle if (this.electricCircle) { this.electricCircle.duration--; if (this.electricCircle.duration <= 0) { this.electricCircle = null; } } // Update ejected spikes if (this.spikesEjected) { this.spikes.forEach(spike => { spike.x += spike.velocityX; spike.y += spike.velocityY; }); // The off-screen check is now handled by destroyOffscreenObjects if (this.spikes.length === 0) { this.spikesEjected = false; } } // Keep the fighter upright this.scene.matter.body.setAngle(this.body, 0); // Limit horizontal velocity const velocity = this.body.velocity; const maxVelocity = 5; if (Math.abs(velocity.x) > maxVelocity) { this.scene.matter.body.setVelocity(this.body, { x: Math.sign(velocity.x) * maxVelocity, y: velocity.y }); } // Constrain fighter to screen this.constrainToScreen(); } isNearEdge() { const margin = 100; // Distance from edge to consider "near" return ( this.body.position.x < margin || this.body.position.x > this.scene.game.config.width - margin ); } moveTowards(otherFighter) { const moveForce = 0.005; // Increased force const direction = this.isNearEdge() ? (this.body.position.x < this.scene.game.config.width / 2 ? 1 : -1) : this.facing; this.scene.matter.body.applyForce(this.body, this.body.position, { x: direction * moveForce, y: 0 }); } moveAway(otherFighter) { const retreatForce = 0.005; // Increased force const direction = this.isNearEdge() ? (this.body.position.x < this.scene.game.config.width / 2 ? 1 : -1) : -this.facing; this.scene.matter.body.applyForce(this.body, this.body.position, { x: direction * retreatForce, y: 0 }); } jump() { const yVelocity = Math.abs(this.body.velocity.y); if (yVelocity < 0.1) { this.scene.matter.body.setVelocity(this.body, { x: this.body.velocity.x, y: -12 // Increased jump velocity }); this.isJumping = true; } } improvedDodge(otherFighter) { const threatDistance = 200; // Increased threat detection distance const dx = otherFighter.body.position.x - this.body.position.x; const dy = otherFighter.body.position.y - this.body.position.y; const distance = Math.sqrt(dx * dx + dy * dy); // Detect incoming threats const incomingThreats = this.scene.matter.world.getAllBodies().filter(body => { if (body.owner === this || body === this.body) return false; const bodyDx = body.position.x - this.body.position.x; const bodyDy = body.position.y - this.body.position.y; const bodyDistance = Math.sqrt(bodyDx * bodyDx + bodyDy * bodyDy); return bodyDistance < threatDistance && (body.circleRadius || (body.width && body.height)); }); if (incomingThreats.length > 0 || (distance < threatDistance && otherFighter.spikesExtended)) { // Determine dodge direction const dodgeDirection = Math.random() < 0.5 ? -1 : 1; // Dodge sideways this.scene.matter.body.setVelocity(this.body, { x: dodgeDirection * 5, y: this.body.velocity.y }); // Jump if not already jumping if (!this.isJumping && Math.random() < 0.7) { this.jump(); } } } constrainToScreen() { const halfWidth = 20; // Half of the fighter's width const halfHeight = 40; // Half of the fighter's height const screenWidth = this.scene.game.config.width; const screenHeight = this.scene.game.config.height; let x = this.body.position.x; let y = this.body.position.y; x = Phaser.Math.Clamp(x, halfWidth, screenWidth - halfWidth); y = Phaser.Math.Clamp(y, halfHeight, screenHeight - halfHeight); this.scene.matter.body.setPosition(this.body, { x, y }); } dodgeProjectiles() { const nearbyProjectiles = this.scene.matter.world.getAllBodies().filter(body => { if (body.owner === this || body === this.body) return false; const dx = body.position.x - this.body.position.x; const dy = body.position.y - this.body.position.y; const distance = Math.sqrt(dx * dx + dy * dy); return distance < 150 && (body.circleRadius || (body.width && body.height)); }); if (nearbyProjectiles.length > 0) { const closestProjectile = nearbyProjectiles[0]; const dx = closestProjectile.position.x - this.body.position.x; const dy = closestProjectile.position.y - this.body.position.y; if (Math.abs(dx) < 50 && Math.abs(dy) < 50) { if (!this.isJumping) { this.jump(); } else { this.moveAway({ body: { position: closestProjectile.position } }); } } } } fireHomingMissile(targetFighter) { if (this.missileCooldown > 0 || this.globalCooldown > 0) { console.log("Cannot fire missile: on cooldown"); return; } this.missileCooldown = 90; // 1.5 seconds cooldown (assuming 60 FPS) this.globalCooldown = this.globalCooldownTime; const { x, y } = this.body.position; const missileX = x + (this.facing * 30); const missileY = y - 20; const missileWidth = 30; const missileHeight = 10; const missile = this.scene.matter.add.rectangle(missileX, missileY, missileWidth, missileHeight, { friction: 0, frictionAir: 0.05, restitution: 1, isSensor: true, collisionFilter: { category: 0x0004, mask: 0x0002 } }); missile.depth = this.scene.DEPTH.PROJECTILE; missile.fillColor = this.isPlayer ? 0xFFFF00 : 0x00FF00; // Yellow for player, Green for AI missile.owner = this; missile.width = missileWidth; missile.height = missileHeight; this.activeMissile = missile; // Set this as the active missile const initialSpeed = 3.1; // Reduced by 38% from 5 const initialVerticalSpeed = -0.62; // Reduced by 38% from -1 const initialAngle = this.facing === 1 ? 0 : Math.PI; // Set initial angle based on facing direction this.scene.matter.body.setAngle(missile, initialAngle); this.scene.matter.body.setVelocity(missile, { x: this.facing * initialSpeed, y: initialVerticalSpeed }); let currentAngle = initialAngle; const updateMissile = () => { if (!this.activeMissile) return; // Stop updating if missile is destroyed const dx = targetFighter.body.position.x - missile.position.x; const dy = targetFighter.body.position.y - missile.position.y; const targetAngle = Math.atan2(dy, dx); const angleAdjustment = 0.1; currentAngle += Phaser.Math.Angle.Wrap(targetAngle - currentAngle) * angleAdjustment; const speed = 2.48; // Reduced by 38% from 4 let newVelocity = { x: Math.cos(currentAngle) * speed, y: Math.sin(currentAngle) * speed }; // Check if the missile would go below the screen const screenHeight = this.scene.game.config.height; const missileRadius = 12; // The radius of the missile if (missile.position.y + newVelocity.y > screenHeight - missileRadius) { // If it would go below, set y velocity to 0 and adjust the angle newVelocity.y = 0; currentAngle = newVelocity.x > 0 ? 0 : Math.PI; } this.scene.matter.body.setVelocity(missile, newVelocity); this.scene.matter.body.setAngle(missile, currentAngle); // Update missile's angle }; missile.updateLoop = this.scene.time.addEvent({ delay: 16, // Update more frequently for smoother rotation callback: updateMissile, callbackScope: this, loop: true }); this.scene.time.delayedCall(1700, () => { this.destroyMissile(missile); }); } destroyMissile(missile) { if (missile.updateLoop) { missile.updateLoop.destroy(); } this.scene.matter.world.remove(missile); } dropBomb() { if (this.globalCooldown > 0 || this.bombCooldown > 0) { console.log("Cannot drop bomb: on cooldown"); return; } this.globalCooldown = this.globalCooldownTime; this.bombCooldown = 120; // 2 seconds cooldown (assuming 60 FPS) const { x, y } = this.body.position; const bombX = x; const bombY = y + 40; // Drop the bomb from the bottom of the fighter const bombRadius = 20; // Doubled from 10 to 20 const bomb = this.scene.matter.add.circle(bombX, bombY, bombRadius, { friction: 0.005, frictionAir: 0.0005, restitution: 0.6, density: 0.005, collisionFilter: { category: 0x0004, mask: 0x0001 | 0x0002 // Can collide with ground and fighters } }); bomb.depth = this.scene.DEPTH.PROJECTILE; bomb.owner = this; bomb.radius = bombRadius; // Store the radius for later use bomb.isBomb = true; // Add a flag to identify it as a bomb bomb.isPlayerBomb = this.isPlayer; // Add a flag to identify if it's a player's bomb // Set a timer for the bomb to explode after 2 seconds this.scene.time.delayedCall(2000, () => { this.explodeBomb(bomb); }); } explodeBomb(bomb) { const explosionRadius = 150; const explosionDamage = 225; // Determine which fighter to check for damage const targetFighter = bomb.owner.isPlayer ? this.scene.fighter2 : this.scene.fighter1; const distance = Phaser.Math.Distance.Between( bomb.position.x, bomb.position.y, targetFighter.body.position.x, targetFighter.body.position.y ); if (distance <= explosionRadius) { const damage = Math.floor(explosionDamage * (1 - distance / explosionRadius)); targetFighter.health -= damage; console.log(`Bomb hit ${targetFighter.isPlayer ? 'Player' : 'AI'}! Damage: ${damage}, Remaining health: ${targetFighter.health}`); } // Create explosion effect this.scene.add.circle(bomb.position.x, bomb.position.y, explosionRadius, 0xFFA500, 0.5) .setDepth(this.scene.DEPTH.PROJECTILE + 1) .setAlpha(0.8) .setScale(0) .setBlendMode(Phaser.BlendModes.SCREEN); this.scene.tweens.add({ targets: this.scene.children.getAll().pop(), scale: 1, alpha: 0, duration: 300, ease: 'Power2', onComplete: (tween, targets) => { targets[0].destroy(); } }); // Remove the bomb this.scene.matter.world.remove(bomb); } updateBombs() { this.scene.matter.world.getAllBodies().forEach(body => { if (body.isBomb) { const screenWidth = this.scene.game.config.width; const screenHeight = this.scene.game.config.height; const bombRadius = body.radius; // Check for collision with screen edges if (body.position.x - bombRadius < 0 || body.position.x + bombRadius > screenWidth) { this.scene.matter.body.setVelocity(body, { x: -body.velocity.x * 0.8, y: body.velocity.y }); } if (body.position.y - bombRadius < 0 || body.position.y + bombRadius > screenHeight) { this.scene.matter.body.setVelocity(body, { x: body.velocity.x, y: -body.velocity.y * 0.8 }); } // Ensure the bomb stays within the screen const clampedX = Phaser.Math.Clamp(body.position.x, bombRadius, screenWidth - bombRadius); const clampedY = Phaser.Math.Clamp(body.position.y, bombRadius, screenHeight - bombRadius); this.scene.matter.body.setPosition(body, { x: clampedX, y: clampedY }); } }); } createBug() { if (this.bugCooldown > 0 || this.globalCooldown > 0) { console.log("Cannot create bug: on cooldown"); return; } this.bugCooldown = this.bugCooldownTime; this.globalCooldown = this.globalCooldownTime; const { x, y } = this.body.position; const screenWidth = this.scene.game.config.width; const screenHeight = this.scene.game.config.height; const groundHeight = 50; // Height of the ground platform const maxHeight = screenHeight * 0.6; // Maximum height for the bug (60% of screen height) const bug = { x: x + (this.facing * 30), y: y - 20, radius: 14, color: this.isPlayer ? 0xFF69B4 : 0x87CEFA, // Pink for player, Light Sky Blue for AI angle: Math.random() * Math.PI * 2, speed: 3, turnSpeed: 0.3, owner: this, lifespan: 240, // 4 seconds lifespan (assuming 60 FPS) update: function() { this.lifespan--; if (this.lifespan <= 0) { return false; // Remove the bug } // Update position let newX = this.x + Math.cos(this.angle) * this.speed; let newY = this.y + Math.sin(this.angle) * this.speed; // Bounce off screen edges if (newX - this.radius < 0 || newX + this.radius > screenWidth) { this.angle = Math.PI - this.angle; newX = Phaser.Math.Clamp(newX, this.radius, screenWidth - this.radius); } // Bounce off the top if it goes too high if (newY - this.radius < screenHeight - maxHeight) { this.angle = -this.angle; newY = screenHeight - maxHeight + this.radius; } // Bounce off the ground if (newY + this.radius > screenHeight - groundHeight) { this.angle = -this.angle; newY = screenHeight - groundHeight - this.radius; } this.x = newX; this.y = newY; // Randomly change direction with increased probability if (Math.random() < 0.1) { this.angle += (Math.random() - 0.5) * Math.PI; } // Check for collision with the opposing fighter const opposingFighter = this.owner.isPlayer ? this.owner.scene.fighter2 : this.owner.scene.fighter1; const dx = this.x - opposingFighter.body.position.x; const dy = this.y - opposingFighter.body.position.y; const distance = Math.sqrt(dx * dx + dy * dy); const fighterWidth = 40; const fighterHeight = 80; // Check if the bug is within the fighter's bounding box if (Math.abs(dx) < (this.radius + fighterWidth / 2) && Math.abs(dy) < (this.radius + fighterHeight / 2)) { opposingFighter.health -= 60; console.log(`Bug hit! Damage: 60, Remaining health: ${opposingFighter.health}`); return false; // Remove the bug after collision } return true; // Keep updating this bug } }; // Add the bug to a new array in the scene for tracking and updating if (!this.scene.bugs) { this.scene.bugs = []; } this.scene.bugs.push(bug); } isTooClose(otherFighter) { const dx = otherFighter.body.position.x - this.body.position.x; const dy = otherFighter.body.position.y - this.body.position.y; const distance = Math.sqrt(dx * dx + dy * dy); return distance < 80; // Adjust this value as needed } isNearBomb() { const bombDetectionRadius = 100; // Adjust as needed return this.scene.matter.world.getAllBodies().some(body => { if (body.isBomb) { const dx = body.position.x - this.body.position.x; const dy = body.position.y - this.body.position.y; const distance = Math.sqrt(dx * dx + dy * dy); return distance < bombDetectionRadius; } return false; }); } shouldFaceBackToPlayer() { return this.spikesExtended && !this.isPlayer; } updateFacing(otherFighter) { if (this.shouldFaceBackToPlayer()) { this.facing = this.body.position.x < otherFighter.body.position.x ? -1 : 1; } else { this.facing = this.body.position.x < otherFighter.body.position.x ? 1 : -1; } } defensiveBehavior(otherFighter, distance) { this.updateFacing(otherFighter); if (this.isNearEdge()) { this.moveTowards(otherFighter); // Move back to center } else if (this.isTooClose(otherFighter)) { if (this.spikesCooldown <= 0 && Math.random() < 0.6) { // 60% chance to use back spikes when too close this.extendSpikes(); } else if (this.shouldFaceBackToPlayer()) { this.moveTowards(otherFighter); } else { this.moveAway(otherFighter); } } else if (distance < 200) { if (this.electricCircleCooldown <= 0) { this.createElectricCircle(); } else if (this.spikesCooldown <= 0 && Math.random() < 0.4) { // 40% chance to use back spikes at medium range this.extendSpikes(); } else if (this.shouldFaceBackToPlayer()) { this.moveTowards(otherFighter); } else { this.moveAway(otherFighter); } } else { if (this.fireworkCooldown <= 0) { this.launchFirework(); } else if (this.lightningCooldown <= 0) { this.createLightning(); } else if (this.spikesCooldown <= 0 && Math.random() < 0.2) { // 20% chance to use back spikes at long range this.extendSpikes(); } else if (Math.random() < 0.6) { // 60% chance to move instead of shooting this.moveTowards(otherFighter); } else { this.shootParticle(); } } } aggressiveBehavior(otherFighter, distance) { this.updateFacing(otherFighter); if (this.isNearEdge()) { this.moveTowards(otherFighter); // Move back to center } else if (this.isTooClose(otherFighter)) { if (this.spikesCooldown <= 0 && Math.random() < 0.7) { // 70% chance to use back spikes when too close this.extendSpikes(); } else if (this.shouldFaceBackToPlayer()) { this.moveTowards(otherFighter); } else if (Math.random() < 0.7) { // 70% chance to attack when close this.shootParticle(); } else { this.moveAway(otherFighter); } } else if (distance < 350) { if (this.missileCooldown <= 0) { this.fireHomingMissile(otherFighter); } else if (this.spikedBallCooldown <= 0) { this.rollSpikedBall(); } else if (this.spikesCooldown <= 0 && Math.random() < 0.5) { // 50% chance to use back spikes at medium range this.extendSpikes(); } else { this.moveTowards(otherFighter); } } else { if (this.bugCooldown <= 0) { this.createBug(); } else if (this.bouncingBallCooldown <= 0) { this.launchBouncingBall(); } else if (this.spikesCooldown <= 0 && Math.random() < 0.3) { // 30% chance to use back spikes at long range this.extendSpikes(); } else if (Math.random() < 0.8) { // 80% chance to move when far this.moveTowards(otherFighter); } else { this.shootParticle(); } } } balancedBehavior(otherFighter, distance) { this.updateFacing(otherFighter); if (this.isNearBomb()) { // Prioritize moving away from bombs const nearestBomb = this.findNearestBomb(); if (nearestBomb) { const moveDirection = this.body.position.x < nearestBomb.position.x ? -1 : 1; this.scene.matter.body.setVelocity(this.body, { x: moveDirection * 5, y: this.body.velocity.y }); if (this.isOnGround()) { this.jump(); } } } else if (this.isNearEdge()) { this.moveTowards(otherFighter); // Move back to center } else if (this.isTooClose(otherFighter)) { this.handleCloseRange(otherFighter); } else if (distance < 400) { this.handleMediumRange(otherFighter); } else { this.handleLongRange(otherFighter); } } findNearestBomb() { let nearestBomb = null; let shortestDistance = Infinity; this.scene.matter.world.getAllBodies().forEach(body => { if (body.isBomb) { const dx = body.position.x - this.body.position.x; const dy = body.position.y - this.body.position.y; const distance = Math.sqrt(dx * dx + dy * dy); if (distance < shortestDistance) { shortestDistance = distance; nearestBomb = body; } } }); return nearestBomb; } handleCloseRange(otherFighter) { const actions = [{ action: () => this.extendSpikes(), weight: 2, cooldown: this.spikesCooldown }, { action: () => this.createElectricCircle(), weight: 2, cooldown: this.electricCircleCooldown }, { action: () => this.shootParticle(), weight: 1, cooldown: this.attackCooldown }, { action: () => this.moveAway(otherFighter), weight: 1, cooldown: 0 }, { action: () => this.launchBouncingBall(), weight: 2, cooldown: this.bouncingBallCooldown }, { action: () => this.dropBomb(), weight: 2, cooldown: this.bombCooldown }]; this.performWeightedAction(actions); } handleMediumRange(otherFighter) { const actions = [{ action: () => this.fireHomingMissile(otherFighter), weight: 2, cooldown: this.missileCooldown }, { action: () => this.createLightning(), weight: 2, cooldown: this.lightningCooldown }, { action: () => this.launchFirework(), weight: 2, cooldown: this.fireworkCooldown }, { action: () => this.extendSpikes(), weight: 1, cooldown: this.spikesCooldown }, { action: () => this.moveTowards(otherFighter), weight: 3, cooldown: 0 }, { action: () => this.shootParticle(), weight: 1, cooldown: this.attackCooldown }, { action: () => this.launchBouncingBall(), weight: 3, cooldown: this.bouncingBallCooldown }, { action: () => this.dropBomb(), weight: 2, cooldown: this.bombCooldown }]; this.performWeightedAction(actions); } handleLongRange(otherFighter) { const actions = [{ action: () => this.moveTowards(otherFighter), weight: 3, cooldown: 0 }, { action: () => this.createBug(), weight: 2, cooldown: this.bugCooldown }, { action: () => this.launchBouncingBall(), weight: 3, cooldown: this.bouncingBallCooldown }, { action: () => this.rollSpikedBall(), weight: 2, cooldown: this.spikedBallCooldown }, { action: () => this.extendSpikes(), weight: 1, cooldown: this.spikesCooldown }, { action: () => this.shootParticle(), weight: 1, cooldown: this.attackCooldown }]; this.performWeightedAction(actions); } performWeightedAction(actions) { const availableActions = actions.filter(action => this.isActionAvailable(action.cooldown)); if (availableActions.length === 0) { // If no action is available, just move this.moveTowards(this.scene.fighter1); return; } const totalWeight = availableActions.reduce((sum, action) => sum + action.weight, 0); let random = Math.random() * totalWeight; for (let action of availableActions) { if (random < action.weight) { action.action(); return; } random -= action.weight; } // Fallback: perform the last available action availableActions[availableActions.length - 1].action(); } isActionAvailable(cooldown) { const relativeCooldown = cooldown / this.masterCooldown; return relativeCooldown <= 0.1 || Math.random() < 0.2; // 20% chance to use an action even if on cooldown } intelligentJumping(otherFighter) { const projectiles = this.scene.matter.world.getAllBodies().filter(body => body.owner !== this && (body.circleRadius || (body.width && body.height)) ); const nearbyProjectile = projectiles.find(projectile => { const dx = projectile.position.x - this.body.position.x; const dy = projectile.position.y - this.body.position.y; return Math.sqrt(dx * dx + dy * dy) < 100 && dy > 0; }); if (nearbyProjectile && this.isOnGround() && Math.random() < 0.8) { this.jump(); } else if (this.isOnGround() && Math.random() < 0.05) { this.jump(); } } isOnGround() { const groundY = this.scene.game.config.height - 50; // Assuming ground height is 50 return Math.abs(this.body.position.y + 40 - groundY) < 1; // 40 is half the height of the fighter } predictiveAiming(otherFighter) { const dx = otherFighter.body.position.x - this.body.position.x; const dy = otherFighter.body.position.y - this.body.position.y; const distance = Math.sqrt(dx * dx + dy * dy); if (distance > 200 && distance < 400) { const predictedX = otherFighter.body.position.x + otherFighter.body.velocity.x * 30; const predictedY = otherFighter.body.position.y + otherFighter.body.velocity.y * 30; if (this.missileCooldown <= 0) { this.fireHomingMissile({ body: { position: { x: predictedX, y: predictedY } } }); } else if (this.lightningCooldown <= 0) { this.createLightning(predictedX); } } } createLightning(targetX = null) { if (this.lightningCooldown > 0 || this.globalCooldown > 0) { console.log("Cannot create lightning: on cooldown"); return; } this.lightningCooldown = 90; // 1.5 seconds cooldown this.globalCooldown = this.globalCooldownTime; const { x } = this.body.position; const lightningX = targetX || x + (this.facing * 150); // Use targetX if provided, otherwise 150 pixels ahead of the fighter const lightningStartY = 0; // Start from the top of the screen const lightningEndY = this.scene.game.config.height - 70; // End near the ground, adjusted for ground height const lightningColor = this.isPlayer ? 0xFFFF00 : 0x00FFFF; // Yellow for player, Lightning blue for AI const lightningPath = this.drawLightning(lightningX, lightningStartY, lightningEndY, lightningColor); // Reset the last lightning strike flag this.lastLightningStrike = this.scene.time.now; // Check if lightning hits the other fighter const otherFighter = this.isPlayer ? this.scene.fighter2 : this.scene.fighter1; const hitBox = new Phaser.Geom.Rectangle( otherFighter.body.position.x - 20, otherFighter.body.position.y - 40, 40, 80 ); let hit = false; for (let i = 1; i < lightningPath.length; i++) { const line = new Phaser.Geom.Line( lightningPath[i - 1].x, lightningPath[i - 1].y, lightningPath[i].x, lightningPath[i].y ); if (Phaser.Geom.Intersects.LineToRectangle(line, hitBox)) { hit = true; break; } } if (hit && otherFighter.lastLightningStrike !== this.lastLightningStrike) { const damage = Math.round(66 * 1.5 * 0.82 * 0.87); // Increased damage by 50%, then reduced by 18%, then reduced by additional 13% otherFighter.health -= damage; otherFighter.lastLightningStrike = this.lastLightningStrike; console.log(`Lightning hit! Damage: ${damage}, Remaining health: ${otherFighter.health}`); } else { console.log("Lightning missed!"); } } drawLightning(x, startY, endY, color) { const graphics = this.scene.add.graphics(); graphics.lineStyle(4, color, 1); const segments = 10; const segmentHeight = (endY - startY) / segments; let prevX = x; let prevY = startY; const path = [{ x: prevX, y: prevY }]; for (let i = 1; i <= segments; i++) { const newX = x + (Math.random() * 40 - 20); const newY = startY + (segmentHeight * i); graphics.moveTo(prevX, prevY); graphics.lineTo(newX, newY); prevX = newX; prevY = newY; path.push({ x: newX, y: newY }); } graphics.strokePath(); // Fade out and destroy the lightning effect this.scene.tweens.add({ targets: graphics, alpha: 0, duration: 200, onComplete: () => { graphics.destroy(); } }); return path; } explodeFirework(firework) { const particleCount = 30; const particleSpeed = 3; for (let i = 0; i < particleCount; i++) { const angle = (Math.PI * 2 / particleCount) * i; const particleX = firework.position.x + Math.cos(angle) * 5; const particleY = firework.position.y + Math.sin(angle) * 5; const particle = this.scene.matter.add.circle(particleX, particleY, 4, { friction: 0, frictionAir: 0.01, restitution: 0.8, isSensor: true, collisionFilter: { category: 0x0004, mask: 0x0002 // Can collide with fighters } }); particle.depth = this.scene.DEPTH.PROJECTILE; // Set particle color based on the owner if (this.isPlayer) { particle.fillColor = Phaser.Math.Between(0xFF0000, 0xFF8080); // Shades of red } else { particle.fillColor = Phaser.Math.Between(0x0000FF, 0x8080FF); // Shades of blue } particle.owner = this; this.scene.matter.body.setVelocity(particle, { x: Math.cos(angle) * particleSpeed, y: Math.sin(angle) * particleSpeed }); // Set a timer to remove the particle after 1.5 seconds this.scene.time.delayedCall(1500, () => { this.scene.matter.world.remove(particle); }); } // Remove the main firework this.scene.matter.world.remove(firework); } launchFirework() { if (this.fireworkCooldown > 0 || this.globalCooldown > 0) { console.log("Cannot launch firework: on cooldown"); return; } this.fireworkCooldown = 180; // 3 seconds cooldown (assuming 60 FPS) this.globalCooldown = this.globalCooldownTime; const { x, y } = this.body.position; const fireworkX = x; const fireworkY = y - 40; // Launch from the top of the fighter's head const firework = this.scene.matter.add.circle(fireworkX, fireworkY, 5, { friction: 0, frictionAir: 0.01, // Reduced air friction restitution: 0.3, isSensor: true, collisionFilter: { category: 0x0004, mask: 0x0000 // Doesn't collide with anything } }); firework.depth = this.scene.DEPTH.PROJECTILE; firework.fillColor = this.isPlayer ? 0xFF0000 : 0x0000FF; // Red for player, Blue for AI firework.isFirework = true; const launchAngle = -Math.PI / 2; // Straight up const launchSpeed = 15; // Increased launch speed this.scene.matter.body.setVelocity(firework, { x: Math.cos(launchAngle) * launchSpeed, y: Math.sin(launchAngle) * launchSpeed }); // Set up a check to explode the firework at its peak or if it goes above the ceiling let lastY = firework.position.y; const checkHeight = () => { if (firework.position.y > lastY || firework.position.y <= 0) { // Firework has reached its peak, is now falling, or has gone above the ceiling this.explodeFirework(firework); heightCheck.remove(); // Stop checking } else { lastY = firework.position.y; } }; const heightCheck = this.scene.time.addEvent({ delay: 16, // Check every frame (assuming 60 FPS) callback: checkHeight, loop: true }); // Fallback timer in case the firework doesn't reach a peak (e.g., if it goes off-screen) this.scene.time.delayedCall(1000, () => { if (firework.active) { this.explodeFirework(firework); heightCheck.remove(); } }); } rollSpikedBall() { if (this.spikedBallCooldown > 0 || this.globalCooldown > 0) { console.log("Cannot roll spiked ball: on cooldown"); return; } this.spikedBallCooldown = 120; // 2 seconds cooldown (assuming 60 FPS) this.globalCooldown = this.globalCooldownTime; const { x, y } = this.body.position; const ballRadius = 15; const ballX = x + (this.facing * 20); // Start 20 pixels in front of the fighter const ballY = y + 40; // Start at the fighter's feet (assuming fighter height is 80) const groundY = this.scene.game.config.height - 50; // Assuming ground height is 50 const spikedBall = { x: ballX, y: ballY, radius: ballRadius, velocityX: this.facing * 2.5, // Reduced speed by half velocityY: 0, owner: this, fillColor: this.isPlayer ? 0xFF0000 : 0x0000FF, // Red for player, Blue for AI rotation: 0, update: function() { this.x += this.velocityX; this.y = groundY - this.radius; // Keep the ball on the ground this.rotation += 0.05 * Math.sign(this.velocityX); // Reduced rotation speed // Check for collision with fighters let hit = false; [this.owner.scene.fighter1, this.owner.scene.fighter2].forEach(fighter => { if (fighter !== this.owner) { const dx = fighter.body.position.x - this.x; const dy = fighter.body.position.y - this.y; const distance = Math.sqrt(dx * dx + dy * dy); if (distance < this.radius + 20) { // 20 is half the width of a fighter fighter.health -= 50; // Doubled damage to 50 console.log(`Spiked ball hit! Damage: 50, Remaining health: ${fighter.health}`); hit = true; } } }); // Remove the ball if it goes off-screen or hits a fighter if (this.x < -this.radius || this.x > this.owner.scene.game.config.width + this.radius || hit) { return false; } return true; } }; this.scene.spikedBalls.push(spikedBall); // Create a non-physical object to represent the bouncing ball const bouncingBall = { x: ballX, y: ballY, radius: ballRadius, velocityX: 0, // Initial horizontal speed is 0 velocityY: 0, // Initial vertical speed is 0 owner: this, isBouncingBall: true, fillColor: this.isPlayer ? 0xFF0000 : 0x0000FF, // Red for player, Blue for AI rotation: 0, // Add rotation property isDropping: true, // New property to track if the ball is still dropping initialFacing: this.facing, // Store the initial facing direction update: function() { if (this.isDropping) { // Apply gravity this.velocityY += 0.5; this.y += this.velocityY; // Check if the ball has reached the ground if (this.y + this.radius >= groundY) { this.y = groundY - this.radius; this.isDropping = false; this.velocityX = this.initialFacing * 5; // Start rolling } } else { // Regular rolling update this.x += this.velocityX; // Update rotation based on movement direction this.rotation += (this.velocityX > 0 ? 1 : -1) * 0.1; // Rotate based on direction } // Check for collision with the opposing fighter const opposingFighter = this.owner.isPlayer ? this.owner.scene.fighter2 : this.owner.scene.fighter1; const dx = this.x - opposingFighter.body.position.x; const dy = this.y - opposingFighter.body.position.y; const distance = Math.sqrt(dx * dx + dy * dy); if (distance < this.radius + 20) { // 20 is half the width of a fighter // Deal damage to the opposing fighter const damage = 30; // Adjusted damage for bouncing ball opposingFighter.health -= damage; console.log(`Bouncing ball hit! Damage: ${damage}, Remaining health: ${opposingFighter.health}`); // Remove the bouncing ball const index = this.owner.scene.bouncingBalls.indexOf(this); if (index > -1) { this.owner.scene.bouncingBalls.splice(index, 1); } return; // Exit the update function as the ball is destroyed } // Check if the ball is off-screen if (this.x < -this.radius || this.x > this.owner.scene.game.config.width + this.radius) { // Remove the ball from the scene const index = this.owner.scene.bouncingBalls.indexOf(this); if (index > -1) { this.owner.scene.bouncingBalls.splice(index, 1); } } } }; // Add the bouncing ball to a new array in the scene for tracking and updating if (!this.scene.bouncingBalls) { this.scene.bouncingBalls = []; } this.scene.bouncingBalls.push(bouncingBall); } } class Example extends Phaser.Scene { static aiCooldown = 120; // Initial cooldown of 2 seconds (120 frames) constructor() { super(); this.roundNumber = 0; this.groundColor = 0x3E2723; // Dark wood color this.enemyCooldownText = null; // New property to store the cooldown text object // Define depth constants this.DEPTH = { BACKGROUND: 0, TERRAIN: 10, FIGHTER: 20, PROJECTILE: 30, UI: 40 }; this.healthBar1 = null; this.healthBar2 = null; this.spikedBalls = []; // Initialize spikedBalls array this.bestClear = 0 } addAttackList() { const attacks = [ '1: Spit Ball', '2: Electric Circle', '3: Back Spikes', '4: Homing Spike', '5: Bomb', '6: Lightning', '7: Firework', '8: Spiked Ball', '9: Bouncy Ball', '0: Bug Ball' ]; this.attackTexts = attacks.map((attack, index) => { return this.add.text(10, 10 + index * 20, attack, { fontSize: '12px', fill: '#ffffff' }).setDepth(this.DEPTH.UI); }); } updateAttackList() { const cooldowns = [ this.fighter1.attackCooldown, this.fighter1.electricCircleCooldown, this.fighter1.spikesCooldown, this.fighter1.missileCooldown, this.fighter1.bombCooldown, this.fighter1.lightningCooldown, this.fighter1.fireworkCooldown, this.fighter1.spikedBallCooldown, this.fighter1.bouncingBallCooldown, this.fighter1.bugCooldown ]; this.attackTexts.forEach((text, index) => { if (cooldowns[index] > 0 || this.fighter1.globalCooldown > 0) { text.setAlpha(0.5).setTint(0x808080); } else { text.setAlpha(1).setTint(0xffffff); } }); } preload() { // No need to preload background image anymore } create() { // Clear all existing objects this.matter.world.resetCollisionIDs(); this.matter.world.getAllBodies().forEach(body => { this.matter.world.remove(body); }); this.children.removeAll(); // Reset arrays and properties this.bouncingBalls = []; this.spikedBalls = []; this.bugs = []; this.roundNumber++; console.log(`Round ${this.roundNumber} started`); // Add dark blue background this.add.rectangle(400, 300, 800, 600, 0x000033); // Add S key for electric circle this.key2 = this.input.keyboard.addKey(Phaser.Input.Keyboard.KeyCodes.TWO); // Add 1 key for bullet balls (particle attack) this.key1 = this.input.keyboard.addKey(Phaser.Input.Keyboard.KeyCodes.ONE); // Add 3 key for back spikes this.key3 = this.input.keyboard.addKey(Phaser.Input.Keyboard.KeyCodes.THREE); // Add the attack list this.addAttackList(); // Create graphics object for drawing this.graphics = this.add.graphics(); // Add a dark wood colored ground platform const groundHeight = 50; const ground = this.add.rectangle(this.game.config.width / 2, this.game.config.height - groundHeight / 2, this.game.config.width, groundHeight, this.groundColor); this.matter.add.gameObject(ground, { isStatic: true, friction: 0.5, collisionFilter: { category: 0x0001 } }); ground.setDepth(this.DEPTH.TERRAIN); // Calculate the y-position for the fighters to be on the ground const fighterY = this.game.config.height - groundHeight - 40; // 40 is half the height of the fighter // Create two fighters on the ground, at opposite ends of the screen const margin = 50; // Distance from the edge of the screen this.fighter1 = new Fighter(this, margin, fighterY, true); // Red fighter is player-controlled this.fighter2 = new Fighter(this, this.game.config.width - margin, fighterY, false); // AI-controlled blue fighter this.fighter1.body.depth = this.DEPTH.FIGHTER; this.fighter2.body.depth = this.DEPTH.FIGHTER; // Set the AI's cooldown this.fighter2.globalCooldownTime = Example.aiCooldown; this.fighter2.masterCooldown = Example.aiCooldown; // Set initial facing direction for both fighters this.fighter1.facing = 1; // Facing right this.fighter2.facing = -1; // Facing left // Set initial move direction for both fighters this.fighter1.moveDirection = 1; this.fighter2.moveDirection = -1; // Reset cooldowns for both fighters this.fighter1.resetCooldowns(); this.fighter2.resetCooldowns(); // Setup input this.cursors = this.input.keyboard.createCursorKeys(); this.key4 = this.input.keyboard.addKey(Phaser.Input.Keyboard.KeyCodes.FOUR); this.key5 = this.input.keyboard.addKey(Phaser.Input.Keyboard.KeyCodes.FIVE); this.key6 = this.input.keyboard.addKey(Phaser.Input.Keyboard.KeyCodes.SIX); this.key7 = this.input.keyboard.addKey(Phaser.Input.Keyboard.KeyCodes.SEVEN); this.key8 = this.input.keyboard.addKey(Phaser.Input.Keyboard.KeyCodes.EIGHT); this.key9 = this.input.keyboard.addKey(Phaser.Input.Keyboard.KeyCodes.NINE); this.key0 = this.input.keyboard.addKey(Phaser.Input.Keyboard.KeyCodes.ZERO); // Create health bars const barWidth = 200; const barHeight = 20; const barMargin = 10; this.healthBar1 = this.add.rectangle(this.game.config.width - barMargin - barWidth / 2, barMargin + barHeight / 2, barWidth, barHeight, 0xff0000).setOrigin(0.5, 0.5); this.healthBar2 = this.add.rectangle(this.game.config.width - barMargin - barWidth / 2, barMargin * 2 + barHeight * 1.5, barWidth, barHeight, 0x0000ff).setOrigin(0.5, 0.5); this.healthBar1.setDepth(this.DEPTH.UI); this.healthBar2.setDepth(this.DEPTH.UI); // Create difficulty text this.enemyCooldownText = this.add.text(400, 10, 'Difficulty: 0.00', { fontSize: '16px', fill: '#ffffff' }).setOrigin(0.5, 0).setDepth(this.DEPTH.UI); // Create best clear text this.bestClearText = this.add.text(400, 30, 'Best Clear: 0', { fontSize: '16px', fill: '#ffffff' }).setOrigin(0.5, 0).setDepth(this.DEPTH.UI); // Create controls instructions text this.controlsText = this.add.text(400, 30, 'Arrow keys to move. Number keys to attack.', { fontSize: '12px', fill: '#ffffff' }).setOrigin(0.5, -1.3).setDepth(this.DEPTH.UI); } update() { // Clear previous drawings this.graphics.clear(); // Update and draw fighters this.fighter1.update(this.fighter2); this.fighter2.update(this.fighter1); this.fighter1.draw(); this.fighter2.draw(); // Update the attack list colors this.updateAttackList(); // Update bombs this.fighter1.updateBombs(); this.fighter2.updateBombs(); // Destroy off-screen objects (except bombs) this.destroyOffscreenObjects(); // Update and draw spiked balls this.spikedBalls = this.spikedBalls.filter(ball => { const keepBall = ball.update(); if (keepBall) { this.graphics.fillStyle(ball.fillColor); this.graphics.fillCircle(ball.x, ball.y, ball.radius); // Draw spikes const spikeCount = 8; const spikeLength = 5; for (let i = 0; i < spikeCount; i++) { const angle = (Math.PI * 2 / spikeCount) * i + ball.rotation; const spikeX = ball.x + Math.cos(angle) * (ball.radius + spikeLength); const spikeY = ball.y + Math.sin(angle) * (ball.radius + spikeLength); this.graphics.lineBetween(ball.x, ball.y, spikeX, spikeY); } } return keepBall; }); // Handle 2 key press for electric circle if (Phaser.Input.Keyboard.JustDown(this.key2)) { this.fighter1.createElectricCircle(); } // Handle 1 key press for bullet balls (particle attack) if (Phaser.Input.Keyboard.JustDown(this.key1)) { this.fighter1.shootParticle(); } // Handle 3 key press for back spikes if (Phaser.Input.Keyboard.JustDown(this.key3)) { this.fighter1.extendSpikes(); } // Check for collisions this.fighter1.checkCollisions(this.fighter2); this.fighter2.checkCollisions(this.fighter1); // Draw particles and missiles this.matter.world.getAllBodies().forEach(body => { if (body.circleRadius === 10) { // Regular particles this.graphics.fillStyle(body.fillColor); this.graphics.fillCircle(body.position.x, body.position.y, body.circleRadius); } else if (body.width && body.height) { // Missiles this.graphics.fillStyle(body.fillColor); const angle = body.angle; const halfWidth = body.width / 2; const halfHeight = body.height / 2; // Calculate triangle points const point1 = { x: body.position.x + Math.cos(angle) * halfWidth, y: body.position.y + Math.sin(angle) * halfWidth }; const point2 = { x: body.position.x - Math.cos(angle) * halfWidth + Math.sin(angle) * halfHeight, y: body.position.y - Math.sin(angle) * halfWidth - Math.cos(angle) * halfHeight }; const point3 = { x: body.position.x - Math.cos(angle) * halfWidth - Math.sin(angle) * halfHeight, y: body.position.y - Math.sin(angle) * halfWidth + Math.cos(angle) * halfHeight }; // Draw triangle this.graphics.fillTriangle( point1.x, point1.y, point2.x, point2.y, point3.x, point3.y ); } else if (body.isBomb) { // Bombs const centerX = body.position.x; const centerY = body.position.y; const radius = body.radius; // Draw the grey half this.graphics.fillStyle(0x808080); this.graphics.fillCircle(centerX, centerY, radius); // Draw the colored half this.graphics.fillStyle(body.isPlayerBomb ? 0xFF0000 : 0x0000FF); this.graphics.beginPath(); this.graphics.arc(centerX, centerY, radius, -Math.PI / 2, Math.PI / 2); this.graphics.lineTo(centerX, centerY); this.graphics.closePath(); this.graphics.fillPath(); } else if (body.circleRadius === 5 || body.circleRadius === 4) { // Firework particles this.graphics.fillStyle(body.fillColor); this.graphics.fillCircle(body.position.x, body.position.y, body.circleRadius); } else if (body.isBouncingBall) { // Bouncing balls this.graphics.fillStyle(body.fillColor); this.graphics.fillCircle(body.position.x, body.position.y, body.circleRadius); } }); // Update cooldowns if (this.fighter1.fireworkCooldown > 0) this.fighter1.fireworkCooldown--; if (this.fighter2.fireworkCooldown > 0) this.fighter2.fireworkCooldown--; if (this.fighter1.bouncingBallCooldown > 0) this.fighter1.bouncingBallCooldown--; if (this.fighter2.bouncingBallCooldown > 0) this.fighter2.bouncingBallCooldown--; // Handle 4 key press for homing missile if (Phaser.Input.Keyboard.JustDown(this.key4)) { this.fighter1.fireHomingMissile(this.fighter2); } // Handle 5 key press for dropping a bomb if (Phaser.Input.Keyboard.JustDown(this.key5)) { this.fighter1.dropBomb(); } // Handle 6 key press for creating lightning if (Phaser.Input.Keyboard.JustDown(this.key6)) { this.fighter1.createLightning(); } // Handle 7 key press for launching a firework if (Phaser.Input.Keyboard.JustDown(this.key7)) { this.fighter1.launchFirework(); } // Handle 8 key press for rolling a spiked ball if (Phaser.Input.Keyboard.JustDown(this.key8)) { this.fighter1.rollSpikedBall(); } // Handle 9 key press for launching a bouncing ball if (Phaser.Input.Keyboard.JustDown(this.key9)) { this.fighter1.launchBouncingBall(); } // Handle 0 key press for creating a bug if (Phaser.Input.Keyboard.JustDown(this.key0)) { this.fighter1.createBug(); } // Update health bars this.healthBar1.width = (this.fighter1.health / 1000) * 200; this.healthBar2.width = (this.fighter2.health / 1000) * 200; // Update and draw spiked balls if (this.spikedBalls) { this.spikedBalls = this.spikedBalls.filter(ball => { if (ball.update()) { this.graphics.fillStyle(ball.fillColor); this.graphics.fillCircle(ball.x, ball.y, ball.radius); // Draw spikes const spikeCount = 8; const spikeLength = 5; for (let i = 0; i < spikeCount; i++) { const angle = (Math.PI * 2 / spikeCount) * i + ball.rotation; const spikeX = ball.x + Math.cos(angle) * (ball.radius + spikeLength); const spikeY = ball.y + Math.sin(angle) * (ball.radius + spikeLength); this.graphics.lineBetween(ball.x, ball.y, spikeX, spikeY); } // Draw an indicator for rotation direction const indicatorAngle = ball.rotation; const indicatorLength = ball.radius * 0.8; const indicatorX = ball.x + Math.cos(indicatorAngle) * indicatorLength; const indicatorY = ball.y + Math.sin(indicatorAngle) * indicatorLength; this.graphics.lineStyle(2, 0xFFFF00); this.graphics.lineBetween(ball.x, ball.y, indicatorX, indicatorY); return true; } return false; }); } // Update bouncing balls if (this.bouncingBalls) { this.bouncingBalls = this.bouncingBalls.filter(ball => ball.update(this)); this.bouncingBalls.forEach(ball => { this.graphics.fillStyle(ball.fillColor); this.graphics.fillCircle(ball.x, ball.y, ball.radius); }); } // Update and draw bugs if (this.bugs) { this.bugs = this.bugs.filter(bug => { const keepBug = bug.update(); if (keepBug) { this.graphics.fillStyle(bug.color || 0xFF69B4); this.graphics.fillCircle(bug.x, bug.y, bug.radius); // Add details to make the bug more interesting this.graphics.fillStyle(0xFFFFFF); this.graphics.fillCircle(bug.x + Math.cos(bug.angle) * 5, bug.y + Math.sin(bug.angle) * 5, 3); this.graphics.fillCircle(bug.x + Math.cos(bug.angle + 0.5) * 5, bug.y + Math.sin(bug.angle + 0.5) * 5, 3); } return keepBug; }); } // Update difficulty text const difficultyValue = Math.round((10 - Example.aiCooldown / 60) * 100); this.enemyCooldownText.setText(`Difficulty: ${difficultyValue}`); this.enemyCooldownText.x = this.game.config.width / 2; // Update best clear text this.bestClearText.setText(`Best Clear: ${this.bestClear}`); this.bestClearText.x = this.game.config.width / 2; // Check for game over if (this.fighter1.health <= 0 || this.fighter2.health <= 0) { console.log(`Round ${this.roundNumber} ended.`); const winner = this.fighter1.health > 0 ? this.fighter1 : this.fighter2; this.adjustEnemyCooldown(winner); this.scene.restart(); } } adjustEnemyCooldown(winner) { let adjustment; if (winner === this.fighter1) { // Player won const playerHealthPercentage = (this.fighter1.health / 1000) * 100; adjustment = -(playerHealthPercentage / 100); // Subtract player's remaining health percentage / 100 // Update best clear const currentDifficulty = Math.round((10 - Example.aiCooldown / 60) * 100); this.bestClear = Math.max(this.bestClear, currentDifficulty); } else { // AI won const aiHealthPercentage = (this.fighter2.health / 1000) * 100; adjustment = aiHealthPercentage / 100; // Add AI's remaining health percentage / 100 } // Adjust the AI's cooldown (in seconds), ensuring a minimum of 0.1 seconds Example.aiCooldown = Math.max(6, Example.aiCooldown + adjustment * 60); // Convert seconds to frames, minimum 6 frames (0.1s) console.log(`AI cooldown adjusted by ${adjustment.toFixed(2)} seconds. New cooldown: ${(Example.aiCooldown / 60).toFixed(2)} seconds`); } destroyOffscreenObjects() { this.matter.world.getAllBodies().forEach(body => { if (body !== this.fighter1.body && body !== this.fighter2.body && !body.isBomb) { const x = body.position.x; const y = body.position.y; const radius = body.circleRadius || 0; const isFireworkParticle = body.circleRadius === 4; if (x + radius < 0 || x - radius > this.game.config.width || (!isFireworkParticle && y + radius < 0) || y - radius > this.game.config.height) { this.matter.world.remove(body); } } }); } } const config = { type: Phaser.AUTO, width: 800, height: 600, parent: 'renderDiv', scale: { mode: Phaser.Scale.FIT, autoCenter: Phaser.Scale.CENTER_BOTH }, physics: { default: 'matter', matter: { gravity: { y: 1 }, debug: false, airFriction: 0.02 } }, scene: Example }; const game = new Phaser.Game(config);