class MainScene extends Phaser.Scene { constructor() { super('MainScene'); this.playerCar = null; this.aiCars = []; this.cursors = null; this.speed = 0; this.acceleration = 0.15; this.deceleration = 0.075; this.maxSpeed = 4.5; this.maxReverseSpeed = this.maxSpeed * 0.75; this.turnSpeed = 0.04; this.circles = []; this.bottomSquare = null; this.topSquare = null; this.leftSquare = null; this.rightSquare = null; this.scores = { blue: 0, green: 0, red: 0, purple: 0 }; this.scoreTexts = {}; this.tethers = []; this.gameTimer = 75; // 1:15 in seconds this.timerText = null; this.circleCountText = null; this.enemySpeedText = null; this.roundNumber = 1; this.roundScores = []; // Store scores for each round this.scoredCircles = []; // New array to store scored circles this.teamFormations = {}; // Store team formations this.bestDifficulty = 0; // Initialize best difficulty to 0 this.winningTeam = null; // Track the currently winning team // Audio-related properties this.audioContext = null; this.masterGainNode = null; this.oscillators = []; this.lastNoteTime = 0; this.noteDuration = 2; // Duration of each note in seconds this.noteInterval = 0.5; // Time between notes in seconds } initAudio() { this.audioContext = new(window.AudioContext || window.webkitAudioContext)(); this.masterGainNode = this.audioContext.createGain(); this.masterGainNode.gain.setValueAtTime(0.2, this.audioContext.currentTime); // Set volume to 0.2 this.masterGainNode.connect(this.audioContext.destination); } generateTone() { const now = this.audioContext.currentTime; if (now - this.lastNoteTime < this.noteInterval) return; // Pentatonic scale frequencies const pentatonicScale = [261.63, 293.66, 329.63, 392.00, 440.00]; const baseFrequency = pentatonicScale[Math.floor(Math.random() * pentatonicScale.length)]; const octave = Math.floor(Math.random() * 2); // 0 or 1 const frequency = baseFrequency * Math.pow(2, octave); const oscillator = this.audioContext.createOscillator(); const gainNode = this.audioContext.createGain(); const reverbNode = this.audioContext.createConvolver(); // Create reverb impulse const reverbLength = 2; const decay = 2; const impulse = this.audioContext.createBuffer(2, this.audioContext.sampleRate * reverbLength, this.audioContext.sampleRate); for (let channel = 0; channel < impulse.numberOfChannels; channel++) { const impulseData = impulse.getChannelData(channel); for (let i = 0; i < impulseData.length; i++) { impulseData[i] = (Math.random() * 2 - 1) * Math.pow(1 - i / impulseData.length, decay); } } reverbNode.buffer = impulse; oscillator.type = 'sine'; oscillator.frequency.setValueAtTime(frequency, now); // Apply smoother envelope gainNode.gain.setValueAtTime(0, now); gainNode.gain.linearRampToValueAtTime(0.3, now + 0.1); gainNode.gain.exponentialRampToValueAtTime(0.001, now + this.noteDuration); oscillator.connect(gainNode); gainNode.connect(reverbNode); reverbNode.connect(this.masterGainNode); oscillator.start(now); oscillator.stop(now + this.noteDuration); this.lastNoteTime = now; // Add some variation based on game state if (this.playerCar) { const speed = Math.abs(this.playerCar.body.velocity.x) + Math.abs(this.playerCar.body.velocity.y); this.noteInterval = Phaser.Math.Clamp(0.8 - speed / 1500, 0.3, 0.8); this.noteDuration = Phaser.Math.Clamp(1.5 - speed / 1000, 0.5, 1.5); } } updateMusic() { if (this.audioContext.state === 'suspended') { this.audioContext.resume(); } this.generateTone(); } preload() { // No preload needed as we're drawing the cars } create() { // Initialize audio this.initAudio(); const carWidth = 21.42; // Increased by 50% const carHeight = 10.71; // Increased by 50% const worldWidth = 2500; const worldHeight = 2500; const margin = 50; const gridCellSize = 100; const squareWidth = gridCellSize * 7.5; // Increased from 5 to 7.5 (1.5x) // Change the background color to a darker blue-gray const calmBlueGray = 0x455A64; // This is a darker shade of blue-gray this.cameras.main.setBackgroundColor('#455A64'); const playingField = this.add.rectangle(worldWidth / 2, worldHeight / 2, worldWidth, worldHeight, 0x708090); playingField.setDepth(-2); // Create color-coded grid this.createColorCodedGrid(worldWidth, worldHeight, gridCellSize); // Add 100 yellow circles with transparency this.createCircles(worldWidth, worldHeight, gridCellSize, squareWidth); // Create cars this.createCars(worldWidth, worldHeight, carWidth, carHeight, margin); const squareX = this.playerCar.x; const squareY = worldHeight + gridCellSize * 0.75; // Moved back to line up this.bottomSquare = this.add.rectangle(squareX, squareY, squareWidth, gridCellSize * 1.5, 0x708090); this.bottomSquare.setDepth(-2); this.bottomSquare.setAlpha(1); const topSquareY = -gridCellSize * 0.75; // Moved back to line up this.topSquare = this.add.rectangle(squareX, topSquareY, squareWidth, gridCellSize * 1.5, 0x708090); this.topSquare.setDepth(-2); this.topSquare.setAlpha(1); const leftSquareX = -gridCellSize * 0.75; // Moved back to line up this.leftSquare = this.add.rectangle(leftSquareX, worldHeight / 2, gridCellSize * 1.5, squareWidth, 0x708090); this.leftSquare.setDepth(-2); this.leftSquare.setAlpha(1); const rightSquareX = worldWidth + gridCellSize * 0.75; // Moved back to line up this.rightSquare = this.add.rectangle(rightSquareX, worldHeight / 2, gridCellSize * 1.5, squareWidth, 0x708090); this.rightSquare.setDepth(-2); this.rightSquare.setAlpha(1); this.cursors = this.input.keyboard.createCursorKeys(); this.matter.world.setBounds(-gridCellSize * 1.5, -gridCellSize * 1.5, worldWidth + 3 * gridCellSize, worldHeight + 3 * gridCellSize); // Create straight walls for the borders, excluding the new squares const wallOptions = { isStatic: true, restitution: 1.7, friction: 0, chamfer: { radius: 2 } }; const wallThickness = 40; // Increased wall thickness this.matter.add.rectangle(worldWidth / 4 - squareWidth / 4, worldHeight + wallThickness / 2, worldWidth / 2 - squareWidth / 2, wallThickness, wallOptions); this.matter.add.rectangle(worldWidth * 3 / 4 + squareWidth / 4, worldHeight + wallThickness / 2, worldWidth / 2 - squareWidth / 2, wallThickness, wallOptions); this.matter.add.rectangle(worldWidth / 4 - squareWidth / 4, -wallThickness / 2, worldWidth / 2 - squareWidth / 2, wallThickness, wallOptions); this.matter.add.rectangle(worldWidth * 3 / 4 + squareWidth / 4, -wallThickness / 2, worldWidth / 2 - squareWidth / 2, wallThickness, wallOptions); this.matter.add.rectangle(-wallThickness / 2, worldHeight / 4 - squareWidth / 4, wallThickness, worldHeight / 2 - squareWidth / 2, wallOptions); this.matter.add.rectangle(-wallThickness / 2, worldHeight * 3 / 4 + squareWidth / 4, wallThickness, worldHeight / 2 - squareWidth / 2, wallOptions); this.matter.add.rectangle(worldWidth + wallThickness / 2, worldHeight / 4 - squareWidth / 4, wallThickness, worldHeight / 2 - squareWidth / 2, wallOptions); this.matter.add.rectangle(worldWidth + wallThickness / 2, worldHeight * 3 / 4 + squareWidth / 4, wallThickness, worldHeight / 2 - squareWidth / 2, wallOptions); // Add side walls for goals this.matter.add.rectangle(worldWidth / 2 - squareWidth / 2 - wallThickness / 2, -gridCellSize * 0.75, wallThickness, gridCellSize * 1.5, wallOptions); this.matter.add.rectangle(worldWidth / 2 + squareWidth / 2 + wallThickness / 2, -gridCellSize * 0.75, wallThickness, gridCellSize * 1.5, wallOptions); this.matter.add.rectangle(worldWidth / 2 - squareWidth / 2 - wallThickness / 2, worldHeight + gridCellSize * 0.75, wallThickness, gridCellSize * 1.5, wallOptions); this.matter.add.rectangle(worldWidth / 2 + squareWidth / 2 + wallThickness / 2, worldHeight + gridCellSize * 0.75, wallThickness, gridCellSize * 1.5, wallOptions); this.matter.add.rectangle(-gridCellSize * 0.75, worldHeight / 2 - squareWidth / 2 - wallThickness / 2, gridCellSize * 1.5, wallThickness, wallOptions); this.matter.add.rectangle(-gridCellSize * 0.75, worldHeight / 2 + squareWidth / 2 + wallThickness / 2, gridCellSize * 1.5, wallThickness, wallOptions); this.matter.add.rectangle(worldWidth + gridCellSize * 0.75, worldHeight / 2 - squareWidth / 2 - wallThickness / 2, gridCellSize * 1.5, wallThickness, wallOptions); this.matter.add.rectangle(worldWidth + gridCellSize * 0.75, worldHeight / 2 + squareWidth / 2 + wallThickness / 2, gridCellSize * 1.5, wallThickness, wallOptions); const frameGraphics = this.add.graphics(); frameGraphics.lineStyle(2, 0x000000, 1); frameGraphics.moveTo(0, 0); frameGraphics.lineTo(squareX - squareWidth / 2, 0); frameGraphics.lineTo(squareX - squareWidth / 2, -gridCellSize * 1.5); frameGraphics.lineTo(squareX + squareWidth / 2, -gridCellSize * 1.5); frameGraphics.lineTo(squareX + squareWidth / 2, 0); frameGraphics.lineTo(worldWidth, 0); frameGraphics.lineTo(worldWidth, worldHeight / 2 - squareWidth / 2); frameGraphics.lineTo(worldWidth + gridCellSize * 1.5, worldHeight / 2 - squareWidth / 2); frameGraphics.lineTo(worldWidth + gridCellSize * 1.5, worldHeight / 2 + squareWidth / 2); frameGraphics.lineTo(worldWidth, worldHeight / 2 + squareWidth / 2); frameGraphics.lineTo(worldWidth, worldHeight); frameGraphics.lineTo(squareX + squareWidth / 2, worldHeight); frameGraphics.lineTo(squareX + squareWidth / 2, worldHeight + gridCellSize * 1.5); frameGraphics.lineTo(squareX - squareWidth / 2, worldHeight + gridCellSize * 1.5); frameGraphics.lineTo(squareX - squareWidth / 2, worldHeight); frameGraphics.lineTo(0, worldHeight); frameGraphics.lineTo(0, worldHeight / 2 + squareWidth / 2); frameGraphics.lineTo(-gridCellSize * 1.5, worldHeight / 2 + squareWidth / 2); frameGraphics.lineTo(-gridCellSize * 1.5, worldHeight / 2 - squareWidth / 2); frameGraphics.lineTo(0, worldHeight / 2 - squareWidth / 2); frameGraphics.lineTo(0, 0); frameGraphics.strokePath(); frameGraphics.setDepth(1); // Use the darker blue-gray color for the areas outside the playing field this.add.rectangle(worldWidth / 2, -gridCellSize * 0.75, worldWidth, gridCellSize * 1.5, calmBlueGray).setDepth(-3); this.add.rectangle(worldWidth / 2, worldHeight + gridCellSize * 0.75, worldWidth, gridCellSize * 1.5, calmBlueGray).setDepth(-3); this.add.rectangle(-gridCellSize * 0.75, worldHeight / 2, gridCellSize * 1.5, worldHeight, calmBlueGray).setDepth(-3); this.add.rectangle(worldWidth + gridCellSize * 0.75, worldHeight / 2, gridCellSize * 1.5, worldHeight, calmBlueGray).setDepth(-3); this.cameras.main.startFollow(this.playerCar); this.cameras.main.setZoom(1.445); this.cameras.main.setRotation(Math.PI * 3 / 2); this.cameras.main.setBounds(-Number.MAX_SAFE_INTEGER / 2, -Number.MAX_SAFE_INTEGER / 2, Number.MAX_SAFE_INTEGER, Number.MAX_SAFE_INTEGER); // Set up collision detection for cars and circles this.matter.world.on('collisionstart', (event) => { event.pairs.forEach((pair) => { const bodyA = pair.bodyA; const bodyB = pair.bodyB; if (bodyA.gameObject && bodyA.gameObject.type === 'car' && (this.circles.includes(bodyB) || bodyB.attachedTo)) { this.handleCircleCollision(bodyA.gameObject, bodyB); } else if (bodyB.gameObject && bodyB.gameObject.type === 'car' && (this.circles.includes(bodyA) || bodyA.attachedTo)) { this.handleCircleCollision(bodyB.gameObject, bodyA); } }); }); // Set up flashing effect for all squares this.setupFlashTimer(); // Add score texts const scoreConfig = { fontSize: '24px', fontFamily: 'Arial', fontStyle: 'bold', fixedWidth: 150, fixedHeight: 30, align: 'left' }; // Create a separate camera for the score display this.scoreCamera = this.cameras.add(0, 0, this.sys.game.config.width, this.sys.game.config.height); this.scoreCamera.setScroll(0, 0); this.scoreCamera.setZoom(1); // Create a container for score texts this.scoreContainer = this.add.container(10, this.sys.game.config.height - 330); this.scoreContainer.setScrollFactor(0); this.scoreContainer.setDepth(1000); // Add "Maximum Load" text this.maxLoadText = this.add.text(0, 20, 'MAXIMUM LOAD', { fontSize: '24px', fontFamily: 'Arial', fontStyle: 'bold', color: '#FF0000' }); this.maxLoadText.setVisible(false); // Add "YOUR HIGH SCORE:" text this.bestScoreText = this.add.text(0, 50, 'YOUR HIGH SCORE:', { fontSize: '12px', fontFamily: 'Arial', fontStyle: 'bold', color: '#FFFFFF' }); // Add instruction text this.instructionText = this.add.text(0, 260, 'Arrow keys to drive.\nBring dots to green goal.', { ...scoreConfig, fontSize: '18px', color: '#000000', fixedWidth: 250, fixedHeight: 50, align: 'left' }); // Add difficulty and best clear texts this.circleCountText = this.add.text(0, 220, 'Circles Left: 500', { ...scoreConfig, fontSize: '18px', color: '#FFFFFF' }); this.timerText = this.add.text(0, 190, '1:15', { ...scoreConfig, fontSize: '18px', color: '#FFFFFF' }); // Add score texts this.scoreTexts.purple = this.add.text(0, 160, 'Purple: 0', { ...scoreConfig, fontSize: '16px', color: '#800080' }); this.scoreTexts.blue = this.add.text(0, 130, 'Blue: 0', { ...scoreConfig, fontSize: '16px', color: '#0000FF' }); this.scoreTexts.red = this.add.text(0, 100, 'Red: 0', { ...scoreConfig, fontSize: '16px', color: '#FF0000' }); this.scoreTexts.green = this.add.text(0, 70, 'Green: 0', { ...scoreConfig, fontSize: '16px', color: '#006400' // Changed to dark green (RGB: 0, 100, 0) }); // Remove duplicate timerText creation this.scoreContainer.add([this.maxLoadText, this.bestScoreText, this.instructionText, this.circleCountText, this.timerText, this.scoreTexts.purple, this.scoreTexts.blue, this.scoreTexts.red, this.scoreTexts.green ]); // Make the score camera ignore everything except the score container this.scoreCamera.ignore(this.children.list.filter(child => child !== this.scoreContainer)); // Remove the score container from the main camera this.cameras.main.ignore(this.scoreContainer); // Create a separate camera for the tethers this.tetherCamera = this.cameras.add(0, 0, this.sys.game.config.width, this.sys.game.config.height); this.tetherCamera.setScroll(0, 0); this.tetherCamera.setZoom(1); // Create a container for tethers this.tetherContainer = this.add.container(0, 0); this.tetherContainer.setScrollFactor(0); this.tetherContainer.setDepth(0); // Create a graphics object for tethers this.tetherGraphics = this.add.graphics(); this.tetherContainer.add(this.tetherGraphics); // Make the tether camera ignore everything except the tether container this.tetherCamera.ignore(this.children.list.filter(child => child !== this.tetherContainer)); // Remove the tether container from the main camera this.cameras.main.ignore(this.tetherContainer); // Start the game timer this.time.addEvent({ delay: 1000, callback: this.updateTimer, callbackScope: this, loop: true }); } createCars(worldWidth, worldHeight, carWidth, carHeight, margin) { const teamSpacing = 125; // Reduced spacing between teammates const blueCenter = worldWidth / 2; for (let i = 0; i < 9; i++) { const x = blueCenter + (i - 4) * teamSpacing; const car = this.createCar(x, 50, 0x0000FF, Math.PI / 2); this.aiCars.push(car); } const greenCenter = worldWidth / 2; for (let i = 0; i < 9; i++) { const x = greenCenter + (i - 4) * teamSpacing; const car = this.createCar(x, worldHeight - 50, 0x00FF00, -Math.PI / 2); if (i === 4) { this.playerCar = car; } else { this.aiCars.push(car); } } const redCenter = worldHeight / 2; for (let i = 0; i < 9; i++) { const y = redCenter + (i - 4) * teamSpacing; const car = this.createCar(50, y, 0xFF0000, 0); this.aiCars.push(car); } const purpleCenter = worldHeight / 2; for (let i = 0; i < 9; i++) { const y = purpleCenter + (i - 4) * teamSpacing; const car = this.createCar(worldWidth - 50, y, 0x800080, Math.PI); this.aiCars.push(car); } } setupFlashTimer() { if (this.flashTimer) { this.flashTimer.remove(); } this.flashTimer = this.time.addEvent({ delay: 500, callback: this.flashAllSquares, callbackScope: this, loop: true }); } createColorCodedGrid(worldWidth, worldHeight, gridCellSize) { const graphics = this.add.graphics(); graphics.setDepth(-1); const goals = [{ x: worldWidth / 2, y: 0, color: 0x0000FF }, // Blue { x: worldWidth / 2, y: worldHeight, color: 0x00FF00 }, // Green (changed to bright green) { x: 0, y: worldHeight / 2, color: 0xFF0000 }, // Red { x: worldWidth, y: worldHeight / 2, color: 0x800080 } // Purple ]; for (let x = 0; x < worldWidth; x += gridCellSize) { for (let y = 0; y < worldHeight; y += gridCellSize) { let cellColor = new Phaser.Display.Color(); let totalWeight = 0; goals.forEach(goal => { const distance = Phaser.Math.Distance.Between(x + gridCellSize / 2, y + gridCellSize / 2, goal.x, goal.y); const maxDistance = Math.sqrt(worldWidth * worldWidth + worldHeight * worldHeight); const weight = Math.pow(1 - (distance / maxDistance), 3); // Increased power for more intensity totalWeight += weight; const goalColor = new Phaser.Display.Color(); goalColor.setFromRGB(Phaser.Display.Color.IntegerToRGB(goal.color)); cellColor.red += goalColor.red * weight; cellColor.green += goalColor.green * weight; cellColor.blue += goalColor.blue * weight; }); cellColor.red /= totalWeight; cellColor.green /= totalWeight; cellColor.blue /= totalWeight; // Adjust color balance to emphasize blue and reduce purple if (cellColor.blue > cellColor.red && cellColor.blue > cellColor.green) { cellColor.blue = Math.min(255, cellColor.blue * 1.2); cellColor.red = Math.max(0, cellColor.red * 0.8); } // Increase overall color intensity cellColor.red = Math.min(255, cellColor.red * 1.3); cellColor.green = Math.min(255, cellColor.green * 1.3); cellColor.blue = Math.min(255, cellColor.blue * 1.3); graphics.fillStyle(Phaser.Display.Color.GetColor(cellColor.red, cellColor.green, cellColor.blue), 0.6); // Slightly increased opacity graphics.fillRect(x, y, gridCellSize, gridCellSize); } } } createCar(x, y, color, rotation) { const graphics = this.add.graphics(); graphics.fillStyle(color, 1); graphics.fillRect(-10.71, -5.355, 21.42, 10.71); graphics.fillStyle(0x000000, 1); graphics.fillRect(-9.375, -7.125, 4.5, 2.625); graphics.fillRect(4.875, -7.125, 4.5, 2.625); graphics.fillRect(-9.375, 4.5, 4.5, 2.625); graphics.fillRect(4.875, 4.5, 4.5, 2.625); graphics.fillStyle(0xADD8E6, 1); graphics.fillRect(3.75, -5.355, 6, 10.71); const car = this.matter.add.gameObject(graphics, { shape: { type: 'rectangle', width: 21.42, height: 10.71 }, frictionAir: 0.05, restitution: 0.8, friction: 0.01, density: 0.001 }); car.setPosition(x, y); car.setRotation(rotation); car.setDepth(1); car.type = 'car'; car.attachedCircles = []; car.teamColor = color; car.speed = 0; car.maxSpeed = 3.75; car.maxReverseSpeed = car.maxSpeed * 0.625; car.searchTarget = null; car.searchTimer = 0; return car; } handleCircleCollision(car, circle) { if (car.attachedCircles.length >= 10) return; // Don't attach if already holding 10 circles if (this.circles.includes(circle)) { this.attachCircleToCar(car, circle); } else if (circle.attachedTo && circle.attachedTo !== car) { this.transferCircle(circle.attachedTo, car, circle); } } attachCircleToCar(car, circle) { if (!car.attachedCircles.includes(circle)) { car.attachedCircles.push(circle); this.circles = this.circles.filter(c => c !== circle); const constraint = this.matter.add.constraint(car.body, circle, 25, 0.7); circle.constraint = constraint; circle.attachedTo = car; } } transferCircle(fromCar, toCar, circle) { fromCar.attachedCircles = fromCar.attachedCircles.filter(c => c !== circle); if (circle.constraint) { this.matter.world.removeConstraint(circle.constraint); } circle.attachedTo = null; this.attachCircleToCar(toCar, circle); } flashAllSquares() { this.flashSquare(this.bottomSquare, 0x00FF00); this.flashSquare(this.topSquare, 0x0000FF); this.flashSquare(this.leftSquare, 0xFF0000); this.flashSquare(this.rightSquare, 0x800080); } flashSquare(square, teamColor) { if (square.fillColor === 0x708090) { square.setFillStyle(teamColor, 0.5); } else { square.setFillStyle(0x708090, 1); } } updateScoreTexts() { const totalScore = this.scores.blue + this.scores.green + this.scores.red + this.scores.purple; if (totalScore > 0) { this.scoreTexts.blue.setText(`Blue: ${((this.scores.blue / totalScore) * 100).toFixed(2)}%`); this.scoreTexts.green.setText(`Green: ${((this.scores.green / totalScore) * 100).toFixed(2)}%`); this.scoreTexts.red.setText(`Red: ${((this.scores.red / totalScore) * 100).toFixed(2)}%`); this.scoreTexts.purple.setText(`Purple: ${((this.scores.purple / totalScore) * 100).toFixed(2)}%`); } else { this.scoreTexts.blue.setText('Blue: 0.00%'); this.scoreTexts.green.setText('Green: 0.00%'); this.scoreTexts.red.setText('Red: 0.00%'); this.scoreTexts.purple.setText('Purple: 0.00%'); } // Update high score text if (this.bestScore) { this.bestScoreText.setText(`YOUR HIGH SCORE: ${this.bestScore.toFixed(2)}%`); } else { this.bestScoreText.setText('YOUR HIGH SCORE:'); } } updateTimer() { if (this.gameTimer > 0) { this.gameTimer--; const minutes = Math.floor(this.gameTimer / 60); const seconds = this.gameTimer % 60; this.timerText.setText(`${minutes}:${seconds.toString().padStart(2, '0')}`); } } startNewRound() { // Store the scores from the end of the round this.roundScores.push({ ...this.scores }); // Update best score for green team (player's team) const totalScore = this.scores.blue + this.scores.green + this.scores.red + this.scores.purple; if (totalScore > 0) { const greenPercentage = (this.scores.green / totalScore) * 100; this.bestScore = Math.max(this.bestScore || 0, greenPercentage); } this.roundNumber++; // Reset scores this.scores = { blue: 0, green: 0, red: 0, purple: 0 }; // Clear all tethered circles this.clearAllTetheredCircles(); // Update score texts this.updateScoreTexts(); // Reset the game timer to 1:15 (75 seconds) this.gameTimer = 75; if (this.timerText) { this.timerText.setText('1:15'); } // Clear all existing circles and recreate them this.createCircles(2500, 2500, 100, 750); // Reset the flash timer this.setupFlashTimer(); // Reset car positions this.resetCarPositions(); } clearAllTetheredCircles() { const allCars = [...this.aiCars, this.playerCar]; allCars.forEach(car => { car.attachedCircles.forEach(circle => { if (circle.gameObject) { circle.gameObject.destroy(); } this.matter.world.remove(circle); if (circle.constraint) { this.matter.world.removeConstraint(circle.constraint); } }); car.attachedCircles = []; }); } resetCarPositions() { const worldWidth = 2500; const worldHeight = 2500; const teamSpacing = 200; // Spacing between teammates // Reset blue cars const blueCenter = worldWidth / 2; this.aiCars.filter(car => car.teamColor === 0x0000FF).forEach((car, i) => { const x = blueCenter + (i - 2) * teamSpacing; car.setPosition(x, 50); car.setRotation(Math.PI / 2); car.setVelocity(0, 0); car.speed = 0; }); // Reset green cars (including player car) const greenCenter = worldWidth / 2; const greenCars = this.aiCars.filter(car => car.teamColor === 0x00FF00); const greenPositions = [-2, -1, 1, 2]; // Positions for AI cars // Position the player car in the center this.playerCar.setPosition(greenCenter, worldHeight - 50); this.playerCar.setRotation(-Math.PI / 2); this.playerCar.setVelocity(0, 0); this.playerCar.speed = 0; // Position AI green cars around the player greenCars.forEach((car, i) => { const x = greenCenter + greenPositions[i] * teamSpacing; car.setPosition(x, worldHeight - 50); car.setRotation(-Math.PI / 2); car.setVelocity(0, 0); car.speed = 0; }); // Reset red cars const redCenter = worldHeight / 2; this.aiCars.filter(car => car.teamColor === 0xFF0000).forEach((car, i) => { const y = redCenter + (i - 2) * teamSpacing; car.setPosition(50, y); car.setRotation(0); car.setVelocity(0, 0); car.speed = 0; }); // Reset purple cars const purpleCenter = worldHeight / 2; this.aiCars.filter(car => car.teamColor === 0x800080).forEach((car, i) => { const y = purpleCenter + (i - 2) * teamSpacing; car.setPosition(worldWidth - 50, y); car.setRotation(Math.PI); car.setVelocity(0, 0); car.speed = 0; }); // Reset player speed and camera rotation this.speed = 0; this.cameras.main.setRotation(Math.PI * 3 / 2); } createCircles(worldWidth, worldHeight, gridCellSize, squareWidth) { const carWidth = 21.42; // Updated to match the new car width const circleRadius = carWidth / 3; // Adjusted to maintain proportion const wallThickness = 40; const goalDepth = gridCellSize * 1.5; // Clear existing circles this.circles.forEach(circle => { if (circle.gameObject) { circle.gameObject.destroy(); } this.matter.world.remove(circle); }); this.circles = []; const isOverlappingWall = (x, y) => { // Check top and bottom walls if ((y < wallThickness || y > worldHeight - wallThickness) && (x < worldWidth / 2 - squareWidth / 2 || x > worldWidth / 2 + squareWidth / 2)) { return true; } // Check left and right walls if ((x < wallThickness || x > worldWidth - wallThickness) && (y < worldHeight / 2 - squareWidth / 2 || y > worldHeight / 2 + squareWidth / 2)) { return true; } // Check goal areas if ((y < goalDepth || y > worldHeight - goalDepth) && (x > worldWidth / 2 - squareWidth / 2 - wallThickness && x < worldWidth / 2 + squareWidth / 2 + wallThickness)) { return true; } if ((x < goalDepth || x > worldWidth - goalDepth) && (y > worldHeight / 2 - squareWidth / 2 - wallThickness && y < worldHeight / 2 + squareWidth / 2 + wallThickness)) { return true; } return false; }; const spacing = 100; // Spacing between circles const rows = Math.floor(worldHeight / spacing); const cols = Math.floor(worldWidth / spacing); const totalPositions = rows * cols; const positions = []; for (let row = 0; row < rows; row++) { for (let col = 0; col < cols; col++) { let x = col * spacing + spacing / 2; let y = row * spacing + spacing / 2; // Add some randomness to avoid a perfect grid x += Phaser.Math.Between(-spacing / 4, spacing / 4); y += Phaser.Math.Between(-spacing / 4, spacing / 4); if (!isOverlappingWall(x, y)) { positions.push({ x, y }); } } } // Shuffle the positions array Phaser.Utils.Array.Shuffle(positions); // Create circles using the first 500 valid positions for (let i = 0; i < Math.min(500, positions.length); i++) { const { x, y } = positions[i]; const circle = this.matter.add.circle(x, y, circleRadius, { isStatic: false, isSensor: true, render: { fillColor: 0xFFFF00, fillAlpha: 0.5 } }); circle.gameObject = this.add.circle(x, y, circleRadius, 0xFFFF00, 0.5); circle.gameObject.setDepth(0); this.circles.push(circle); } // Make sure the score camera and tether camera ignore the new circles if (this.scoreCamera) { this.scoreCamera.ignore(this.circles.map(circle => circle.gameObject)); } if (this.tetherCamera) { this.tetherCamera.ignore(this.circles.map(circle => circle.gameObject)); } // Update the circle count text if (this.circleCountText) { this.circleCountText.setText(`Circles Left: ${this.circles.length}`); } } isCarInGoal(car) { const carWidth = 14.28; const carHeight = 7.14; const gridCellSize = 100; const squareWidth = gridCellSize * 7.5; // Increased from 5 to 7.5 (1.5x) const worldWidth = 2500; const worldHeight = 2500; const carLeft = car.x - 21.42 / 2; const carRight = car.x + 21.42 / 2; const carTop = car.y - 10.71 / 2; const carBottom = car.y + 10.71 / 2; if (car.teamColor === 0x0000FF) { return carTop >= -gridCellSize * 1.5 && carBottom <= 0 && carLeft >= worldWidth / 2 - squareWidth / 2 && carRight <= worldWidth / 2 + squareWidth / 2; } else if (car.teamColor === 0x00FF00) { return carTop >= worldHeight && carBottom <= worldHeight + gridCellSize * 1.5 && carLeft >= worldWidth / 2 - squareWidth / 2 && carRight <= worldWidth / 2 + squareWidth / 2; } else if (car.teamColor === 0xFF0000) { return carLeft >= -gridCellSize * 1.5 && carRight <= 0 && carTop >= worldHeight / 2 - squareWidth / 2 && carBottom <= worldHeight / 2 + squareWidth / 2; } else if (car.teamColor === 0x800080) { return carLeft >= worldWidth && carRight <= worldWidth + gridCellSize * 1.5 && carTop >= worldHeight / 2 - squareWidth / 2 && carBottom <= worldHeight / 2 + squareWidth / 2; } return false; } getTeamGoal(teamColor) { const worldWidth = 2500; const worldHeight = 2500; const gridCellSize = 100; const squareWidth = gridCellSize * 7.5; // Increased from 5 to 7.5 (1.5x) if (teamColor === 0x0000FF) { return { x: worldWidth / 2, y: -gridCellSize * 0.75 }; } else if (teamColor === 0x00FF00) { return { x: worldWidth / 2, y: worldHeight + gridCellSize * 0.75 }; } else if (teamColor === 0xFF0000) { return { x: -gridCellSize * 0.75, y: worldHeight / 2 }; } else if (teamColor === 0x800080) { return { x: worldWidth + gridCellSize * 0.75, y: worldHeight / 2 }; } } findNearestCircle(car) { let nearestCircle = null; let minDistance = Infinity; const visibleCircles = this.getVisibleCircles(car); for (const circle of visibleCircles) { const distance = Phaser.Math.Distance.Between(car.x, car.y, circle.position.x, circle.position.y); if (distance < minDistance) { minDistance = distance; nearestCircle = circle; } } return nearestCircle; } findNearestEnemyWithCircle(car) { let nearestEnemy = null; let minDistance = Infinity; const visibleEnemies = this.getVisibleEnemies(car); for (const enemy of visibleEnemies) { if (enemy !== car && enemy.teamColor !== car.teamColor && enemy.attachedCircles.length > 0) { const distance = Phaser.Math.Distance.Between(car.x, car.y, enemy.x, enemy.y); if (distance < minDistance) { minDistance = distance; nearestEnemy = enemy; } } } return nearestEnemy; } getVisibleCircles(car) { const viewportWidth = (this.cameras.main.width / this.cameras.main.zoom) * 1.15; const viewportHeight = (this.cameras.main.height / this.cameras.main.zoom) * 1.15; const visibleArea = new Phaser.Geom.Rectangle( car.x - viewportWidth / 2, car.y - viewportHeight / 2, viewportWidth, viewportHeight ); return this.circles.filter(circle => Phaser.Geom.Rectangle.Contains(visibleArea, circle.position.x, circle.position.y) ); } getVisibleEnemies(car) { const viewportWidth = (this.cameras.main.width / this.cameras.main.zoom) * 1.15; const viewportHeight = (this.cameras.main.height / this.cameras.main.zoom) * 1.15; const visibleArea = new Phaser.Geom.Rectangle( car.x - viewportWidth / 2, car.y - viewportHeight / 2, viewportWidth, viewportHeight ); return this.aiCars.concat(this.playerCar).filter(enemy => enemy !== car && enemy.teamColor !== car.teamColor && Phaser.Geom.Rectangle.Contains(visibleArea, enemy.x, enemy.y) ); } updateAICar(car) { if (!car.state) { car.state = this.initializeCarState(car); } const state = this.updateCarState(car); const action = this.getActionFromState(car, state); this.executeAction(car, action); this.updateCarFormation(car); } findPurpleTeammateWithCircles(car) { const teammatesWithCircles = this.aiCars .filter(c => c !== car && c.teamColor === 0x800080 && c.attachedCircles.length > 0) .map(c => ({ car: c, distance: Phaser.Math.Distance.Between(car.x, car.y, c.x, c.y), threatenedBy: this.getNearestEnemyDirection(c) })) .filter(t => t.threatenedBy !== null); return teammatesWithCircles.length > 0 ? teammatesWithCircles.reduce((a, b) => a.distance < b.distance ? a : b).car : null; } isTeammateUnderThreat(teammate) { const nearestEnemy = this.getNearestEnemyDirection(teammate); return nearestEnemy && Phaser.Math.Distance.Between(teammate.x, teammate.y, nearestEnemy.x, nearestEnemy.y) < 300; } getWinningTeam() { const totalScore = this.scores.blue + this.scores.green + this.scores.red + this.scores.purple; if (totalScore === 0) return null; const maxScore = Math.max(this.scores.blue, this.scores.green, this.scores.red, this.scores.purple); if (this.scores.blue === maxScore) return 0x0000FF; if (this.scores.green === maxScore) return 0x00FF00; if (this.scores.red === maxScore) return 0xFF0000; if (this.scores.purple === maxScore) return 0x800080; return null; } initializeCarState(car) { return { mode: 'search', target: null, stuckTime: 0, lastPosition: { x: car.x, y: car.y }, role: this.assignInitialRole(car) }; } assignInitialRole(car) { const teamCars = this.aiCars.filter(c => c.teamColor === car.teamColor); const roleIndex = teamCars.indexOf(car) % 5; return ['attacker', 'defender', 'supporter', 'interceptor', 'scout'][roleIndex]; } getOptimalCircleCount(car) { const remainingTime = this.gameTimer; const distanceToGoal = Phaser.Math.Distance.Between(car.x, car.y, this.getTeamGoal(car.teamColor).x, this.getTeamGoal(car.teamColor).y); const enemiesNearby = this.getVisibleEnemies(car).length; const teamScore = this.scores[car.teamColor.toString(16).padStart(6, '0')]; const maxEnemyScore = Math.max(...Object.values(this.scores).filter(score => score !== teamScore)); let optimalCount = 5; // Start with a higher base optimal count if (remainingTime > 60 && distanceToGoal < 800 && enemiesNearby <= 1) { optimalCount = 8; } else if (remainingTime > 30 && distanceToGoal < 1000 && enemiesNearby <= 2) { optimalCount = 6; } if (teamScore < maxEnemyScore - 5) { optimalCount = Math.min(optimalCount + 2, 10); } return Math.min(Math.max(optimalCount, 3), 10); // Return between 3 and 10 } updateCarState(car) { const state = car.state; const nearestCircle = this.findNearestCircle(car); const nearestEnemy = this.findNearestEnemyWithCircle(car); const nearestTeammate = this.findNearestTeammate(car); const teamStrategy = this.getTeamStrategy(car); const remainingCircles = this.getRemainingCircles(); const winningTeam = this.getWinningTeam(); const optimalCircleCount = this.getOptimalCircleCount(car); const isNearGoal = this.isNearGoal(car); // Update stuck detection const distance = Phaser.Math.Distance.Between(car.x, car.y, state.lastPosition.x, state.lastPosition.y); state.stuckTime = distance < 1 ? state.stuckTime + 1 : 0; state.lastPosition = { x: car.x, y: car.y }; // Reset mode state.mode = 'roam'; // Prioritize modes if (isNearGoal && car.attachedCircles.length >= Math.max(3, optimalCircleCount / 2)) { state.mode = 'score'; } else if (car.attachedCircles.length >= optimalCircleCount) { state.mode = 'score'; } else if (car.attachedCircles.length > 0 && this.isUnderSevereThread(car)) { state.mode = 'score'; } else if (car.teamColor === 0x800080 && car.attachedCircles.length === 0) { // Purple team protector logic const teammateToProtect = this.findPurpleTeammateWithCircles(car); if (teammateToProtect && this.isTeammateUnderThreat(teammateToProtect)) { state.mode = 'protect'; state.protectTarget = teammateToProtect; } else if (teammateToProtect) { state.mode = 'escort'; state.protectTarget = teammateToProtect; } } else if (nearestCircle && car.attachedCircles.length < optimalCircleCount) { state.mode = 'collect'; } else if (nearestEnemy && nearestEnemy.attachedCircles.length > 0 && car.attachedCircles.length < optimalCircleCount) { if (this.shouldGangUp(car)) { state.mode = 'gangUp'; } else { state.mode = 'intercept'; } } else if (winningTeam && winningTeam !== car.teamColor) { const winningTeamCar = this.findNearestEnemyOfTeam(car, winningTeam); if (winningTeamCar) { state.mode = 'jealous'; } } else if (this.shouldDefendTeammate(car, nearestTeammate)) { state.mode = 'defend'; } // Update target based on mode switch (state.mode) { case 'score': state.target = this.getOptimalScoringPath(car); break; case 'collect': state.target = nearestCircle.position; break; case 'intercept': case 'jealous': case 'gangUp': state.target = this.getPredictedEnemyPosition(nearestEnemy || this.findNearestEnemyOfTeam(car, winningTeam)); break; case 'defend': state.target = this.getDefensivePosition(car, nearestTeammate); break; case 'roam': state.target = this.getStrategicPosition(car, teamStrategy); break; } return state; } findNearestEnemyOfTeam(car, teamColor) { return this.aiCars .filter(c => c.teamColor === teamColor) .reduce((nearest, c) => { const distance = Phaser.Math.Distance.Between(car.x, car.y, c.x, c.y); return (!nearest || distance < nearest.distance) ? { car: c, distance } : nearest; }, null)?.car; } getActionFromState(car, state) { let targetVector = { x: state.target.x - car.x, y: state.target.y - car.y }; if ((state.mode === 'protect' || state.mode === 'escort') && state.protectTarget) { const teammateToProtect = state.protectTarget; const enemyDirection = this.getNearestEnemyDirection(teammateToProtect); if (enemyDirection && state.mode === 'protect') { // Intercept the approaching enemy const interceptPoint = { x: teammateToProtect.x - enemyDirection.x * 100, y: teammateToProtect.y - enemyDirection.y * 100 }; targetVector = { x: interceptPoint.x - car.x, y: interceptPoint.y - car.y }; } else { // Escort formation: position slightly behind and to the side of the teammate const escortAngle = teammateToProtect.rotation + Math.PI / 4; targetVector = { x: teammateToProtect.x - Math.cos(escortAngle) * 50 - car.x, y: teammateToProtect.y - Math.sin(escortAngle) * 50 - car.y }; } } // Apply obstacle avoidance const avoidanceVector = this.getObstacleAvoidanceVector(car, state.mode === 'intercept' || state.mode === 'gangUp' || state.mode === 'jealous' || state.mode === 'protect'); targetVector.x += avoidanceVector.x; targetVector.y += avoidanceVector.y; // Handle stuck situations if (state.stuckTime > 60) { targetVector.x += Phaser.Math.Between(-50, 50); targetVector.y += Phaser.Math.Between(-50, 50); state.stuckTime = 0; } const angle = Math.atan2(targetVector.y, targetVector.x); const angleDiff = Phaser.Math.Angle.Wrap(angle - car.rotation); // Calculate desired speed const speedMultiplier = this.getSpeedMultiplier(car, state); const desiredSpeed = this.calculateDesiredSpeed(car, 0, speedMultiplier); // Make all AI cars more aggressive const aggressiveness = 1.3; const steeringFactor = 1.2; return { steer: angleDiff * steeringFactor, accelerate: (desiredSpeed - car.speed) * aggressiveness }; } getNearestEnemyDirection(car) { const nearestEnemy = this.getVisibleEnemies(car) .reduce((nearest, enemy) => { const distance = Phaser.Math.Distance.Between(car.x, car.y, enemy.x, enemy.y); return (!nearest || distance < nearest.distance) ? { enemy, distance } : nearest; }, null)?.enemy; if (nearestEnemy) { const dx = nearestEnemy.x - car.x; const dy = nearestEnemy.y - car.y; const length = Math.sqrt(dx * dx + dy * dy); return { x: dx / length, y: dy / length }; } return null; } executeAction(car, action) { // Apply steering if (Math.abs(action.steer) > 0.05) { const steerAmount = Phaser.Math.Clamp(action.steer, -this.turnSpeed, this.turnSpeed); car.rotation += steerAmount; } // Apply acceleration if (action.accelerate > 0) { car.speed = Math.min(car.speed + this.acceleration, car.maxSpeed); } else if (action.accelerate < 0) { car.speed = Math.max(car.speed - this.deceleration, -car.maxReverseSpeed); } else { car.speed = Phaser.Math.Linear(car.speed, 0, this.deceleration); } // Set velocity const velocityX = Math.cos(car.rotation) * car.speed; const velocityY = Math.sin(car.rotation) * car.speed; car.setVelocity(velocityX, velocityY); // Prevent physical interactions from changing the AI car's rotation car.setAngularVelocity(0); } getObstacleAvoidanceVector(car, isAggressive) { const avoidanceDistance = 100; const obstacles = this.getVisibleEnemies(car).concat(this.getVisibleCircles(car)); let avoidanceVector = { x: 0, y: 0 }; for (const obstacle of obstacles) { const dx = car.x - obstacle.x; const dy = car.y - obstacle.y; const distance = Math.sqrt(dx * dx + dy * dy); if (distance < avoidanceDistance && !isAggressive) { const weight = 1 - (distance / avoidanceDistance); avoidanceVector.x += dx / distance * weight; avoidanceVector.y += dy / distance * weight; } } return avoidanceVector; } calculateDesiredSpeed(car, distanceToTarget, speedMultiplier) { return car.maxSpeed * speedMultiplier; } getSpeedMultiplier(car, state) { let baseMultiplier = 1.2; // Increase base speed for all modes switch (state.mode) { case 'intercept': baseMultiplier = 1.5; break; case 'score': const distanceToGoal = Phaser.Math.Distance.Between(car.x, car.y, this.getTeamGoal(car.teamColor).x, this.getTeamGoal(car.teamColor).y); const speedUpThreshold = 1000; if (distanceToGoal < speedUpThreshold) { baseMultiplier = 1.5 + (speedUpThreshold - distanceToGoal) / speedUpThreshold; } break; case 'collect': baseMultiplier = 1.4; break; } // Adjust speed based on the number of attached circles baseMultiplier *= 1 - (car.attachedCircles.length * 0.02); // 2% slower for each attached circle return Math.max(baseMultiplier, 0.8); // Ensure the car doesn't become too slow } updateCarFormation(car) { const teamColor = car.teamColor.toString(16).padStart(6, '0'); if (!this.teamFormations[teamColor]) { this.teamFormations[teamColor] = this.initializeTeamFormation(teamColor); } const formation = this.teamFormations[teamColor]; const carIndex = formation.cars.indexOf(car); if (carIndex !== -1) { const desiredPosition = this.getFormationPosition(formation, carIndex); const distanceToDesired = Phaser.Math.Distance.Between(car.x, car.y, desiredPosition.x, desiredPosition.y); if (distanceToDesired > 50 && car.state.mode === 'search') { car.state.target = desiredPosition; } } } initializeTeamFormation(teamColor) { const teamCars = this.aiCars.filter(c => c.teamColor.toString(16).padStart(6, '0') === teamColor); return { cars: teamCars, center: { x: 0, y: 0 }, radius: 200, angle: 0 }; } getFormationPosition(formation, index) { const angleStep = (2 * Math.PI) / formation.cars.length; const angle = formation.angle + index * angleStep; return { x: formation.center.x + Math.cos(angle) * formation.radius, y: formation.center.y + Math.sin(angle) * formation.radius }; } isNearGoal(car) { const goal = this.getTeamGoal(car.teamColor); const distance = Phaser.Math.Distance.Between(car.x, car.y, goal.x, goal.y); return distance < 200; // Adjust this value as needed } getAwayFromGoalPosition(car) { const goal = this.getTeamGoal(car.teamColor); const angle = Phaser.Math.Angle.Between(goal.x, goal.y, car.x, car.y); return { x: car.x + Math.cos(angle) * 300, y: car.y + Math.sin(angle) * 300 }; } getRemainingCircles() { const freeCircles = this.circles.length; const attachedCircles = this.aiCars.concat(this.playerCar).reduce((sum, car) => sum + car.attachedCircles.length, 0); return freeCircles + attachedCircles; } getOptimalScoringPath(car) { const goal = this.getTeamGoal(car.teamColor); const directPath = new Phaser.Math.Vector2(goal.x - car.x, goal.y - car.y); const enemies = this.getVisibleEnemies(car); let bestPath = directPath; let minInterference = Number.MAX_VALUE; for (let angle = -Math.PI / 4; angle <= Math.PI / 4; angle += Math.PI / 8) { const rotatedPath = directPath.rotate(angle); let interference = 0; for (const enemy of enemies) { const enemyVector = new Phaser.Math.Vector2(enemy.x - car.x, enemy.y - car.y); interference += Math.abs(rotatedPath.dot(enemyVector)) / enemyVector.length(); } if (interference < minInterference) { minInterference = interference; bestPath = rotatedPath; } } return { x: car.x + bestPath.x, y: car.y + bestPath.y }; } getTeamStrategy(car) { const teamScores = { 0x0000FF: this.scores.blue, 0x00FF00: this.scores.green, 0xFF0000: this.scores.red, 0x800080: this.scores.purple }; const ourScore = teamScores[car.teamColor]; const maxEnemyScore = Math.max(...Object.values(teamScores).filter(score => score !== ourScore)); if (ourScore > maxEnemyScore + 5) return 'defensive'; if (maxEnemyScore > ourScore + 5) return 'aggressive'; return 'balanced'; } getStrategicPosition(car, strategy) { const goal = this.getTeamGoal(car.teamColor); const centerX = 1250, centerY = 1250; const worldWidth = 2500, worldHeight = 2500; // If the car is near the edge, move it towards the center const edgeThreshold = 100; if (car.x < edgeThreshold || car.x > worldWidth - edgeThreshold || car.y < edgeThreshold || car.y > worldHeight - edgeThreshold) { return { x: centerX, y: centerY }; } switch (strategy) { case 'aggressive': return { x: Phaser.Math.Between(centerX - 500, centerX + 500), y: Phaser.Math.Between(centerY - 500, centerY + 500) }; case 'defensive': return { x: Phaser.Math.Between(goal.x - 300, goal.x + 300), y: Phaser.Math.Between(goal.y - 300, goal.y + 300) }; default: // balanced return this.getFallbackTarget(car, worldWidth, worldHeight); } } getPredictedEnemyPosition(enemy) { const predictionTime = 0.5; // Predict 0.5 seconds ahead return { x: enemy.x + enemy.body.velocity.x * predictionTime, y: enemy.y + enemy.body.velocity.y * predictionTime }; } getSpeedMultiplier(car, state) { let baseMultiplier = 1.2; // Increase base speed for all modes switch (state.mode) { case 'intercept': baseMultiplier = 1.5; break; case 'gangUp': baseMultiplier = 1.4; break; case 'score': baseMultiplier = 1.6 - (car.attachedCircles.length * 0.03); // Slower as more circles are attached break; case 'protect': baseMultiplier = 1.5; break; case 'escort': baseMultiplier = 1.4; break; } // Adjust speed based on the number of attached circles baseMultiplier *= 1 - (car.attachedCircles.length * 0.02); // 2% slower for each attached circle return Math.max(baseMultiplier, 0.8); // Ensure the car doesn't become too slow } getFallbackTarget(car, worldWidth, worldHeight) { if (!car.fallbackTarget || car.fallbackTimer <= 0 || Phaser.Math.Distance.Between(car.x, car.y, car.fallbackTarget.x, car.fallbackTarget.y) < 50) { car.fallbackTarget = this.getNewSearchTarget(car, worldWidth, worldHeight); car.fallbackTimer = Phaser.Math.Between(120, 180); } car.fallbackTimer--; // If the car has been stuck for too long, force a new target if (car.state.stuckTime > 120) { car.fallbackTarget = this.getNewSearchTarget(car, worldWidth, worldHeight); car.state.stuckTime = 0; } return car.fallbackTarget; } findNearestTeammate(car) { return this.aiCars .filter(c => c !== car && c.teamColor === car.teamColor) .reduce((nearest, c) => { const distance = Phaser.Math.Distance.Between(car.x, car.y, c.x, c.y); return (nearest && nearest.distance < distance) ? nearest : { car: c, distance }; }, null)?.car; } shouldDefendTeammate(car, teammate) { if (!teammate || teammate.attachedCircles.length === 0) return false; const enemiesNearTeammate = this.getVisibleEnemies(teammate).filter(e => Phaser.Math.Distance.Between(teammate.x, teammate.y, e.x, e.y) < 300 ); return enemiesNearTeammate.length > 0; } getDefensivePosition(car, teammate) { const angle = Phaser.Math.Angle.Between(teammate.x, teammate.y, this.getTeamGoal(car.teamColor).x, this.getTeamGoal(car.teamColor).y); return { x: teammate.x + Math.cos(angle) * 100, y: teammate.y + Math.sin(angle) * 100 }; } getNewSearchTarget(car, worldWidth, worldHeight) { const angle = Phaser.Math.Between(0, 360) * (Math.PI / 180); const distance = Phaser.Math.Between(300, 800); return { x: Phaser.Math.Clamp(car.x + Math.cos(angle) * distance, 0, worldWidth), y: Phaser.Math.Clamp(car.y + Math.sin(angle) * distance, 0, worldHeight) }; } update() { // Update music this.updateMusic(); if (this.playerCar) { if (this.cursors.up.isDown) { this.speed = Math.min(this.speed + this.acceleration, this.maxSpeed); } else if (this.cursors.down.isDown) { this.speed = Math.max(this.speed - this.acceleration, -this.maxReverseSpeed); } else { if (this.speed > 0) { this.speed = Math.max(this.speed - this.deceleration, 0); } else if (this.speed < 0) { this.speed = Math.min(this.speed + this.deceleration, 0); } } if (this.cursors.left.isDown) { this.playerCar.angle -= this.turnSpeed * (180 / Math.PI) * (this.speed / this.maxSpeed); } else if (this.cursors.right.isDown) { this.playerCar.angle += this.turnSpeed * (180 / Math.PI) * (this.speed / this.maxSpeed); } const rotation = this.playerCar.rotation; this.playerCar.setVelocity( Math.cos(rotation) * this.speed, Math.sin(rotation) * this.speed ); // Prevent physical interactions from changing the player car's rotation this.playerCar.setAngularVelocity(0); this.cameras.main.setRotation(Math.PI * 3 / 2 - this.playerCar.rotation); } for (const aiCar of this.aiCars) { this.updateAICar(aiCar); } this.tetherGraphics.clear(); let remainingCircles = this.circles.length; this.matter.world.getAllBodies().forEach(body => { if (body.gameObject && body.gameObject.type === 'car') { const car = body.gameObject; if (this.isCarInGoal(car)) { const points = car.attachedCircles.length; if (car.teamColor === 0x0000FF) { this.scores.blue += points; } else if (car.teamColor === 0x00FF00) { this.scores.green += points; } else if (car.teamColor === 0xFF0000) { this.scores.red += points; } else if (car.teamColor === 0x800080) { this.scores.purple += points; } car.attachedCircles.forEach(circle => { if (circle.gameObject) { circle.gameObject.destroy(); } this.matter.world.remove(circle); this.matter.world.removeConstraint(circle.constraint); }); car.attachedCircles = []; } else { car.attachedCircles.forEach(circle => { circle.gameObject.setPosition(circle.position.x, circle.position.y); const relativeCarX = car.x - this.playerCar.x; const relativeCarY = car.y - this.playerCar.y; const relativeCircleX = circle.position.x - this.playerCar.x; const relativeCircleY = circle.position.y - this.playerCar.y; const cosRotation = Math.cos(-this.playerCar.rotation - Math.PI / 2); const sinRotation = Math.sin(-this.playerCar.rotation - Math.PI / 2); const rotatedCarX = relativeCarX * cosRotation - relativeCarY * sinRotation; const rotatedCarY = relativeCarX * sinRotation + relativeCarY * cosRotation; const rotatedCircleX = relativeCircleX * cosRotation - relativeCircleY * sinRotation; const rotatedCircleY = relativeCircleX * sinRotation + relativeCircleY * cosRotation; this.tetherGraphics.lineStyle(1, 0x000000, 0.3); this.tetherGraphics.beginPath(); this.tetherGraphics.moveTo( this.cameras.main.width / 2 + rotatedCarX * this.cameras.main.zoom, this.cameras.main.height / 2 + rotatedCarY * this.cameras.main.zoom ); this.tetherGraphics.lineTo( this.cameras.main.width / 2 + rotatedCircleX * this.cameras.main.zoom, this.cameras.main.height / 2 + rotatedCircleY * this.cameras.main.zoom ); this.tetherGraphics.closePath(); this.tetherGraphics.strokePath(); }); remainingCircles += car.attachedCircles.length; } } }); this.updateScoreTexts(); if (this.circleCountText) { this.circleCountText.setText(`Circles Left: ${remainingCircles}`); } // Update the "Maximum Load" text visibility if (this.maxLoadText) { this.maxLoadText.setVisible(this.playerCar.attachedCircles.length >= 10); } // Update the winning team this.winningTeam = this.getWinningTeam(); if (this.gameTimer <= 0 || remainingCircles <= 0) { this.startNewRound(); } } shouldGangUp(car) { const enemies = this.getVisibleEnemies(car); const teammatesToGangUp = this.aiCars.filter(c => c.teamColor === car.teamColor && Phaser.Math.Distance.Between(c.x, c.y, car.x, car.y) < 400); for (const enemy of enemies) { if (enemy.attachedCircles.length > 0 || teammatesToGangUp.length >= 1) { return true; } } return Math.random() < 0.3; // 30% chance to gang up even if conditions are not met } isUnderThreat(car) { const nearbyEnemies = this.getVisibleEnemies(car).filter(enemy => Phaser.Math.Distance.Between(car.x, car.y, enemy.x, enemy.y) < 300 ); return nearbyEnemies.length > 0 || car.attachedCircles.length > 0; } isUnderSevereThread(car) { const nearbyEnemies = this.getVisibleEnemies(car).filter(enemy => Phaser.Math.Distance.Between(car.x, car.y, enemy.x, enemy.y) < 200 ); return nearbyEnemies.length >= 2 || (nearbyEnemies.length > 0 && car.attachedCircles.length >= 5); } } const config = { type: Phaser.AUTO, parent: 'renderDiv', width: 800, height: 600, scale: { mode: Phaser.Scale.FIT, autoCenter: Phaser.Scale.CENTER_BOTH, }, physics: { default: 'matter', matter: { gravity: { y: 0 }, debug: false } }, scene: MainScene }; window.phaserGame = new Phaser.Game(config);