// Configuration object const configAI = { wanderDurationRange: { min: 500, max: 3500 }, // Range for the wander duration (in milliseconds) wanderResetDuration: 5000, // Duration after which the wander cycle should be reset (in milliseconds) chaseRange: 240, // Maximum distance (in pixels) at which the bubble should start chasing a smaller bubble chaseTimeout: 2000, // Maximum duration (in milliseconds) for which the bubble should chase a smaller bubble before switching back to Wander mode chaseForce: 1.5, // Force multiplier to apply when chasing a smaller bubble fleeRange: 50, // Maximum distance (in pixels) at which the bubble should start fleeing from a larger bubble fleeTimeout: 3500, // Maximum duration (in milliseconds) for which the bubble should flee from a larger bubble before switching back to Wander mode fleeForce: 2.0, // Force multiplier to apply when fleeing from a larger bubble modeEvaluationInterval: 100, // Interval (in milliseconds) at which the bubble should evaluate its current mode and decide whether to switch modes modePriority: ['Flee', 'Chase', 'Wander'], // Priority order for selecting modes postCollisionWanderDuration: 1000, // Duration (in milliseconds) for which the remaining bubbles should switch to Wander mode after a collision maxSpeed: 200, // Maximum speed (in pixels per second) at which the bubbles can move minMass: 1, // Minimum mass value for a bubble maxMass: 10, // Maximum mass value for a bubble moveForce: 0.0005 }; class Bubble extends Phaser.Physics.Matter.Sprite { constructor(scene, x, y, texture, frame, options) { super(scene.matter.world, x, y, texture, frame, options); this.setCircle(); this.setBounce(1); this.setFriction(0); this.mass = options.mass; this.durability = options.mass; this.maxDurability = options.mass; this.isAI = options.isAI || false; this.scene = scene; this.waypoint = null; this.lastWaypointTime = 0; this.wanderStartTime = 0; scene.add.existing(this); if (!this.isAI) { this.keys = scene.input.keyboard.createCursorKeys(); } console.log(`Bubble created with mass: ${this.mass}, durability: ${this.durability}`); } destroy() { if (this.aiTimer) { this.aiTimer.remove(); } super.destroy(); } updateAIState() { if (!this.scene || !this.scene.bubbleManager || !this.body) return; const flee = this.evaluateBehavior('flee', configAI.fleeRange); if (flee) { this.state = 'Flee'; return; } const chase = this.evaluateBehavior('chase', configAI.chaseRange); if (chase) { this.state = 'Chase'; return; } this.state = 'Wander'; this.setRandomWaypoint(); } executeAI() { if (!this.scene || !this.scene.bubbleManager || !this.body) return; switch (this.state) { case 'Flee': this.performBehavior('flee', configAI.fleeRange); break; case 'Chase': this.performBehavior('chase', configAI.chaseRange); break; case 'Wander': if (this.scene.time.now - this.wanderStartTime > configAI.wanderResetDuration) { this.wanderStartTime = 0; } this.moveToWaypoint(); break; default: this.wander(); break; } } setRandomWaypoint() { const diameter = this.width; const minDistance = diameter * 2; const maxDistance = diameter * 5; const halfWidth = this.width / 2; const halfHeight = this.height / 2; const worldWidth = this.scene.worldWidth; const worldHeight = this.scene.worldHeight; let angle, distance, waypointX, waypointY; do { angle = Phaser.Math.Between(0, 360); distance = Phaser.Math.Between(minDistance, maxDistance); waypointX = this.x + distance * Math.cos(angle); waypointY = this.y + distance * Math.sin(angle); waypointX = Phaser.Math.Clamp(waypointX, halfWidth, worldWidth - halfWidth); waypointY = Phaser.Math.Clamp(waypointY, halfHeight, worldHeight - halfHeight); } while (waypointX === this.x && waypointY === this.y); this.waypoint = { x: waypointX, y: waypointY }; this.lastWaypointTime = this.scene.time.now; if (this.state === 'Wander' && this.wanderStartTime === 0) { this.wanderStartTime = this.scene.time.now; } } moveToWaypoint() { if (this.waypoint) { const dx = this.waypoint.x - this.x; const dy = this.waypoint.y - this.y; const distance = Math.sqrt(dx * dx + dy * dy); if (distance < 10 || this.scene.time.now - this.lastWaypointTime > 1000) { this.setRandomWaypoint(); } else { const forceX = (dx / distance) * configAI.moveForce; const forceY = (dy / distance) * configAI.moveForce; this.applyForce({ x: forceX, y: forceY }); } } else { this.setRandomWaypoint(); } } evaluateBehavior(type, distance) { const closestBubble = this.scene.bubbleManager.bubbles.reduce((prev, current) => { if (!current || current === this) return prev; const prevDist = Phaser.Math.Distance.Between(prev.x, prev.y, this.x, this.y); const currentDist = Phaser.Math.Distance.Between(current.x, current.y, this.x, this.y); return prevDist < currentDist ? prev : current; }); if (closestBubble) { const bubbleDistance = Phaser.Math.Distance.Between(this.x, this.y, closestBubble.x, closestBubble.y); if (type === 'flee' && closestBubble.mass > this.mass && bubbleDistance < distance) { return true; } if (type === 'chase' && closestBubble.mass < this.mass && bubbleDistance < distance) { return true; } } return false; } performBehavior(type, distance) { const closestBubble = this.scene.bubbleManager.bubbles.reduce((prev, current) => { if (!current || current === this) return prev; const prevDist = Phaser.Math.Distance.Between(prev.x, prev.y, this.x, this.y); const currentDist = Phaser.Math.Distance.Between(current.x, current.y, this.x, this.y); return prevDist < currentDist ? prev : current; }); if (closestBubble) { const dx = closestBubble.x - this.x; const dy = closestBubble.y - this.y; const bubbleDistance = Math.sqrt(dx * dx + dy * dy); if (type === 'flee' && closestBubble.mass > this.mass && bubbleDistance < distance) { const fleeX = (-dx / bubbleDistance) * configAI.moveForce * configAI.fleeForce; const fleeY = (-dy / bubbleDistance) * configAI.moveForce * configAI.fleeForce; this.applyForce({ x: fleeX, y: fleeY }); return true; } if (type === 'chase' && closestBubble.mass < this.mass && bubbleDistance < distance) { const chaseX = (dx / bubbleDistance) * configAI.moveForce * configAI.chaseForce; const chaseY = (dy / bubbleDistance) * configAI.moveForce * configAI.chaseForce; this.applyForce({ x: chaseX, y: chaseY }); return true; } } return false; } handlePlayerInput(cursors) { const force = configAI.moveForce; const frictionFactor = 0.99995; let velocityX = this.body.velocity.x; let velocityY = this.body.velocity.y; if (cursors.left.isDown) { this.applyForce({ x: -force, y: 0 }); } else if (cursors.right.isDown) { this.applyForce({ x: force, y: 0 }); } else { velocityX *= frictionFactor; } if (cursors.up.isDown) { this.applyForce({ x: 0, y: -force }); } else if (cursors.down.isDown) { this.applyForce({ x: 0, y: force }); } else { velocityY *= frictionFactor; } this.setVelocity(velocityX, velocityY); } burst(impactForce) { if (impactForce > this.durability) { const numChildBubbles = Phaser.Math.Between(2, 5); const totalMass = this.mass; const childMasses = this.distributeChildMasses(totalMass, numChildBubbles); const childBubbles = []; for (let i = 0; i < numChildBubbles; i++) { const childBubble = this.scene.bubbleManager.createBubble(this.x, this.y, 'aiBubble', { mass: childMasses[i], isAI: true }); childBubbles.push(childBubble); } const totalChildMass = childBubbles.reduce((sum, bubble) => sum + bubble.mass, 0); const massRatio = totalMass / totalChildMass; childBubbles.forEach(bubble => { bubble.mass *= massRatio; bubble.durability = bubble.mass; bubble.maxDurability = bubble.mass; }); if (!this.isAI) { const largestChildBubble = childBubbles.reduce((a, b) => (a.mass > b.mass ? a : b)); if (largestChildBubble.mass >= this.scene.bubbleManager.configAI.minMass) { this.scene.playerBubble = largestChildBubble; largestChildBubble.isAI = false; largestChildBubble.setTexture('playerBubble'); if (largestChildBubble.aiTimer) { largestChildBubble.aiTimer.remove(); } } else { this.scene.endGame(); } } this.applyChildVelocities(childBubbles); this.scene.bubbleManager.destroyBubble(this); } } distributeChildMasses(totalMass, numChildBubbles) { const childMasses = []; for (let i = 0; i < numChildBubbles; i++) { childMasses.push(Phaser.Math.Between(1, totalMass / numChildBubbles)); } return childMasses; } applyChildVelocities(childBubbles) { const impactPoint = new Phaser.Math.Vector2(this.x, this.y); for (let childBubble of childBubbles) { const direction = new Phaser.Math.Vector2(childBubble.x - impactPoint.x, childBubble.y - impactPoint.y).normalize(); childBubble.setVelocity(direction.x * 5, direction.y * 5); } } rescale(minMass, maxMass) { const maxDimension = 65; const minDimension = 15; let scale = 0; if (maxMass !== minMass) { scale = (this.mass - minMass) / (maxMass - minMass); } else { scale = 1; } const size = minDimension + scale * (maxDimension - minDimension); const spriteScale = size / Math.max(this.width, this.height); this.setScale(spriteScale); } applyTint() { const tintIntensity = 1 - (this.durability / this.maxDurability); const tintColor = Phaser.Display.Color.GetColor(tintIntensity * 255, 0, 0); this.setTint(tintColor, 0xffffff, 0xffffff * (1 - tintIntensity), 0xffffff * (1 - tintIntensity), 0xffffff * (1 - tintIntensity)); if (this.durability === this.maxDurability) { this.clearTint(); } } } class Obstacle extends Phaser.Physics.Matter.Sprite { constructor(scene, x, y, texture, width, height) { super(scene.matter.world, x, y, texture, null, { isSensor: true }); this.scene = scene; const sprite = scene.textures.get(texture).getSourceImage(); const spriteWidth = sprite.width; const spriteHeight = sprite.height; const scale = Math.max(width, height) / Math.max(spriteWidth, spriteHeight); this.setScale(scale); this.setRectangle(width, height); this.setFriction(Infinity); scene.add.existing(this); this.setAlpha(0); this.setCollisionCategory(0x0000); this.setDepth(5); // Set depth for obstacles this.fadeInTween = scene.tweens.add({ targets: this, alpha: 1, duration: 5000, onComplete: () => { if (this.scene && !this.scene.isGameOver) { this.setCollisionCategory(0x0002); this.setSensor(false); this.setStatic(true); } } }); this.removeTimer = scene.time.delayedCall(10000, () => { this.removeObstacle(); }, [], this); // Add gravity well effect this.gravityWellRadius = Math.max(width, height) * 5; // Increased radius for a wider effect this.baseGravityStrength = 0.0000005; // Adjusted base gravity strength this.isDestroyed = false; this.gravityWellGraphic = this.scene.add.graphics(); } removeObstacle() { if (this.scene && !this.scene.isGameOver) { this.scene.tweens.add({ targets: this, alpha: 0, duration: 500, onComplete: () => { this.destroy(); } }); } else { this.destroy(); } } destroy(fromScene) { this.isDestroyed = true; if (this.removeTimer) { this.removeTimer.remove(); } if (this.fadeInTween) { this.fadeInTween.stop(); } if (this.gravityWellGraphic) { this.gravityWellGraphic.clear(); this.gravityWellGraphic.destroy(); } super.destroy(fromScene); } applyGravityWell(bubble) { if (this.isDestroyed) return; const dx = this.x - bubble.x; const dy = this.y - bubble.y; const distanceSquared = dx * dx + dy * dy; if (distanceSquared < this.gravityWellRadius * this.gravityWellRadius) { const distance = Math.sqrt(distanceSquared); const normalizedDistance = distance / this.gravityWellRadius; // More dramatic inverse square law for force calculation const forceMagnitude = this.baseGravityStrength / (Math.pow(normalizedDistance, 2.5) + 0.01); // Sharper falloff at the edge of the gravity well const edgeFalloff = 1 - Math.pow(normalizedDistance, 3); const finalForceMagnitude = forceMagnitude * edgeFalloff; const forceX = (dx / distance) * finalForceMagnitude; const forceY = (dy / distance) * finalForceMagnitude; bubble.applyForce({ x: forceX, y: forceY }); } } updateGravityWellGraphic() { if (this.isDestroyed) return; this.gravityWellGraphic.clear(); // Logarithmic-like spacing for the rings const ringRadii = [ this.gravityWellRadius * 0.18, // Innermost ring (closest to the obstacle) this.gravityWellRadius * 0.28, // Second ring (still close) this.gravityWellRadius * 0.4, // Third ring (significant jump) this.gravityWellRadius // Outermost ring ]; // Adjust alphas to make inner rings more visible const alphas = [0.2, 0.15, 0.1, 0.05]; for (let i = 0; i < 4; i++) { this.gravityWellGraphic.lineStyle(2, 0x00ff00, alphas[i]); this.gravityWellGraphic.strokeCircle(this.x, this.y, ringRadii[i]); } } } class BubbleManager { constructor(scene, configAI) { this.scene = scene; this.bubbles = []; this.obstacles = []; this.minMass = Infinity; this.maxMass = -Infinity; this.configAI = configAI; // Store the AI configuration object this.setupCollisionHandler(); this.setupObstacleSpawner(); } setupCollisionHandler() { this.scene.matter.world.on('collisionstart', (event, bodyA, bodyB) => { this.handleCollision(event, bodyA, bodyB); }); } setupObstacleSpawner() { this.spawnObstacleTimer = this.scene.time.addEvent({ delay: 5000, callback: this.manageObstacles, callbackScope: this, loop: true }); } manageObstacles() { if (this.scene.isGameOver) return; // Remove destroyed obstacles this.obstacles = this.obstacles.filter(obstacle => !obstacle.isDestroyed); const currentObstacleCount = this.obstacles.length; const maxObstacles = 3; const minObstacles = 1; if (currentObstacleCount < minObstacles) { // Spawn at least one obstacle if there are none this.spawnObstacle(); } else if (currentObstacleCount < maxObstacles) { // Randomly decide whether to spawn a new obstacle if (Phaser.Math.Between(0, 1) === 1) { this.spawnObstacle(); } } } reset() { // Clear all bubbles and obstacles this.bubbles.forEach(bubble => bubble.destroy()); this.obstacles.forEach(obstacle => obstacle.destroy()); this.bubbles = []; this.obstacles = []; this.minMass = Infinity; this.maxMass = -Infinity; // Reset the obstacle spawner if (this.spawnObstacleTimer) { this.spawnObstacleTimer.remove(); } this.spawnObstacleTimer = null; } spawnObstacle() { if (this.scene.isGameOver) return; const minWidth = 20; const maxWidth = 85; const minHeight = 20; const maxHeight = 85; const width = Phaser.Math.Between(minWidth, maxWidth); const height = Phaser.Math.Between(minHeight, maxHeight); const x = Phaser.Math.Between(width / 2, this.scene.cameras.main.width - width / 2); const y = Phaser.Math.Between(height / 2, this.scene.cameras.main.height - height / 2); const obstacle = new Obstacle(this.scene, x, y, 'Tile', width, height); this.obstacles.push(obstacle); } handleCollision(event, bodyA, bodyB) { const bubbleA = this.bubbles.find(b => b.body === bodyA); const bubbleB = this.bubbles.find(b => b.body === bodyB); const obstacle = this.obstacles.find(o => o.body === bodyA || o.body === bodyB); if (obstacle || bodyA.gameObject === null || bodyB.gameObject === null) { const bubble = bubbleA || bubbleB; if (bubble) { const impactForce = this.calculateImpactForce(bubble.body); bubble.durability -= impactForce; if (bubble.durability <= 0) { bubble.burst(impactForce); } else { setTimeout(() => { this.startDurabilityRegeneration(bubble); }, 1000); } bubble.applyTint(); } return; } if (bubbleA && bubbleB) { if (bubbleA.mass > bubbleB.mass) { bubbleA.mass += bubbleB.mass; bubbleA.durability += bubbleB.durability; bubbleA.maxDurability = bubbleA.durability; this.destroyBubble(bubbleB); } else { bubbleB.mass += bubbleA.mass; bubbleB.durability += bubbleA.durability; bubbleB.maxDurability = bubbleB.durability; this.destroyBubble(bubbleA); } this.updateMinMaxMass(); } } spawnObstacle() { const minWidth = 20; const maxWidth = 85; const minHeight = 20; const maxHeight = 85; const width = Phaser.Math.Between(minWidth, maxWidth); const height = Phaser.Math.Between(minHeight, maxHeight); let x, y; let validPosition = false; const minDistance = 100; // Minimum distance between obstacles // Try to find a valid position for (let attempts = 0; attempts < 10; attempts++) { x = Phaser.Math.Between(width / 2, this.scene.cameras.main.width - width / 2); y = Phaser.Math.Between(height / 2, this.scene.cameras.main.height - height / 2); validPosition = this.obstacles.every(obstacle => { const distance = Phaser.Math.Distance.Between(x, y, obstacle.x, obstacle.y); return distance > minDistance; }); if (validPosition) break; } if (validPosition) { const obstacle = new Obstacle(this.scene, x, y, 'Tile', width, height); this.obstacles.push(obstacle); } } startDurabilityRegeneration(bubble) { const regenerationDuration = 10000; const regenerationInterval = 100; const regenerationAmount = bubble.maxDurability / (regenerationDuration / regenerationInterval); const regenerationTimer = setInterval(() => { bubble.durability = Math.min(bubble.durability + regenerationAmount, bubble.maxDurability); bubble.applyTint(); if (bubble.durability >= bubble.maxDurability) { clearInterval(regenerationTimer); } }, regenerationInterval); } calculateImpactForce(body) { const velocity = new Phaser.Math.Vector2(body.velocity.x, body.velocity.y).length(); const kineticEnergy = 0.5 * body.mass * velocity * velocity; return kineticEnergy; } destroyBubble(bubble) { const index = this.bubbles.indexOf(bubble); if (index > -1) { this.bubbles.splice(index, 1); } bubble.destroy(); this.checkGameOver(); } checkGameOver() { if (!this.bubbles.some(bubble => !bubble.isAI)) { this.scene.endGame(); } } createBubble(x, y, texture, options) { const bubble = new Bubble(this.scene, x, y, texture, null, options); bubble.isAI = options.isAI || false; bubble.setDepth(10); // Set depth for bubbles if (bubble.isAI) { bubble.state = 'Wander'; bubble.aiTimer = this.scene.time.addEvent({ delay: 500, callback: () => { bubble.updateAIState(); bubble.executeAI(); }, callbackScope: bubble, loop: true }); } this.bubbles.push(bubble); this.updateMinMaxMass(); return bubble; } createPlayerBubble(x, y, texture, options) { const bubble = this.createBubble(x, y, texture, { ...options, isAI: false }); return bubble; } createAIBubble(x, y, texture, options) { const minDistance = 50; // Minimum distance between bubbles let validPosition = false; let attempts = 0; const maxAttempts = 50; // Maximum number of attempts to find a valid position while (!validPosition && attempts < maxAttempts) { validPosition = true; for (let existingBubble of this.bubbles) { const distance = Phaser.Math.Distance.Between(x, y, existingBubble.x, existingBubble.y); if (distance < minDistance) { validPosition = false; x = Phaser.Math.Between(100, 700); y = Phaser.Math.Between(100, 500); break; } } attempts++; } if (validPosition) { const bubble = this.createBubble(x, y, texture, { ...options, isAI: true }); return bubble; } else { console.log("Failed to find a valid position for new bubble after " + maxAttempts + " attempts"); return null; } } updateMinMaxMass() { if (this.minMass === Infinity) this.minMass = this.bubbles[0].mass; if (this.maxMass === -Infinity) this.maxMass = this.bubbles[0].mass; this.minMass = Math.min(this.minMass, ...this.bubbles.map(b => b.mass)); this.maxMass = Math.max(this.maxMass, ...this.bubbles.map(b => b.mass)); this.rescaleBubbles(); } rescaleBubbles() { for (let bubble of this.bubbles) { bubble.rescale(this.minMass, this.maxMass); bubble.applyTint(); } } update(cursors) { for (let bubble of this.bubbles) { if (!bubble.isAI) { bubble.handlePlayerInput(cursors); } // Apply gravity well effect from all obstacles for (let i = this.obstacles.length - 1; i >= 0; i--) { const obstacle = this.obstacles[i]; if (obstacle.isDestroyed) { this.obstacles.splice(i, 1); } else { obstacle.applyGravityWell(bubble); obstacle.updateGravityWellGraphic(); } } } // Check if the total number of bubbles is below the minimum if (this.bubbles.length < 4) { const playerBubble = this.bubbles.find(bubble => !bubble.isAI); if (!playerBubble) return; // Safety check const playerBubbleMass = playerBubble.mass; const desiredTotalMass = playerBubbleMass * 4; const spawnMinMass = playerBubbleMass * 0.2; const spawnMaxMass = playerBubbleMass * 1.3; // Reduced to ensure smaller bubbles let spawnedTotalMass = 0; let smallerBubbleSpawned = false; let spawnAttempts = 0; const maxSpawnAttempts = 20; // Maximum number of spawn attempts while ((spawnedTotalMass < desiredTotalMass || !smallerBubbleSpawned) && spawnAttempts < maxSpawnAttempts) { let newBubbleMass; if (!smallerBubbleSpawned) { // Ensure at least one bubble is smaller than the player newBubbleMass = Phaser.Math.Between(spawnMinMass, playerBubbleMass * 0.8); } else { newBubbleMass = Phaser.Math.Between(spawnMinMass, spawnMaxMass); } const x = Phaser.Math.Between(100, 700); const y = Phaser.Math.Between(100, 500); const newBubble = this.createAIBubble(x, y, 'aiBubble', { mass: newBubbleMass }); if (newBubble) { spawnedTotalMass += newBubbleMass; if (!smallerBubbleSpawned && newBubbleMass < playerBubbleMass) { smallerBubbleSpawned = true; } } spawnAttempts++; // Break the loop if we've spawned enough mass and a smaller bubble if (spawnedTotalMass >= desiredTotalMass && smallerBubbleSpawned) { break; } } if (spawnAttempts >= maxSpawnAttempts) { console.log("Max spawn attempts reached. Some bubbles may not have been spawned."); } } } } class UIScene extends Phaser.Scene { constructor() { super({ key: 'UIScene', active: true }); } create() { this.gameScene = this.scene.get('GameScene'); } showGameOverPopup(score) { const x = this.cameras.main.width / 2; const y = this.cameras.main.height / 2; // Calculate the size of the popup based on the content const padding = 40; const width = Math.max(300, 250 + padding * 2); const height = 200; // Create the popup background const popup = this.add.graphics(); popup.fillStyle(0x000000, 0.8); popup.fillRoundedRect(x - width / 2, y - height / 2, width, height, 20); const title = this.add.text(x, y - 60, 'Game Over', { fontSize: '32px', fill: '#fff' }).setOrigin(0.5); const formattedScore = this.formatLargeNumber(score); const scoreText = this.add.text(x, y, `Score: ${formattedScore}`, { fontSize: '24px', fill: '#fff' }).setOrigin(0.5); const restartButton = this.add.text(x, y + 60, 'Try Again', { fontSize: '24px', fill: '#fff', backgroundColor: '#4a4a4a', padding: { x: 10, y: 5 } }).setOrigin(0.5); restartButton.setInteractive({ useHandCursor: true }); restartButton.on('pointerdown', () => { this.hideGameOverPopup(); this.gameScene.restartGame(); }); this.gameOverPopup = { popup, title, scoreText, restartButton }; } hideGameOverPopup() { if (this.gameOverPopup) { this.gameOverPopup.popup.destroy(); this.gameOverPopup.title.destroy(); this.gameOverPopup.scoreText.destroy(); this.gameOverPopup.restartButton.destroy(); this.gameOverPopup = null; } } formatLargeNumber(number) { if (number === 0) return "0"; const exponent = Math.floor(Math.log10(Math.abs(number))); const mantissa = number / Math.pow(10, exponent); return mantissa.toFixed(3) + " e" + exponent; } } class Example extends Phaser.Scene { constructor() { super({ key: 'GameScene' }); this.worldWidth = 800; this.worldHeight = 600; this.score = 0; this.isGameOver = false; this.musicManager = new MusicManager(this); } preload() { this.load.image('sky', 'https://play.rosebud.ai/assets/Cosmosis_background.png?mEYo'); this.load.image('Tile', 'https://play.rosebud.ai/assets/tile.png?CHA7'); this.load.image('aiBubble', 'https://play.rosebud.ai/assets/bubble 3.png?yqab'); this.load.image('playerBubble', 'https://play.rosebud.ai/assets/bubble.png?iaal'); this.load.image('muteButton', 'https://play.rosebud.ai/assets/sound-off.png?1dSK'); this.load.image('skipButton', 'https://play.rosebud.ai/assets/next-button.png?jdZV'); this.load.image('helpButton', 'https://play.rosebud.ai/assets/help.png?6qhh'); // Add this line this.musicManager.preload(); } create() { // Set background with lowest depth this.add.image(400, 300, 'sky').setDepth(-1); this.bubbleManager = new BubbleManager(this, configAI); this.matter.world.setBounds(0, 0, this.worldWidth, this.worldHeight, 32, true, true, true, true); this.playerBubble = this.bubbleManager.createPlayerBubble(400, 300, 'playerBubble', { mass: 10 }); this.cursors = this.input.keyboard.createCursorKeys(); for (let i = 0; i < 10; i++) { this.bubbleManager.createAIBubble( Phaser.Math.Between(100, 700), Phaser.Math.Between(100, 500), 'aiBubble', { mass: Phaser.Math.Between(1, 5) } ); } // Add help button const helpButton = this.add.image(40, 40, 'helpButton') .setInteractive({ useHandCursor: true }) .setScale(0.15) .setDepth(1000); helpButton.on('pointerdown', () => { this.scene.pause(); this.scene.launch('HelpScene'); }); // Add score text this.scoreText = this.add.text(80, 30, 'Score: 0', { fontSize: '24px', fill: '#fff' }).setDepth(1000); this.formatScore(0); // Initialize with formatted score // Set up music this.musicManager.create(); // Add mute button const muteButton = this.add.image(this.worldWidth - 30, 30, 'muteButton') .setInteractive() .setScale(0.2) .setDepth(1000); muteButton.on('pointerdown', () => { this.musicManager.toggleMute(); muteButton.setTint(this.musicManager.isMuted ? 0xff0000 : 0xffffff); }); // Add skip button const skipButton = this.add.image(this.worldWidth - 75, 30, 'skipButton') .setInteractive() .setScale(0.15) .setDepth(1000); skipButton.on('pointerdown', () => { this.musicManager.nextSong(); }); } update() { this.bubbleManager.update(this.cursors); this.updateScore(); } updateScore() { if (this.playerBubble) { this.score = Math.floor(this.playerBubble.mass * 10); this.formatScore(this.score); } } formatScore(score) { const formattedScore = this.scene.get('UIScene').formatLargeNumber(score); this.scoreText.setText('Score: ' + formattedScore); } endGame() { this.isGameOver = true; this.matter.world.pause(); this.scene.pause(); this.scene.get('UIScene').showGameOverPopup(this.score); } restartGame() { this.score = 0; this.isGameOver = false; this.scoreText.setText('Score: 0'); this.bubbleManager.reset(); this.playerBubble = this.bubbleManager.createPlayerBubble(400, 300, 'playerBubble', { mass: 10 }); // Reset and shuffle the music playlist this.musicManager.create(); for (let i = 0; i < 10; i++) { this.bubbleManager.createAIBubble( Phaser.Math.Between(100, 700), Phaser.Math.Between(100, 500), 'aiBubble', { mass: Phaser.Math.Between(1, 5) } ); } this.bubbleManager.updateMinMaxMass(); this.bubbleManager.setupObstacleSpawner(); this.matter.world.resume(); this.scene.resume(); } } class HelpScene extends Phaser.Scene { constructor() { super({ key: 'HelpScene' }); } create() { const width = 500; const height = 400; const x = this.cameras.main.width / 2; const y = this.cameras.main.height / 2; // Create help popup const popup = this.add.graphics(); popup.fillStyle(0x000000, 0.8); popup.fillRoundedRect(x - width / 2, y - height / 2, width, height, 20); // Add title this.add.text(x, y - 160, 'How to Play', { fontSize: '32px', fill: '#fff' }).setOrigin(0.5); // Add instructions const instructions = [ 'Objective: Grow your bubble by absorbing smaller ones \n', 'Controls: Use arrow keys to move', 'Avoid: Larger bubbles and obstacles', 'Tip: Your bubble changes color as it takes damage' ]; const instructionsText = this.add.text(x - width / 2 + 30, y - 100, '', { fontSize: '20px', fill: '#fff', wordWrap: { width: width - 30, useAdvancedWrap: true } }); instructionsText.setText(instructions.join('\n\n')); // Add close button const closeButton = this.add.text(x, y + 160, 'Close', { fontSize: '24px', fill: '#fff', backgroundColor: '#4a4a4a', padding: { x: 20, y: 10 } }).setOrigin(0.5).setInteractive({ useHandCursor: true }); closeButton.on('pointerdown', () => { this.scene.stop(); this.scene.resume('GameScene'); }); } } const config = { type: Phaser.AUTO, parent: 'renderDiv', scale: { mode: Phaser.Scale.FIT, autoCenter: Phaser.Scale.CENTER_BOTH, }, width: 800, height: 600, physics: { default: 'matter', matter: { gravity: { y: 0 }, debug: false, } }, scene: [Example, UIScene, HelpScene], audio: { disableWebAudio: false } }; window.phaserGame = new Phaser.Game(config); class MusicManager { constructor(scene) { this.scene = scene; this.playlist = [ 'EtherealDreams1', 'EtherealDreams2', 'EtherealDreams3', 'HeavenlyEchoes' ]; this.currentSongIndex = 0; this.currentSong = null; this.isMuted = false; } shufflePlaylist() { for (let i = this.playlist.length - 1; i > 0; i--) { const j = Math.floor(Math.random() * (i + 1)); [this.playlist[i], this.playlist[j]] = [this.playlist[j], this.playlist[i]]; } } preload() { this.playlist.forEach((songKey, index) => { this.scene.load.audio(songKey, this.getSongURL(index)); }); } getSongURL(index) { const urls = [ 'https://play.rosebud.ai/assets/Ethereal Dreams.LOW.mp3?Bgit', 'https://play.rosebud.ai/assets/Ethereal Dreams(2).mp3?bOx2', 'https://play.rosebud.ai/assets/Ethereal Dreams (1).LOW.mp3?9Dyc', 'https://play.rosebud.ai/assets/Heavenly Echoes (1).LOW.mp3?ARBT' ]; return urls[index]; } create() { this.shufflePlaylist(); this.currentSongIndex = 0; this.playSong(); } playSong() { if (this.currentSong) { this.currentSong.stop(); } const songKey = this.playlist[this.currentSongIndex]; this.currentSong = this.scene.sound.add(songKey, { loop: false }); this.currentSong.play(); this.currentSong.once('complete', () => this.nextSong()); } nextSong() { this.currentSongIndex = (this.currentSongIndex + 1) % this.playlist.length; this.playSong(); } toggleMute() { this.isMuted = !this.isMuted; this.scene.sound.mute = this.isMuted; } }