class ParticleFactory { constructor(scene) { this.scene = scene; } createParticle() { const particle = this.scene.add.graphics(); Object.assign(particle, { x: 0, y: 0, size: 0, speedX: 0, speedY: 0, alpha: 1, shape: 'circle', vertices: null }); particle.customClear = () => particle?.clear(); return particle; } } class ParticlePool { constructor(factory) { this.factory = factory; this.pool = []; } get() { return this.pool.length > 0 ? this.pool.pop() : this.factory.createParticle(); } release(particle) { particle?.customClear?.(); this.pool.push(particle); } } class Background { constructor(scene, maxStars = 300, layer = null, assetKey = 'star') { Object.assign(this, { scene, stars: [], starPool: [], maxStars, layer: layer || scene.add.layer(), assetKey, screenWidth: scene.cameras.main.width, screenHeight: scene.cameras.main.height }); this.particles = []; this.interceptors = []; } create = () => Array(this.maxStars).fill().forEach(() => this.createStar()); createStar = () => { let star = this.starPool.pop() || this.scene.add.image(0, 0, this.assetKey); star?.setActive(true)?.setVisible(true); this.initializeStar(star); if (!this.starPool?.includes(star)) this.stars?.push(star); return star; } initializeStar = star => { const { Between: B, FloatBetween: FB } = Phaser.Math; Object.assign(star, { x: B(0, this.screenWidth), y: B(0, this.screenHeight), speedX: FB(-0.2, 0.2), speedY: FB(-0.2, 0.2), rotationSpeed: FB(-0.02, 0.02) }); star.setAlpha(FB(0.05, 0.3)).setScale(FB(0.001, 0.005)); } update = avgPos => this.stars.forEach(star => this.updateStar(star, avgPos)); updateStar = (star, avgPos) => { const { x, y } = star, distX = avgPos.x - x, distY = avgPos.y - y, dist = Math.sqrt(distX * distX + distY * distY), maxDist = Math.sqrt(this.screenWidth ** 2 + this.screenHeight ** 2), influence = 1 - (dist / maxDist); star.x += distX * 0.0005 * influence + star.speedX; star.y += distY * 0.0005 * influence + star.speedY; star.angle += star.rotationSpeed * this.scene.game.loop.delta; this.wrapStar(star); } wrapStar = (star) => { star.y = star.y > this.screenHeight ? 0 : star.y < 0 ? this.screenHeight : star.y; star.x = star.x > this.screenWidth ? 0 : star.x < 0 ? this.screenWidth : star.x; } recycleStar = star => { star.setActive(false).setVisible(false); this.starPool.push(star); this.createStar(); } } class StaticBackground extends Background {} class PlayerFollowingBackground extends Background { constructor(scene, maxStars = 300, layer = null, followSpeed = 0.02, assetKey = 'star') { super(scene, maxStars, layer, assetKey); this.followSpeed = followSpeed; } updateStar(star, playerPosition, playerVelocity) { super.updateStar(star, playerPosition); const { width: w, height: h } = this.scene.cameras.main; const [dx, dy] = [playerPosition.x - w / 2, playerPosition.y - h / 2]; star.x -= dx * this.followSpeed; star.y -= dy * this.followSpeed; const tf = Math.min(1, (Math.abs(playerVelocity.x) + Math.abs(playerVelocity.y)) / 10); star.setScale(star.baseScale * (1 + tf), star.baseScale * (1 - tf * 0.5)); this.wrapStar(star); } update(playerPosition, playerVelocity) { this.stars.forEach(star => this.updateStar(star, playerPosition, playerVelocity)); } } class TriangleBackground { constructor(scene, maxTriangles = 150) { Object.assign(this, { scene, maxTriangles, triangles: [], layer: scene.add.layer(), screenWidth: scene.cameras.main.width, screenHeight: scene.cameras.main.height }); } create = () => Array(this.maxTriangles).fill().forEach(() => this.createTriangle()); createTriangle = () => { const { Between: B, FloatBetween: FB } = Phaser.Math; const [x, y, size] = [B(0, this.screenWidth), B(0, this.screenHeight), FB(2, 8)]; const t = this.scene.add.triangle(x, y, 0, size, size, 0, 0, -size, 0xffffff); Object.assign(t, { speedX: FB(-0.02, 0.02), speedY: FB(-0.02, 0.02), rotationSpeed: FB(-0.001, 0.001), driftPhase: FB(0, Math.PI * 2), driftAmplitude: FB(0.04, 0.1), driftFrequency: FB(0.0002, 0.0006) }); t.setAlpha(FB(0.05, 0.3)).setDepth(-1); this.layer.add(t); this.triangles.push(t); } update = (playerPosition, time, delta) => { const { width: w, height: h } = this.scene.cameras.main; const [dx, dy] = [playerPosition.x - w / 2, playerPosition.y - h / 2]; this.triangles.forEach(t => { const [driftX, driftY] = [ Math.cos(time * t.driftFrequency + t.driftPhase) * t.driftAmplitude, Math.sin(time * t.driftFrequency + t.driftPhase) * t.driftAmplitude ]; t.x += t.speedX + dx * 0.001 + driftX; t.y += t.speedY + dy * 0.001 + driftY; t.rotation += t.rotationSpeed; if (t.x < 0) t.x = this.screenWidth; if (t.x > this.screenWidth) t.x = 0; if (t.y < 0) t.y = this.screenHeight; if (t.y > this.screenHeight) t.y = 0; }); } } class ShapeFactory { constructor(scene) { this.scene = scene; this.PURPLE_TRIANGLE_SIZE = 35; // Size for purple triangle } createRandomShape(x, y) { const size = Phaser.Math.Between(20, 80); const shapeType = Phaser.Math.Between(0, 3); // Changed to 0-3 for 4 shape types const baseOptions = { friction: 0, frictionAir: 0, restitution: 0.9 }; const baseDensity = 0.001; const densityMultiplier = 1 + (80 - size) / 60; const density = baseDensity * densityMultiplier; const options = { ...baseOptions, density: density }; let body; switch (shapeType) { case 0: // Square body = this.scene.matter.bodies.rectangle(x, y, size, size, options); break; case 1: // Rectangle const width = Phaser.Math.Between(30, 100); const height = Phaser.Math.Between(30, 100); body = this.scene.matter.bodies.rectangle(x, y, width, height, options); break; case 2: // Regular polygon const sides = Phaser.Math.Between(3, 8); // Triangle to octagon const polygonRadius = size / 2; body = this.scene.matter.bodies.polygon(x, y, sides, polygonRadius, options); break; case 3: // Circle body = this.scene.matter.bodies.circle(x, y, size / 2, options); break; } body.label = 'shape'; body.rotationSpeed = Phaser.Math.FloatBetween(-0.02, 0.02); const baseSpeed = Phaser.Math.FloatBetween(0, 2); const speedMultiplier = 1 / densityMultiplier; const speed = baseSpeed * speedMultiplier; const angle = Phaser.Math.FloatBetween(0, Math.PI * 2); if (Phaser.Math.FloatBetween(0, 1) > 0.3) { this.scene.matter.body.setVelocity(body, { x: Math.cos(angle) * speed, y: Math.sin(angle) * speed }); } else { this.scene.matter.body.setVelocity(body, { x: 0, y: 0 }); } return body; } createNegativeSquare(x, y) { const size = 40; const options = { label: 'negativeSquare', friction: 0, frictionAir: 0, restitution: 0.9, render: { fillStyle: 'transparent', strokeStyle: '#FFA500', // Changed to orange (hex code for orange) lineWidth: 2 } }; const body = this.scene.matter.bodies.rectangle(x, y, size, size, options); body.rotationSpeed = Phaser.Math.FloatBetween(-0.02, 0.02); const speed = Phaser.Math.FloatBetween(0.5, 1.5); const angle = Phaser.Math.FloatBetween(0, Math.PI * 2); this.scene.matter.body.setVelocity(body, { x: Math.cos(angle) * speed, y: Math.sin(angle) * speed }); return body; } createPurpleTriangle(x, y) { const options = { label: 'purpleTriangle', friction: 0, frictionAir: 0.02, restitution: 0.9, render: { fillStyle: 'transparent', strokeStyle: '#800080', // Purple color lineWidth: 2 } }; const triangle = this.scene.matter.bodies.polygon(x, y, 3, this.PURPLE_TRIANGLE_SIZE, options); triangle.rotationSpeed = Phaser.Math.FloatBetween(-0.02, 0.02); const speed = Phaser.Math.FloatBetween(0.5, 1.5); const angle = Phaser.Math.FloatBetween(0, Math.PI * 2); this.scene.matter.body.setVelocity(triangle, { x: Math.cos(angle) * speed, y: Math.sin(angle) * speed }); return triangle; } createPositiveTriangle(x, y) { const size = 30; const options = { label: 'positiveTriangle', friction: 0, frictionAir: 0, restitution: 0.9, render: { fillStyle: 'transparent', strokeStyle: '#00FF00', lineWidth: 2 } }; const triangle = this.scene.matter.bodies.polygon(x, y, 3, size, options); triangle.rotationSpeed = Phaser.Math.FloatBetween(-0.02, 0.02); const speed = Phaser.Math.FloatBetween(0, 2); const angle = Phaser.Math.FloatBetween(0, Math.PI * 2); this.scene.matter.body.setVelocity(triangle, { x: Math.cos(angle) * speed, y: Math.sin(angle) * speed }); return triangle; } createNegativeTriangle(x, y) { const size = 30; const options = { label: 'negativeTriangle', friction: 0, frictionAir: 0, restitution: 0.9, render: { fillStyle: 'transparent', strokeStyle: '#FF0000', lineWidth: 2 } }; const triangle = this.scene.matter.bodies.polygon(x, y, 3, size, options); triangle.rotationSpeed = Phaser.Math.FloatBetween(-0.02, 0.02); const speed = Phaser.Math.FloatBetween(0, 2); const angle = Phaser.Math.FloatBetween(0, Math.PI * 2); this.scene.matter.body.setVelocity(triangle, { x: Math.cos(angle) * speed, y: Math.sin(angle) * speed }); return triangle; } createInterceptorTriangle(x, y) { return new InterceptorTriangle(this.scene, x, y); } } class InterceptorTriangle { constructor(scene, x, y) { this.scene = scene; this.body = scene.matter.bodies.polygon(x, y, 3, 20, { label: 'interceptorTriangle', friction: 0, frictionAir: 0.05, restitution: 0.8, }); if (this.body) this.body.interceptor = this; else console.error('Failed to create interceptor body'); Object.assign(this, { predictTime: 1, maxForce: 0.001, maxSpeed: 0.375, rotationSpeed: 0.02 }); } update(player, interceptors) { if (!this.body || !this.scene.matter || !player || !this.body.position || !this.body.velocity) return; const pursuit = this.pursue(player); const separation = this.separate(interceptors); const steeringForce = { x: pursuit.x + separation.x, y: pursuit.y + separation.y }; // Apply steering force this.scene.matter.body.applyForce(this.body, this.body.position, steeringForce); // Limit speed const speed = Math.sqrt(this.body.velocity.x ** 2 + this.body.velocity.y ** 2); if (speed > this.maxSpeed) { const ratio = this.maxSpeed / speed; this.scene.matter.body.setVelocity(this.body, { x: this.body.velocity.x * ratio, y: this.body.velocity.y * ratio }); } // Apply fixed rotation this.scene.matter.body.rotate(this.body, this.rotationSpeed); } pursue(player) { const futureX = player.position.x + player.velocity.x * this.predictTime; const futureY = player.position.y + player.velocity.y * this.predictTime; return this.seek({ x: futureX, y: futureY }); } seek(target) { const desiredVelocity = { x: target.x - this.body.position.x, y: target.y - this.body.position.y }; const mag = Math.sqrt(desiredVelocity.x ** 2 + desiredVelocity.y ** 2); if (mag > 0) { desiredVelocity.x = (desiredVelocity.x / mag) * this.maxSpeed; desiredVelocity.y = (desiredVelocity.y / mag) * this.maxSpeed; } return { x: (desiredVelocity.x - this.body.velocity.x) * this.maxForce, y: (desiredVelocity.y - this.body.velocity.y) * this.maxForce }; } separate(interceptors) { if (!this.body || !this.body.position || !this.body.velocity) { return { x: 0, y: 0 }; // Return zero vector if this interceptor is invalid } const desiredSeparation = 50; let steer = { x: 0, y: 0 }; let count = 0; for (let other of interceptors) { if (other !== this && other.body && other.body.position) { const distance = Phaser.Math.Distance.Between( this.body.position.x, this.body.position.y, other.body.position.x, other.body.position.y ); if (distance < desiredSeparation && distance > 0) { let diff = { x: this.body.position.x - other.body.position.x, y: this.body.position.y - other.body.position.y }; const mag = Math.sqrt(diff.x ** 2 + diff.y ** 2); if (mag > 0) { diff.x /= mag; diff.y /= mag; diff.x /= distance; diff.y /= distance; steer.x += diff.x; steer.y += diff.y; count++; } } } } if (count > 0) { steer.x /= count; steer.y /= count; const mag = Math.sqrt(steer.x ** 2 + steer.y ** 2); if (mag > 0) { steer.x = (steer.x / mag) * this.maxSpeed; steer.y = (steer.y / mag) * this.maxSpeed; } steer.x = (steer.x - this.body.velocity.x) * this.maxForce; steer.y = (steer.y - this.body.velocity.y) * this.maxForce; } return steer; } } // Remove the duplicate Background class declaration // Remove the duplicate PlayerFollowingBackground class declaration // Remove the duplicate HeaviestShapeFollowingBackground class declaration // Remove the duplicate TriangleBackground class declaration class GameScene extends Phaser.Scene { static isRestart = false; constructor() { super('GameScene'); this.initializeProperties(); } init(data) { this.initializeProperties(); if (data && data.reset) { GameScene.isRestart = true; if (data.playerX && data.playerY) { this.lastPlayerPosition = { x: data.playerX, y: data.playerY }; } if (data.particles) { this.deathParticles = data.particles; } } } initializeProperties() { Object.assign(this, { particlePool: null, interceptors: [], MAX_INTERCEPTORS: 2, shapes: [], starPool: [], particles: [], DASH_THRESHOLD: 100, DASH_TIME_THRESHOLD: 300, lastCollidedShape: null, lastCollisionTime: 0, COLLISION_VALID_TIME: 500, shapeFactory: null, debugGraphics: null, negativeSquares: [], strikes: 0, MAX_STRIKES: 3, nextNegativeSquareAt: 150, consumed: 0, enemiesRemoved: 0, lives: 3, currentEnergy: 100, currentStamina: 100, currentPlayerSize: 30, comboCount: 0, comboTimer: 0 }); } initializeProperties() { Object.assign(this, { purpleTriangle: null, purpleTriangleSpawned: false, PURPLE_TRIANGLE_THRESHOLD: 500, comboCount: 0, comboTimer: 0, COMBO_TIMEOUT: 3000, STARVATION_TIME: 8000, // 8 seconds until starvation strike lastShapeConsumedTime: 0, comboText: null, negativeSquares: [], staticBackground: null, followingBackground: null, heaviestShapeBackground: null, triangleBackground: null, shapes: [], shapeGraphics: null, player: null, playerGraphics: null, MIN_SHAPES: 15, MAX_SHAPES: 15, MAX_VELOCITY: 6, // Reduced max velocity PLAYER_ACCELERATION: 0.00015, // Reduced acceleration PLAYER_ROTATION_SPEED: 0.015, SPACE_DRAG: 0.95, // Reduced drag for smoother movement DRIFT_FORCE: 0.00005, driftAngle: 0, lastCollisionTime: 0, COLLISION_WINDOW: 500, MAX_ENERGY: 100, currentEnergy: 100, ENERGY_DEPLETION_RATE: 25, ENERGY_REGENERATION_RATE: 4.662, energyBar: null, INITIAL_PLAYER_SIZE: 30, currentPlayerSize: 30, MIN_PLAYER_SIZE: 30 * 0.7225, flashGraphics: null, lives: 3, MAX_LIVES: 3, livesText: null, particles: [], consumed: 0, consumedText: null, enemiesRemoved: 0, enemiesRemovedText: null, negativeTriangles: [], NEGATIVE_TRIANGLE_SPAWN_THRESHOLD: 4, NEGATIVE_TRIANGLE_SPAWN_INTERVAL: 3, PLAYER_SHRINK_FACTOR: 0.8969, PLAYER_SHRINK_LIMIT: 30 * 0.7225, DEATH_SIZE_THRESHOLD: 30 * 0.7225, positiveTriangle: null, DASH_SPEED: 15, // Reduced dash speed DASH_DURATION: 100, DASH_COOLDOWN: 145, // Significantly reduced cooldown time lastDashTime: 0, isDashing: false, MAX_STAMINA: 100, currentStamina: 100, STAMINA_DEPLETION_RATE: 30, STAMINA_REGENERATION_RATE: 5, staminaBar: null }); } init(data) { // Hard reset all properties this.initializeProperties(); // Preserve post-processing effects if specified if (data && data.preserveEffects) { // Reapply the CRT shader to the new scene this.cameras.main.setPostPipeline(CRTPostFX); } // Clear all arrays this.shapes = []; this.interceptors = []; this.negativeSquares = []; this.negativeTriangles = []; this.particles = []; // Reset spawn points this.interceptorSpawnPoints = [{ threshold: 500, spawned: false }, { threshold: 1500, spawned: false }]; // Reset spawn thresholds this.nextNegativeSquareAt = 150; // Reset counters this.consumed = 0; this.enemiesRemoved = 0; this.strikes = 0; this.lives = this.MAX_LIVES; // Reset size properties this.currentPlayerSize = this.INITIAL_PLAYER_SIZE; this.MIN_PLAYER_SIZE = this.INITIAL_PLAYER_SIZE * 0.7225; // Only preserve player position and particles if needed if (data && data.reset) { if (data.playerX && data.playerY) { this.lastPlayerPosition = { x: data.playerX, y: data.playerY }; } if (data.particles) { this.deathParticles = data.particles; } } // Reset timers this.lastShapeConsumedTime = 0; this.lastCollisionTime = 0; this.lastDashTime = 0; // Reset energy and stamina this.currentEnergy = this.MAX_ENERGY; this.currentStamina = this.MAX_STAMINA; } createEnergyBar() { this.energyBar = this.add.graphics(); this.energyBar.setDepth(1); // Ensure it's drawn above the player // Create stamina bar this.staminaBar = this.add.graphics(); this.staminaBar.setDepth(1); } updateEnergyBar() { if (this.energyBar && this.staminaBar && this.player) { // Update energy bar const energyRatio = this.currentEnergy / this.MAX_ENERGY; const innerSize = this.currentPlayerSize * 0.76 * energyRatio; // 76% of current player size at max energy this.energyBar.clear(); // Only draw the energy bar if the player is visible if (this.player?.isVisible) { this.energyBar.fillStyle(0xffff00, 0.5); // Yellow, semi-transparent // Calculate the vertices of the inner triangle const centerX = this.player.position?.x; const centerY = this.player.position?.y; const angle = this.player.angle; // Adjust the points to be centered on the player const point1 = this.rotatePoint(centerX, centerY - innerSize / 3, centerX, centerY, angle); const point2 = this.rotatePoint(centerX - innerSize / 3, centerY + innerSize / 3, centerX, centerY, angle); const point3 = this.rotatePoint(centerX + innerSize / 3, centerY + innerSize / 3, centerX, centerY, angle); // Draw the inner triangle this.energyBar.beginPath(); this.energyBar.moveTo(point1.x, point1.y); this.energyBar.lineTo(point2.x, point2.y); this.energyBar.lineTo(point3.x, point3.y); this.energyBar.closePath(); this.energyBar.fillPath(); } // Update stamina bar const staminaRatio = this.currentStamina / this.MAX_STAMINA; const barWidth = 100; const barHeight = 10; this.staminaBar.clear(); this.staminaBar.fillStyle(0x00ffff, 1); // Cyan, fully opaque this.staminaBar.fillRect(10, this.game.config.height - 20, barWidth * staminaRatio, barHeight); this.staminaBar.lineStyle(2, 0xffffff); this.staminaBar.strokeRect(10, this.game.config.height - 20, barWidth, barHeight); } } rotatePoint(x, y, cx, cy, angle) { const radians = Phaser.Math.DegToRad(angle); const cos = Math.cos(radians); const sin = Math.sin(radians); const nx = (cos * (x - cx)) + (sin * (y - cy)) + cx; const ny = (cos * (y - cy)) - (sin * (x - cx)) + cy; return { x: nx, y: ny }; } drawHitboxes() { if (!this.debugGraphics) { this.debugGraphics = this.add.graphics(); } this.debugGraphics.clear(); // Set the line style for hitboxes this.debugGraphics.lineStyle(1, 0x00ff00, 1); // Draw hitboxes for all shapes for (let shape of this.shapes) { if (shape.label !== 'player') { if (shape.circleRadius) { // For circular shapes this.debugGraphics.strokeCircle(shape.position.x, shape.position.y, shape.circleRadius); } else { // For polygonal shapes this.debugGraphics.beginPath(); this.debugGraphics.moveTo(shape.vertices[0].x, shape.vertices[0].y); for (let i = 1; i < shape.vertices.length; i++) { this.debugGraphics.lineTo(shape.vertices[i].x, shape.vertices[i].y); } this.debugGraphics.closePath(); this.debugGraphics.strokePath(); } } } // Draw player hitbox this.debugGraphics.lineStyle(1, 0xff0000, 1); // Red for player this.debugGraphics.beginPath(); this.debugGraphics.moveTo(this.player.vertices[0].x, this.player.vertices[0].y); for (let i = 1; i < this.player.vertices.length; i++) { this.debugGraphics.lineTo(this.player.vertices[i].x, this.player.vertices[i].y); } this.debugGraphics.closePath(); this.debugGraphics.strokePath(); } createDebugGraphics() { this.debugGraphics = this.add.graphics(); this.debugText = this.add.text(10, 10, '', { fontSize: '16px', fill: '#00ff00' }); this.debugText.setDepth(1000); } drawCornerCollisionAreas() { const cornerSize = 100; // Radius of the quarter-circle const color = 0xffff00; // Yellow color const alpha = 0.3; // Semi-transparent this.debugGraphics.fillStyle(color, alpha); // Top-left corner this.debugGraphics.beginPath(); this.debugGraphics.arc(cornerSize, cornerSize, cornerSize, Math.PI, Math.PI * 1.5); this.debugGraphics.lineTo(0, 0); this.debugGraphics.fillPath(); // Top-right corner this.debugGraphics.beginPath(); this.debugGraphics.arc(800 - cornerSize, cornerSize, cornerSize, Math.PI * 1.5, 0); this.debugGraphics.lineTo(800, 0); this.debugGraphics.fillPath(); // Bottom-left corner this.debugGraphics.beginPath(); this.debugGraphics.arc(cornerSize, 600 - cornerSize, cornerSize, Math.PI * 0.5, Math.PI); this.debugGraphics.lineTo(0, 600); this.debugGraphics.fillPath(); // Bottom-right corner this.debugGraphics.beginPath(); this.debugGraphics.arc(800 - cornerSize, 600 - cornerSize, cornerSize, 0, Math.PI * 0.5); this.debugGraphics.lineTo(800, 600); this.debugGraphics.fillPath(); } capVelocity(body) { if (!body || !body.velocity) return; const velocity = body.velocity; const speed = Math.sqrt(velocity.x ** 2 + velocity.y ** 2); if (speed > this.MAX_VELOCITY) { const scale = this.MAX_VELOCITY / speed; this.matter.body.setVelocity(body, { x: velocity.x * scale, y: velocity.y * scale }); } } preload() { this.load.image('star', 'https://play.rosebud.ai/assets/star-0t3D.png.png?AQiu'); this.load.image('static_bg', 'https://play.rosebud.ai/assets/star-0t3D.png.png?AQiu'); this.load.image('s.png?hnPQ', 'https://play.rosebud.ai/assets/s.png?hnPQ'); } saveGameState() { const state = { playerPosition: { x: this.player.position.x, y: this.player.position.y }, playerVelocity: { x: this.player.velocity.x, y: this.player.velocity.y }, shapes: this.shapes.map(shape => ({ position: { x: shape.position.x, y: shape.position.y }, velocity: { x: shape.velocity.x, y: shape.velocity.y }, angle: shape.angle, label: shape.label })), score: this.consumed }; } create() { this.cameras.main.setBackgroundColor('#000000'); // Create graphics objects this.shapeGraphics = this.add.graphics(); this.playerGraphics = this.add.graphics(); this.debugGraphics = this.add.graphics(); this.particleFactory = new ParticleFactory(this); this.particlePool = new ParticlePool(this.particleFactory); this.particles = []; this.shapeFactory = new ShapeFactory(this); this.comboCount = this.comboTimer = 0; GameScene.isRestart = false; this.createWalls(); // Ensure interceptor spawn logic is set up if (!Array.isArray(this.interceptorSpawnPoints)) { this.interceptorSpawnPoints = [{ threshold: 500, spawned: false }, { threshold: 1500, spawned: false }]; } // Set up negative square spawn logic if (typeof this.nextNegativeSquareAt !== 'number') { this.nextNegativeSquareAt = 150; } // Initialize consumed score if not set if (typeof this.consumed !== 'number') { this.consumed = 0; } // Initialize enemies removed counter if not set if (typeof this.enemiesRemoved !== 'number') { this.enemiesRemoved = 0; } // Initialize backgrounds this.staticBackground = new StaticBackground(this, 200, null, 'static_bg'); this.followingBackground = new PlayerFollowingBackground(this, 200, null, 0.02, 's.png?hnPQ'); this.triangleBackground = new TriangleBackground(this, 150); this.staticBackground.create(); this.followingBackground.create(); this.triangleBackground.create(); // Create initial shapes for (let i = 0; i < this.MIN_SHAPES; i++) { this.createRandomShape(); } // Ensure we have at least MIN_SHAPES while (this.shapes.filter(shape => shape.label === 'shape').length < this.MIN_SHAPES) { this.createRandomShape(); } // Create player this.createPlayer(); // Maintain shape count this.maintainShapeCount(); // Set up collision events this.matter.world.on('collisionstart', (event, bodyA, bodyB) => this.handleCollision(bodyA, bodyB)); // Set up mouse click event const removeShape = () => { const energyCost = this.lastCollidedShape && this.lastCollidedShape.label === 'positiveTriangle' ? 50 // Cost for positive triangle : this.ENERGY_DEPLETION_RATE; if (this.currentEnergy >= energyCost) { if (this.isClickWithinCollisionWindow() && this.lastCollidedShape) { const removed = this.removeShape(this.lastCollidedShape); if (removed) { this.currentEnergy -= energyCost; this.updateEnergyBar(); this.lastCollidedShape = null; } } } else { console.log('Not enough energy to remove shape'); // Optionally, provide feedback to the player about low energy } }; this.input.on('pointerdown', pointer => pointer.leftButtonDown() ? removeShape() : pointer.rightButtonDown() && this.initiateDash() ); // Remove context menu for all devices this.input.mouse.disableContextMenu(); // Create energy bar this.createEnergyBar(); // Create flash effect this.flashGraphics = this.add.graphics(); // Initialize dash this.initializeDash(); // Prevent right-click context menu this.input.mouse.disableContextMenu(); } initializeDash() { this.input.on('pointerdown', pointer => pointer.rightButtonDown() && this.initiateDash()); } initiateDash(angle) { if (this.time.now - this.lastDashTime < this.DASH_COOLDOWN) return; if (this.currentStamina < this.STAMINA_DEPLETION_RATE) return; // Check if enough stamina this.isDashing = true; this.lastDashTime = this.time.now; this.currentStamina -= this.STAMINA_DEPLETION_RATE; // Consume stamina this.updateEnergyBar(); // Update stamina bar immediately if (angle === undefined) { angle = Phaser.Math.Angle.Between( this.player.position.x, this.player.position.y, this.input.activePointer.worldX, this.input.activePointer.worldY ); } const dashVelocity = new Phaser.Math.Vector2(Math.cos(angle), Math.sin(angle)).scale(this.DASH_SPEED); this.matter.body.setVelocity(this.player, dashVelocity); this.time.delayedCall(this.DASH_DURATION, () => { this.isDashing = false; }); // Create a dash effect this.createDashEffect(angle); } createDashEffect(angle) { const dashParticles = this.add.particles(this.player.position.x, this.player.position.y, 'particle', { speed: 200, angle: Phaser.Math.RadToDeg(angle) - 180, scale: { start: 0.2, end: 0 }, blendMode: 'ADD', lifespan: 100, gravityY: 0 }); this.time.delayedCall(100, () => dashParticles.destroy()); } createWalls() { const wallThickness = 50; const wallOptions = { isStatic: true }; this.matter.add.rectangle(400, -25, 800, wallThickness, wallOptions); this.matter.add.rectangle(400, 625, 800, wallThickness, wallOptions); this.matter.add.rectangle(-25, 300, wallThickness, 600, wallOptions); this.matter.add.rectangle(825, 300, wallThickness, 600, wallOptions); } createStar() { let star; if (this.starPool && this.starPool.length > 0) { star = this.starPool.pop(); star.setActive(true); star.setVisible(true); } else { star = this.add.image(0, 0, 'star'); if (!Array.isArray(this.stars)) { this.stars = []; } this.stars.push(star); } star.x = Phaser.Math.Between(0, 800); star.y = Phaser.Math.Between(0, 600); star.setAlpha(Phaser.Math.FloatBetween(0.2, 1)); star.setScale(Phaser.Math.FloatBetween(0.1, 0.5)); star.speed = Phaser.Math.FloatBetween(0.1, 0.5); return star; } update(time, delta) { // Handle purple triangle gravitational pull if (this.purpleTriangle && this.player) { const dx = this.player.position.x - this.purpleTriangle.position.x; const dy = this.player.position.y - this.purpleTriangle.position.y; const distance = Math.sqrt(dx * dx + dy * dy); if (distance < this.purpleTriangle.gravitationalRadius) { const force = this.purpleTriangle.gravitationalForce * (1 - distance / this.purpleTriangle.gravitationalRadius); const angle = Math.atan2(dy, dx); // Apply gravitational pull this.matter.body.applyForce(this.player, this.player.position, { x: -Math.cos(angle) * force, y: -Math.sin(angle) * force }); // Create visual effect for gravitational pull if (Math.random() < 0.1) { // Occasional particle effect const particle = this.add.graphics(); particle.lineStyle(1, 0x800080, 0.5); particle.lineBetween( this.player.position.x, this.player.position.y, this.purpleTriangle.position.x, this.purpleTriangle.position.y ); this.tweens.add({ targets: particle, alpha: 0, duration: 200, onComplete: () => particle.destroy() }); } } } // Check for starvation if (time - this.lastShapeConsumedTime > this.STARVATION_TIME) { this.handleStarvation(); this.lastShapeConsumedTime = time; // Reset timer after handling starvation } // Calculate average shape position const avgPos = this.calculateAverageShapePosition(); // Update backgrounds this.staticBackground?.update(avgPos); this.followingBackground?.update(this.player?.position, this.player?.velocity); this.triangleBackground?.update(this.player?.position, time, delta); // Update shapes this.updateShapes(delta); // Update player this.updatePlayer(time, delta); // Update particles if (Array.isArray(this.particles)) { this.updateParticles(delta); } else { console.warn('this.particles is not an array'); this.particles = []; } // Energy regeneration this.currentEnergy = Math.min(this.MAX_ENERGY, this.currentEnergy + this.ENERGY_REGENERATION_RATE * delta / 1000); // Stamina regeneration this.currentStamina = Math.min(this.MAX_STAMINA, this.currentStamina + this.STAMINA_REGENERATION_RATE * delta / 1000); this.updateEnergyBar(); // Maintain shape count this.maintainShapeCount(); // Handle combo timer if (this.comboCount > 0 && time > this.comboTimer) { this.comboCount = 0; if (this.comboGlow) { this.comboGlow.clear(); } } // Update Interceptor triangles if (this.player && Array.isArray(this.interceptors)) { this.interceptors = this.interceptors.filter(interceptor => interceptor && interceptor.body && this.matter.world.has(interceptor.body) ); this.interceptors.forEach(interceptor => { if (typeof interceptor.update === 'function') { interceptor.update(this.player, this.interceptors); } }); } else { console.warn('this.interceptors is not an array or player is not defined'); this.interceptors = []; // Initialize if undefined } // Spawn Interceptors if needed if (this.player && typeof this.spawnInterceptors === 'function') { this.spawnInterceptors(); } else if (typeof this.spawnInterceptors !== 'function') { console.error('spawnInterceptors is not a function'); } // Check if game is over if (!this.player) { return; // Exit update loop if player is dead } // Spawn NegativeSquare when player reaches points threshold this.manageNegativeSquares(); // Check if we should spawn purple triangle if (this.consumed >= this.PURPLE_TRIANGLE_THRESHOLD && !this.purpleTriangleSpawned) { this.createPurpleTriangle(); } } spawnInterceptors() { if (!this.player || !this.matter || !this.matter.world) { console.warn('Player, matter, or world not available for spawning interceptors'); return; } if (!Array.isArray(this.interceptors)) { this.interceptors = []; } // Ensure all interceptors are valid this.interceptors = this.interceptors.filter(interceptor => { if (!interceptor || !interceptor.body) { console.warn('Invalid interceptor detected and removed'); return false; } return true; }); // Additional check to remove any interceptors not in the world this.interceptors = this.interceptors.filter(interceptor => { if (interceptor && interceptor.body && !this.matter.world.has(interceptor.body)) { console.warn('Interceptor not in world detected and removed'); return false; } return true; }); // Ensure this.matter and this.matter.world exist if (!this.matter || !this.matter.world) { console.warn('Matter physics not available'); return; } const firstInterceptorThreshold = 500; const secondInterceptorThreshold = 1500; const additionalInterceptorInterval = 1000; // Initialize interceptorSpawnPoints if it doesn't exist if (!Array.isArray(this.interceptorSpawnPoints)) { this.interceptorSpawnPoints = [{ threshold: firstInterceptorThreshold, spawned: false }, { threshold: secondInterceptorThreshold, spawned: false }]; } // Ensure this.shapes is an array if (!Array.isArray(this.shapes)) { this.shapes = []; } // Check if this.consumed is defined, if not initialize it if (typeof this.consumed !== 'number') { this.consumed = 0; } // Only proceed if all necessary properties are defined if (!this.interceptorSpawnPoints || !this.shapes || typeof this.consumed !== 'number') { return; } // Check and update spawn points while (this.consumed >= this.interceptorSpawnPoints[this.interceptorSpawnPoints.length - 1].threshold + additionalInterceptorInterval) { const newThreshold = this.interceptorSpawnPoints[this.interceptorSpawnPoints.length - 1].threshold + additionalInterceptorInterval; this.interceptorSpawnPoints.push({ threshold: newThreshold, spawned: false }); } // Spawn interceptors based on points and available slots for (let i = 0; i < this.interceptorSpawnPoints.length && this.interceptors.filter(Boolean).length < 2; i++) { const spawnPoint = this.interceptorSpawnPoints[i]; if (this.consumed >= spawnPoint.threshold && !spawnPoint.spawned) { this.spawnInterceptor(i); spawnPoint.spawned = true; } } } removeInterceptor(interceptorBody) { if (!interceptorBody || !this.matter || !this.matter.world) { console.warn('Invalid interceptor or matter world not available'); return; } const index = this.interceptors.findIndex(i => i && i.body === interceptorBody); if (index !== -1) { const interceptor = this.interceptors[index]; if (interceptor && interceptor.body) { try { this.matter.world.remove(interceptor.body); this.interceptors[index] = null; if (this.interceptorSpawnPoints && this.interceptorSpawnPoints[index]) { this.interceptorSpawnPoints[index].spawned = false; } this.removeShape(interceptorBody); } catch (error) { console.error('Error removing interceptor:', error); } } } // Clean up the interceptors array this.interceptors = this.interceptors.filter(i => i !== null); } spawnInterceptor(index) { const [x, y] = this.getEdgeSpawnPosition(); const interceptor = this.shapeFactory.createInterceptorTriangle(x, y); this.matter.world.add(interceptor.body); this.interceptors[index] = interceptor; this.shapes.push(interceptor.body); } // updateComboVisuals method removed updateParticles(delta) { if (!Array.isArray(this.particles)) { console.warn('Particles array is not initialized. Initializing as empty array.'); this.particles = []; return; } const screenWidth = this.cameras.main.width; const screenHeight = this.cameras.main.height; const bounceCoefficient = 0.9; // Coefficient of restitution for (let i = this.particles.length - 1; i >= 0; i--) { const particle = this.particles[i]; if (!particle) { console.warn(`Invalid particle at index ${i}. Removing from array.`); this.particles.splice(i, 1); continue; } // Update lifetime particle.lifetime -= delta; if (particle.lifetime <= 0) { // Remove the particle if its lifetime has expired this.particlePool.release(particle); this.particles.splice(i, 1); continue; } // Calculate new alpha based on remaining lifetime particle.alpha = 0.541875 * (particle.lifetime / particle.initialLifetime); // Update position particle.x += particle.speedX; particle.y += particle.speedY; // Check for collisions with other particles for (let j = i - 1; j >= 0; j--) { const otherParticle = this.particles[j]; const dx = otherParticle.x - particle.x; const dy = otherParticle.y - particle.y; const distance = Math.sqrt(dx * dx + dy * dy); const minDistance = (particle.size + otherParticle.size) / 2; if (distance < minDistance) { // Collision detected, calculate new velocities const angle = Math.atan2(dy, dx); const sin = Math.sin(angle); const cos = Math.cos(angle); // Rotate particle velocities const vx1 = particle.speedX * cos + particle.speedY * sin; const vy1 = particle.speedY * cos - particle.speedX * sin; const vx2 = otherParticle.speedX * cos + otherParticle.speedY * sin; const vy2 = otherParticle.speedY * cos - otherParticle.speedX * sin; // Elastic collision const newVx1 = ((vx1 * (particle.size - otherParticle.size) + (2 * otherParticle.size * vx2)) / (particle.size + otherParticle.size)) * bounceCoefficient; const newVx2 = ((vx2 * (otherParticle.size - particle.size) + (2 * particle.size * vx1)) / (particle.size + otherParticle.size)) * bounceCoefficient; // Rotate velocities back particle.speedX = newVx1 * cos - vy1 * sin; particle.speedY = vy1 * cos + newVx1 * sin; otherParticle.speedX = newVx2 * cos - vy2 * sin; otherParticle.speedY = vy2 * cos + newVx2 * sin; // Move particles apart to prevent sticking const overlap = minDistance - distance; particle.x -= overlap * cos / 2; particle.y -= overlap * sin / 2; otherParticle.x += overlap * cos / 2; otherParticle.y += overlap * sin / 2; } } // Check for screen boundaries if (particle.x - particle.size / 2 < 0) { particle.x = particle.size / 2; particle.speedX *= -bounceCoefficient; } else if (particle.x + particle.size / 2 > screenWidth) { particle.x = screenWidth - particle.size / 2; particle.speedX *= -bounceCoefficient; } if (particle.y - particle.size / 2 < 0) { particle.y = particle.size / 2; particle.speedY *= -bounceCoefficient; } else if (particle.y + particle.size / 2 > screenHeight) { particle.y = screenHeight - particle.size / 2; particle.speedY *= -bounceCoefficient; } // Render particle particle.clear(); particle.lineStyle(1, 0xFFFFFF, 0.541875); if (particle.shape === 'circle') { particle.strokeCircle(0, 0, particle.size / 2); } else if (particle.vertices && Array.isArray(particle.vertices)) { particle.beginPath(); particle.vertices.forEach((vertex, index) => { const x = vertex.x * (particle.size / 30); const y = vertex.y * (particle.size / 30); if (index === 0) particle.moveTo(x, y); else particle.lineTo(x, y); }); particle.closePath(); particle.strokePath(); } else { // Default triangle shape if vertices are not defined particle.beginPath(); particle.moveTo(0, -particle.size / 2); particle.lineTo(-particle.size / 2, particle.size / 2); particle.lineTo(particle.size / 2, particle.size / 2); particle.closePath(); particle.strokePath(); } particle.setPosition(particle.x, particle.y); } } maintainShapeCount() { if (!Array.isArray(this.shapes)) { this.shapes = []; return; } const whiteShapeCount = this.shapes.filter(shape => shape && shape.label === 'shape' && !shape.isOrange && !shape.isRed).length; const MIN_WHITE_SHAPES = 5; if (whiteShapeCount < MIN_WHITE_SHAPES) { const shapesToAdd = MIN_WHITE_SHAPES - whiteShapeCount; for (let i = 0; i < shapesToAdd; i++) { this.createRandomShape(); } } const totalShapeCount = this.shapes.filter(shape => shape && shape.label === 'shape').length; if (totalShapeCount > this.MAX_SHAPES) { const shapesToRemove = totalShapeCount - this.MAX_SHAPES; const removableShapes = this.shapes.filter(shape => shape && shape.label === 'shape' && (shape.isOrange || shape.isRed)); for (let i = 0; i < shapesToRemove && i < removableShapes.length; i++) { this.removeShape(removableShapes[i]); } } // Spawn negative triangles based on enemies removed if (this.enemiesRemoved >= this.NEGATIVE_TRIANGLE_SPAWN_THRESHOLD) { const negativeTrianglesToSpawn = Math.floor((this.enemiesRemoved - this.NEGATIVE_TRIANGLE_SPAWN_THRESHOLD) / this.NEGATIVE_TRIANGLE_SPAWN_INTERVAL) + 1 - this.negativeTriangles.length; for (let i = 0; i < negativeTrianglesToSpawn; i++) { this.createNegativeTriangle(); } } } updateShapes(delta) { this.shapeGraphics.clear(); this.shapeGraphics.lineStyle(1, 0xFFFF00, 1); // Set line style to yellow with thickness 1 and alpha 1 for (let i = this.shapes.length - 1; i >= 0; i--) { const body = this.shapes[i]; if (body && body.position) { this.checkBounds(body); if (body.label !== 'player') { this.renderShape(body); this.applyCornerRepulsion(body); // Apply corner repulsion to shapes // Apply rotation if (body.rotationSpeed) { this.matter.body.rotate(body, body.rotationSpeed); } } } else { this.shapes.splice(i, 1); } } // Remove debug information update } renderShape(body) { if (body.label === 'negativeTriangle') { this.shapeGraphics.lineStyle(2, 0xFF0000, 1); // Red, thickness 2 } else if (body.label === 'positiveTriangle') { this.shapeGraphics.lineStyle(2, 0x00FF00, 1); // Green, thickness 2 } else if (body.label === 'player') { this.shapeGraphics.lineStyle(1, 0xFFFF00, 1); // Yellow, thickness 1 for player } else if (body.label === 'stalkerTriangle') { this.shapeGraphics.lineStyle(2, 0xFFFFFF, 1); // White, thickness 2 for stalker triangles } else if (body.label === 'interceptorTriangle') { this.shapeGraphics.lineStyle(2, 0xFFA500, 1); // Orange, thickness 2 for interceptor triangles } else if (body.label === 'purpleTriangle') { this.shapeGraphics.lineStyle(2, 0x800080, 1); // Purple, thickness 2 for purple triangle } else if (body.label === 'boss') { this.shapeGraphics.lineStyle(3, 0xFF00FF, 1); // Magenta, thickness 3 for boss } else if (body.label === 'negativeSquare') { this.shapeGraphics.lineStyle(2, 0xFFA500, 1); // Orange, thickness 2 for negative square } else if (body.isOrange) { this.shapeGraphics.lineStyle(1, 0xFFA500, 1); // Orange, thickness 1 for orange shapes } else if (body.isRed) { this.shapeGraphics.lineStyle(1, 0xFF0000, 1); // Red, thickness 1 for red shapes } else { this.shapeGraphics.lineStyle(1, 0xFFFFFF, 1); // White, thickness 1 for other shapes } if (body.circleRadius) { this.shapeGraphics.strokeCircle(body.position.x, body.position.y, body.circleRadius); } else { this.shapeGraphics.beginPath(); this.shapeGraphics.moveTo(body.vertices[0].x, body.vertices[0].y); for (let i = 1; i < body.vertices.length; i++) { this.shapeGraphics.lineTo(body.vertices[i].x, body.vertices[i].y); } this.shapeGraphics.closePath(); this.shapeGraphics.strokePath(); } } checkBounds(body) { if (!body || !body.position || !body.velocity) return; const x = body.position.x; const y = body.position.y; const vx = body.velocity.x; const vy = body.velocity.y; const radius = Math.max(body.circleRadius || 0, body.bounds.max.x - body.bounds.min.x, body.bounds.max.y - body.bounds.min.y) / 2; if (x - radius < 0 && vx < 0) { this.matter.body.setVelocity(body, { x: -vx, y: vy }); } if (x + radius > 800 && vx > 0) { this.matter.body.setVelocity(body, { x: -vx, y: vy }); } if (y - radius < 0 && vy < 0) { this.matter.body.setVelocity(body, { x: vx, y: -vy }); } if (y + radius > 600 && vy > 0) { this.matter.body.setVelocity(body, { x: vx, y: -vy }); } } applyCornerRepulsion(body) { const cornerSize = 100; // Size of the corner area const maxForce = 0.0001; // Maximum repulsion force const x = body.position.x; const y = body.position.y; let forceX = 0; let forceY = 0; // Check top-left corner if (x < cornerSize && y < cornerSize) { forceX += maxForce * (1 - x / cornerSize); forceY += maxForce * (1 - y / cornerSize); } // Check top-right corner else if (x > 800 - cornerSize && y < cornerSize) { forceX -= maxForce * (1 - (800 - x) / cornerSize); forceY += maxForce * (1 - y / cornerSize); } // Check bottom-left corner else if (x < cornerSize && y > 600 - cornerSize) { forceX += maxForce * (1 - x / cornerSize); forceY -= maxForce * (1 - (600 - y) / cornerSize); } // Check bottom-right corner else if (x > 800 - cornerSize && y > 600 - cornerSize) { forceX -= maxForce * (1 - (800 - x) / cornerSize); forceY -= maxForce * (1 - (600 - y) / cornerSize); } if (forceX !== 0 || forceY !== 0) { this.matter.body.applyForce(body, body.position, { x: forceX, y: forceY }); } } handleCollision(bodyA, bodyB) { if ((bodyA?.label === 'player' || bodyB?.label === 'player') && bodyA && bodyB) { // Handle purple triangle collision if ((bodyA?.label === 'purpleTriangle' || bodyB?.label === 'purpleTriangle')) { this.strikes++; this.createFlashEffect(); if (this.strikes >= this.MAX_STRIKES) { this.gameOver(); } else { this.lives--; this.updateLivesDisplay(); } return; } const player = bodyA?.label === 'player' ? bodyA : bodyB; const shape = bodyA?.label === 'player' ? bodyB : bodyA; // Use optional chaining for position check if (!player?.position || !shape?.position) return; // Handle collision with Interceptor triangle if (shape && shape.label === 'interceptorTriangle') { this.lives--; this.updateLivesDisplay(); this.createFlashEffect(); if (this.lives <= 0) { this.gameOver(); } else { // Remove the Interceptor triangle this.removeInterceptor(shape); } return; // Exit the method after handling Interceptor collision } // Handle collision between negative square and negative triangle if ((bodyA.label === 'negativeSquare' && bodyB.label === 'negativeTriangle') || (bodyA.label === 'negativeTriangle' && bodyB.label === 'negativeSquare')) { const negativeSquare = bodyA.label === 'negativeSquare' ? bodyA : bodyB; this.removeNegativeSquare(negativeSquare); return; // Exit the method after handling this collision } // Add a small repulsion force const angle = Phaser.Math.Angle.Between(player.position.x, player.position.y, shape.position.x, shape.position.y); const baseRepulsion = 0.0005; const playerMass = player.mass; const shapeMass = shape.mass; const totalMass = playerMass + shapeMass; const playerRepulsion = baseRepulsion * (shapeMass / totalMass); const shapeRepulsion = baseRepulsion * (playerMass / totalMass); const playerForce = new Phaser.Math.Vector2(Math.cos(angle), Math.sin(angle)).scale(-playerRepulsion); const shapeForce = new Phaser.Math.Vector2(Math.cos(angle), Math.sin(angle)).scale(shapeRepulsion); this.matter.body.applyForce(player, player.position, playerForce); this.matter.body.applyForce(shape, shape.position, shapeForce); // Update last collision time and shape this.lastCollisionTime = this.time.now; this.lastCollidedShape = shape; // Handle collision with negative triangle if (shape.label === 'negativeTriangle') { this.currentPlayerSize *= this.PLAYER_SHRINK_FACTOR; this.currentPlayerSize = Math.max(this.currentPlayerSize, this.PLAYER_SHRINK_LIMIT); if (this.currentPlayerSize <= this.DEATH_SIZE_THRESHOLD) { this.gameOver(); } else { const scale = this.currentPlayerSize / this.INITIAL_PLAYER_SIZE; this.matter.body.scale(player, scale, scale); this.createFlashEffect(); this.lives--; this.updateLivesDisplay(); if (this.lives <= 0) { this.gameOver(); } } } // Handle collision with orange shapes or negative square if (shape.isOrange || shape.label === 'negativeSquare') { this.handlePlayerColoredShapeCollision(player, shape); this.createPlayerGlitchEffect(); } } else if ((bodyA.label === 'positiveTriangle' && bodyB.label === 'negativeTriangle') || (bodyA.label === 'negativeTriangle' && bodyB.label === 'positiveTriangle')) { // Handle collision between positive and negative triangles const positiveTriangle = bodyA.label === 'positiveTriangle' ? bodyA : bodyB; this.removeShape(positiveTriangle, false); // Pass false to indicate it's not player-initiated } else if ((bodyA.label === 'interceptorTriangle' && bodyB.label === 'negativeTriangle') || (bodyA.label === 'negativeTriangle' && bodyB.label === 'interceptorTriangle')) { // Handle collision between interceptor and negative triangle const interceptor = bodyA.label === 'interceptorTriangle' ? bodyA : bodyB; this.removeInterceptor(interceptor); } else if ((bodyA.label === 'negativeSquare' && bodyB.label === 'negativeTriangle') || (bodyA.label === 'negativeTriangle' && bodyB.label === 'negativeSquare')) { // Handle collision between negative square and negative triangle const negativeSquare = bodyA.label === 'negativeSquare' ? bodyA : bodyB; this.removeNegativeSquare(negativeSquare); } else if (bodyA.label === 'negativeSquare' || bodyB.label === 'negativeSquare') { const negativeSquare = bodyA.label === 'negativeSquare' ? bodyA : bodyB; const otherShape = bodyA.label === 'negativeSquare' ? bodyB : bodyA; this.handleNegativeSquareCollision(negativeSquare, otherShape); } else if (bodyA.label === 'negativeTriangle' || bodyB.label === 'negativeTriangle') { const negativeTriangle = bodyA.label === 'negativeTriangle' ? bodyA : bodyB; const otherShape = bodyA.label === 'negativeTriangle' ? bodyB : bodyA; this.handleNegativeTriangleCollision(negativeTriangle, otherShape); } } removeInterceptor(interceptorBody) { if (!Array.isArray(this.interceptors)) { console.warn('this.interceptors is not an array'); return; } const index = this.interceptors.findIndex(i => i?.body === interceptorBody); if (index !== -1) { const interceptor = this.interceptors[index]; if (interceptor && interceptor.body) { this.interceptors.splice(index, 1); if (typeof this.removeShape === 'function') { this.removeShape(interceptor.body); } else { console.warn('this.removeShape is not a function'); } } } } createRandomShape() { const spawnPattern = Phaser.Math.Between(0, 2); let x, y; switch (spawnPattern) { case 0: [x, y] = this.getEdgeSpawnPosition(); break; case 1: [x, y] = this.getQuadrantSpawnPosition(); break; case 2: [x, y] = this.getSpiralSpawnPosition(); break; } const body = this.shapeFactory.createRandomShape(x, y); this.matter.world.add(body); this.shapes.push(body); } createPlayer = () => { const triangleSize = 30; const [startX, startY] = this.lastPlayerPosition ? [this.lastPlayerPosition.x, this.lastPlayerPosition.y] : [400, 300]; const h = triangleSize * Math.sqrt(3) / 2; this.player = this.matter.bodies.polygon(startX, startY, 3, triangleSize, { label: 'player', friction: 0.005, frictionAir: 0.05, restitution: 0.3 }); this.matter.world.add(this.player); this.shapes.push(this.player); Object.assign(this.player, { isInvulnerable: false, isVisible: false }); this.detectionPoints = [{ x: 0, y: -h * (2 / 3) }, { x: -triangleSize / 2, y: h * (1 / 3) }, { x: triangleSize / 2, y: h * (1 / 3) }]; this.deathParticles && this.deathParticles.length > 0 ? this.animateParticlesToPlayer() : this.player.isVisible = true; } areAllParticlesRegenerated() { return this.deathParticles.every(particle => particle.x === this.player.position.x && particle.y === this.player.position.y ); } createPlayerGlitchEffect() { const glitchGraphics = this.add.graphics(); const bounds = this.player.bounds; const width = bounds.max.x - bounds.min.x; const height = bounds.max.y - bounds.min.y; const centerX = (bounds.min.x + bounds.max.x) / 2; const centerY = (bounds.min.y + bounds.max.y) / 2; const glitchAnimation = this.tweens.createTimeline(); for (let i = 0; i < 8; i++) { glitchAnimation.add({ targets: glitchGraphics, alpha: { from: 0, to: 1 }, duration: 40, onStart: () => { glitchGraphics.clear(); glitchGraphics.lineStyle(2, 0xFFA500, 1); // Orange color for glitch effect for (let j = 0; j < 4; j++) { const x = Phaser.Math.Between(bounds.min.x, bounds.max.x); const y = Phaser.Math.Between(bounds.min.y, bounds.max.y); const triangleSize = Math.min(width, height) / 4; // Draw a triangle instead of a rectangle glitchGraphics.beginPath(); glitchGraphics.moveTo(x, y - triangleSize / 2); glitchGraphics.lineTo(x - triangleSize / 2, y + triangleSize / 2); glitchGraphics.lineTo(x + triangleSize / 2, y + triangleSize / 2); glitchGraphics.closePath(); glitchGraphics.strokePath(); // Create and emit a triangle particle const particle = this.add.graphics(); particle.lineStyle(1, 0xFFA500, 1); particle.beginPath(); particle.moveTo(0, -5); particle.lineTo(-5, 5); particle.lineTo(5, 5); particle.closePath(); particle.strokePath(); const particleContainer = this.add.container(x, y, [particle]); this.tweens.add({ targets: particleContainer, x: centerX, y: centerY, alpha: 0, scale: 0, duration: 150, onComplete: () => particleContainer.destroy() }); } } }); glitchAnimation.add({ targets: glitchGraphics, alpha: { from: 1, to: 0 }, duration: 40 }); } glitchAnimation.play(); this.time.delayedCall(825, () => { glitchGraphics.destroy(); }); } animateParticlesToPlayer() { const particleGraphics = this.add.graphics(); const duration = 1000; // Animation duration in milliseconds // Start the glitch effect at the beginning of the animation this.createPlayerGlitchEffect(); let completedAnimations = 0; const totalParticles = this.deathParticles.length; this.deathParticles.forEach(particle => { this.tweens.add({ targets: particle, x: this.player.position.x, y: this.player.position.y, duration: duration, ease: 'Quad.easeIn', onUpdate: () => { particleGraphics.clear(); this.deathParticles.forEach(p => { particleGraphics.fillStyle(p.color, p.alpha); if (p.shape === 'circle') { particleGraphics.fillCircle(p.x, p.y, p.size / 2); } else { particleGraphics.fillTriangle( p.x, p.y - p.size / 2, p.x - p.size / 2, p.y + p.size / 2, p.x + p.size / 2, p.y + p.size / 2 ); } }); }, onComplete: () => { completedAnimations++; if (completedAnimations === totalParticles) { particleGraphics.clear(); this.deathParticles = []; this.player.isVisible = true; // Make player visible after all particles have converged this.createPlayerGlitchEffect(); // Second glitch effect after particles converge } } }); }); } updateLivesDisplay() { if (this.lives > 0) { this.currentPlayerSize *= this.PLAYER_SHRINK_FACTOR; // Shrink by factor this.currentPlayerSize = Math.max(this.currentPlayerSize, this.PLAYER_SHRINK_LIMIT); // Update player size const scale = this.currentPlayerSize / this.INITIAL_PLAYER_SIZE; this.matter.body.scale(this.player, scale, scale); // Create positive triangle when lives reach 1 if (this.lives === 1 && !this.positiveTriangle) { this.createPositiveTriangle(); } } else { // Game Over condition this.gameOver(); } } gameOver() { // Create final flash effect this.createFlashEffect(); // Clear all tweens and timers this.tweens.killAll(); this.time.removeAllEvents(); // Transition to GameOverScene after a short delay this.time.delayedCall(100, () => { const gameOverData = { consumed: this.consumed, playerX: this.player ? this.player.position.x : 0, playerY: this.player ? this.player.position.y : 0, diedToBoss: Array.isArray(this.bosses) && this.bosses.length > 0 }; this.scene.start('GameOverScene', gameOverData); }); } createFlashEffect = () => { this.flashGraphics.clear().fillStyle(0xFFFFFF, 1).fillRect(0, 0, this.cameras.main.width, this.cameras.main.height).setAlpha(1); this.tweens.add({ targets: this.flashGraphics, alpha: 0, duration: 50, ease: 'Linear', onComplete: () => this.flashGraphics.clear() }); } restartGame() { this.scene.restart(); } updatePlayer = (time, delta) => { const p = this.player; if (!p) return; const m = this.matter.body; m.setAngle(p, p.angle + this.PLAYER_ROTATION_SPEED); if (!this.isDashing) { const ptr = this.input.activePointer; const ma = Phaser.Math.Angle.Between(p.position?.x, p.position?.y, ptr.worldX, ptr.worldY); m.applyForce(p, p.position, new Phaser.Math.Vector2(Math.cos(ma), Math.sin(ma)).scale(this.PLAYER_ACCELERATION)); } const [cos, sin] = [Math.cos(p.angle), Math.sin(p.angle)], s = this.currentPlayerSize; this.detectionPoints = [{ x: 0, y: -s * (2 / 3) }, { x: -s / 2, y: s * (1 / 3) }, { x: s / 2, y: s * (1 / 3) }] .map(pt => ({ ...pt, worldX: p.position.x + pt.x * cos - pt.y * sin, worldY: p.position.y + pt.x * sin + pt.y * cos })); m.setVelocity(p, { x: p.velocity.x * 0.98, // Reduced velocity dampening y: p.velocity.y * 0.98 }); const spd = Math.sqrt(p.velocity.x ** 2 + p.velocity.y ** 2); if (spd > this.MAX_VELOCITY && !this.isDashing) { const scl = this.MAX_VELOCITY / spd; m.setVelocity(p, { x: p.velocity.x * scl, y: p.velocity.y * scl }); } this.checkBounds(p); this.playerGraphics.clear(); if (p.isVisible) { this.playerGraphics.lineStyle(1, this.isDashing ? 0x00FFFF : 0xFFFF00, 1) .beginPath().moveTo(p.vertices[0].x, p.vertices[0].y); p.vertices.slice(1).forEach(v => this.playerGraphics.lineTo(v.x, v.y)); this.playerGraphics.closePath().strokePath(); } this.updateEnergyBar(); } calculateAverageShapePosition() { if (this.shapes.length === 0) return { x: 400, y: 300 }; // Default to center if no shapes let totalX = 0, totalY = 0; for (let shape of this.shapes) { totalX += shape.position.x; totalY += shape.position.y; } return { x: totalX / this.shapes.length, y: totalY / this.shapes.length }; } isClickWithinCollisionWindow() { return this.time.now - this.lastCollisionTime <= this.COLLISION_WINDOW; } removeShape(shape, isPlayerInitiated = true) { const index = this.shapes.indexOf(shape); if (index > -1) { // Reset starvation timer when shape is consumed this.lastShapeConsumedTime = this.time.now; // Check if it's a positive triangle and if there's enough energy if (shape.label === 'positiveTriangle') { const energyCost = 50; // Define an energy cost for removing positive triangle if (this.currentEnergy < energyCost) { console.log('Not enough energy to remove positive triangle'); return; // Exit the method if not enough energy } this.currentEnergy -= energyCost; // Deduct energy } this.shapes.splice(index, 1); this.matter.world.remove(shape); // Calculate score based on shape characteristics let score = this.calculateShapeScore(shape); // Add 1000 points for removing a negative triangle (red shape) if (shape.label === 'negativeTriangle') { score += 1000; } // Increase energy proportional to the score const energyGain = Math.min(35, score / 2); this.currentEnergy = Math.min(this.MAX_ENERGY, this.currentEnergy + energyGain); // Increase stamina const staminaGain = Math.min(20, score / 3); // Adjust this value as needed this.currentStamina = Math.min(this.MAX_STAMINA, this.currentStamina + staminaGain); this.updateEnergyBar(); this.createFlashEffect(); // Transform the shape into particles this.transformShape(shape); // Reset the shape consumption timer this.lastShapeConsumedTime = this.time.now; // Handle positive triangle removal if (shape.label === 'positiveTriangle') { if (isPlayerInitiated) { this.handlePositiveTriangleRemoval(); } // Reset positiveTriangle reference this.positiveTriangle = null; // Create a new positive triangle if strikes are still at 2 if (this.strikes === 2) { this.createPositiveTriangle(); } } else { // Always create a new shape when one is removed if (shape.label === 'shape') { this.createRandomShape(); } else if (shape.label === 'negativeTriangle') { const negativeTriangleIndex = this.negativeTriangles.indexOf(shape); if (negativeTriangleIndex > -1) { this.negativeTriangles.splice(negativeTriangleIndex, 1); } } // Update combo this.comboCount++; this.comboTimer = this.time.now + this.COMBO_TIMEOUT; // Set the timer to future // Calculate score with combo multiplier const comboMultiplier = 1 + (this.comboCount - 1) * 0.1; // 10% increase per combo level score *= comboMultiplier; // Update consumed this.consumed += Math.round(score); // Increment and update enemies removed counter only if in debug mode this.enemiesRemoved++; if (this.enemiesRemovedText) { this.enemiesRemovedText.setText(`Enemies Removed: ${this.enemiesRemoved}`); } // Check if we need to spawn a positive triangle if (this.strikes === 2 && !this.positiveTriangle) { this.createPositiveTriangle(); } } } } calculateShapeScore(shape) { const baseScore = 10; let complexityBonus = 0; let sizeBonus = 0; // Calculate complexity bonus based on number of sides if (shape.circleRadius) { complexityBonus = 0; // Circles have the lowest bonus } else { const sideCount = shape.vertices.length; complexityBonus = Math.min(sideCount * 2, 20); // Cap at 20 to prevent excessive scores } // Calculate size bonus const shapeSize = Math.max(shape.bounds.max.x - shape.bounds.min.x, shape.bounds.max.y - shape.bounds.min.y); sizeBonus = Math.min(shapeSize / 2, 30); // Cap at 30 to prevent excessive scores // Calculate total score const totalScore = baseScore + complexityBonus + sizeBonus; // Ensure the score doesn't exceed a maximum value return Math.min(totalScore, 100); } createPositiveTriangle() { const [x, y] = this.getEdgeSpawnPosition(); this.positiveTriangle = this.shapeFactory.createPositiveTriangle(x, y); this.matter.world.add(this.positiveTriangle); this.shapes.push(this.positiveTriangle); } handlePositiveTriangleRemoval() { // Store current player state const { position: { x, y }, velocity, angle } = this.player; // Calculate current scale relative to initial size const currentScale = this.currentPlayerSize / this.INITIAL_PLAYER_SIZE; // Calculate scale factor needed to return to initial size const scaleUpFactor = 1 / currentScale; // Reset lives and size this.lives = this.MAX_LIVES; this.currentPlayerSize = this.INITIAL_PLAYER_SIZE; this.MIN_PLAYER_SIZE = this.INITIAL_PLAYER_SIZE * 0.7225; // Scale player back to original size this.matter.body.scale(this.player, scaleUpFactor, scaleUpFactor); // Reset player position and movement this.matter.body.setPosition(this.player, { x, y }); this.matter.body.setVelocity(this.player, velocity); this.matter.body.setAngle(this.player, angle); // Update detection points for the new size const h = this.INITIAL_PLAYER_SIZE * Math.sqrt(3) / 2; this.detectionPoints = [{ x: 0, y: -h * (2 / 3) }, { x: -this.INITIAL_PLAYER_SIZE / 2, y: h * (1 / 3) }, { x: this.INITIAL_PLAYER_SIZE / 2, y: h * (1 / 3) }]; // Visual effects this.createGreenFlashEffect(); this.positiveTriangle = null; this.updateEnergyBar(); } createGreenFlashEffect() { const gfg = this.add.graphics().fillStyle(0x00FF00, 1).fillRect(0, 0, this.cameras.main.width, this.cameras.main.height); this.tweens.add({ targets: gfg, alpha: 0, duration: 200, ease: 'Power2', onComplete: () => gfg.destroy() }); } transformShape(shape) { const particleCount = 15; const shapeSize = Math.max(shape.bounds.max.x - shape.bounds.min.x, shape.bounds.max.y - shape.bounds.min.y); const particleSize = (shapeSize / 10) * 0.85 * 0.75; const spreadFactor = 1.5; const minSpeed = 0.3; const minLifetime = 8000; // Minimum lifetime of 8 seconds const maxLifetime = 12000; // Maximum lifetime of 12 seconds for (let i = 0; i < particleCount; i++) { const particle = this.particlePool.get(); particle.x = shape.position.x + Phaser.Math.Between(-shapeSize / 2, shapeSize / 2) * spreadFactor; particle.y = shape.position.y + Phaser.Math.Between(-shapeSize / 2, shapeSize / 2) * spreadFactor; particle.size = particleSize; particle.speedX = Phaser.Math.FloatBetween(-1, 1); particle.speedY = Phaser.Math.FloatBetween(-1, 1); particle.lifetime = Phaser.Math.Between(minLifetime, maxLifetime); particle.initialLifetime = particle.lifetime; // Store initial lifetime for alpha calculation // Ensure minimum speed const speed = Math.sqrt(particle.speedX * particle.speedX + particle.speedY * particle.speedY); if (speed < minSpeed) { const scale = minSpeed / speed; particle.speedX *= scale; particle.speedY *= scale; } particle.alpha = 0.541875; // Initial alpha particle.shape = shape.label === 'circle' ? 'circle' : 'polygon'; particle.vertices = shape.vertices ? shape.vertices.map(v => ({ x: v.x - shape.position.x, y: v.y - shape.position.y })) : null; this.particles.push(particle); } } getEdgeSpawnPosition() { const edge = Phaser.Math.Between(0, 3); switch (edge) { case 0: // Top return [Phaser.Math.Between(0, 800), 0]; case 1: // Right return [800, Phaser.Math.Between(0, 600)]; case 2: // Bottom return [Phaser.Math.Between(0, 800), 600]; case 3: // Left return [0, Phaser.Math.Between(0, 600)]; } } getQuadrantSpawnPosition() { const quadrant = Phaser.Math.Between(0, 3); const x = Phaser.Math.Between(0, 400) + (quadrant % 2) * 400; const y = Phaser.Math.Between(0, 300) + Math.floor(quadrant / 2) * 300; return [x, y]; } getSpiralSpawnPosition() { const centerX = 400; const centerY = 300; const maxRadius = Math.sqrt(400 * 400 + 300 * 300); const angle = Phaser.Math.FloatBetween(0, Math.PI * 2); const radius = Phaser.Math.FloatBetween(0, maxRadius); const x = centerX + radius * Math.cos(angle); const y = centerY + radius * Math.sin(angle); return [x, y]; } createNegativeTriangle() { const [x, y] = this.getEdgeSpawnPosition(); const negativeTriangle = this.shapeFactory.createNegativeTriangle(x, y); this.matter.world.add(negativeTriangle); this.negativeTriangles.push(negativeTriangle); this.shapes.push(negativeTriangle); } createNegativeSquare() { if (this.negativeSquares.length < 2) { const [x, y] = this.getEdgeSpawnPosition(); const negativeSquare = this.shapeFactory.createNegativeSquare(x, y); this.matter.world.add(negativeSquare); this.negativeSquares.push(negativeSquare); this.shapes.push(negativeSquare); } } manageNegativeSquares() { if (this.consumed >= this.nextNegativeSquareAt && this.negativeSquares.length < 2) { this.createNegativeSquare(); this.nextNegativeSquareAt += 400; // Set the next threshold } } createPurpleTriangle() { if (!this.purpleTriangleSpawned) { const [x, y] = this.getEdgeSpawnPosition(); this.purpleTriangle = this.shapeFactory.createPurpleTriangle(x, y); // Add gravitational properties this.purpleTriangle.gravitationalForce = 0.000225; // Increased by 50% this.purpleTriangle.gravitationalRadius = 200; this.matter.world.add(this.purpleTriangle); this.shapes.push(this.purpleTriangle); this.purpleTriangleSpawned = true; } } createGlitchEffect = shape => { const glitchGraphics = this.add.graphics(); const { bounds } = shape; const [width, height] = [bounds.max.x - bounds.min.x, bounds.max.y - bounds.min.y]; const glitchAnimation = this.tweens.createTimeline(); const createGlitchFrame = () => ({ targets: glitchGraphics, alpha: { from: 0, to: 1 }, duration: 50, onStart: () => { glitchGraphics.clear().lineStyle(2, 0xFFA500, 1); [...Array(3)].forEach(() => { const [x, y] = [Phaser.Math.Between(bounds.min.x, bounds.max.x), Phaser.Math.Between(bounds.min.y, bounds.max.y)]; glitchGraphics.strokeRect(x, y, width / 4, height / 4); }); } }); const createFadeFrame = () => ({ targets: glitchGraphics, alpha: { from: 1, to: 0 }, duration: 50 }); [...Array(5)].forEach(() => { glitchAnimation.add(createGlitchFrame()).add(createFadeFrame()); }); glitchAnimation.play(); this.time.delayedCall(600, () => glitchGraphics.destroy()); } turnShapeOrange(shape) { shape.isOrange = true; shape.isRed = false; // Ensure it's not marked as red shape.isRemovable = true; this.createGlitchEffect(shape); } handleNegativeSquareCollision(negativeSquare, otherShape) { if (otherShape.label === 'shape' && !otherShape.isOrange) { this.turnShapeOrange(otherShape); otherShape.isRemovable = true; // Mark as removable } } handleNegativeTriangleCollision(negativeTriangle, otherShape) { if ((otherShape.isOrange || otherShape.isRed) && otherShape.isRemovable) { // Remove the orange or red shape this.removeShape(otherShape); // Increase the size of the negative triangle const growthFactor = 1.1; // 10% increase this.matter.body.scale(negativeTriangle, growthFactor, growthFactor); // Update the render properties of the negative triangle negativeTriangle.render.lineWidth *= growthFactor; } } handlePlayerColoredShapeCollision(player, coloredShape) { this.strikes++; if (this.strikes >= this.MAX_STRIKES) { this.gameOver(); } else { this.lives--; this.updateLivesDisplay(); this.createFlashEffect(); } } handleStarvation() { this.strikes++; this.createFlashEffect(); if (this.strikes >= this.MAX_STRIKES) { this.gameOver(); } else { // Create glitch effect to indicate starvation this.createPlayerGlitchEffect(); // Reduce lives this.lives--; this.updateLivesDisplay(); // Create positive triangle when strikes reach 2 if (this.strikes === 2 && !this.positiveTriangle) { this.createPositiveTriangle(); } } } createStalkerTriangle() { if (this.stalkerTriangles.length >= this.MAX_STALKER_TRIANGLES) return; const [x, y] = this.getEdgeSpawnPosition(); const size = 30; // Fixed size for stalker triangles const options = { label: 'stalkerTriangle', friction: 0, frictionAir: 0.02, restitution: 0.3, }; const stalkerTriangle = this.matter.bodies.polygon(x, y, 3, size, options); stalkerTriangle.maxSpeed = 1.5; stalkerTriangle.minSpeed = 0.3; stalkerTriangle.lastTargetPosition = { x: this.player.position.x, y: this.player.position.y }; stalkerTriangle.updateDelay = 0; stalkerTriangle.updateInterval = Phaser.Math.Between(30, 60); this.matter.world.add(stalkerTriangle); this.stalkerTriangles.push(stalkerTriangle); this.shapes.push(stalkerTriangle); } removeNegativeSquare(negativeSquare) { // Create glitch effect this.createGlitchEffect(negativeSquare); // Delay the removal to allow the glitch effect to be visible this.time.delayedCall(300, () => { // Remove from negativeSquares array const index = this.negativeSquares.indexOf(negativeSquare); if (index > -1) { this.negativeSquares.splice(index, 1); } // Remove from shapes array const shapeIndex = this.shapes.indexOf(negativeSquare); if (shapeIndex > -1) { this.shapes.splice(shapeIndex, 1); } // Remove from the matter world this.matter.world.remove(negativeSquare); // Create particle effect this.createNegativeSquareParticles(negativeSquare.position.x, negativeSquare.position.y); }); } createGlitchEffect(shape) { const glitchGraphics = this.add.graphics(); const bounds = shape.bounds; const width = bounds.max.x - bounds.min.x; const height = bounds.max.y - bounds.min.y; const glitchAnimation = this.tweens.createTimeline(); for (let i = 0; i < 5; i++) { glitchAnimation.add({ targets: glitchGraphics, alpha: { from: 0, to: 1 }, duration: 50, onStart: () => { glitchGraphics.clear(); glitchGraphics.lineStyle(2, 0xFFA500, 1); // Orange color for glitch effect for (let j = 0; j < 4; j++) { const x = Phaser.Math.Between(bounds.min.x, bounds.max.x); const y = Phaser.Math.Between(bounds.min.y, bounds.max.y); const glitchSize = Math.min(width, height) / 4; glitchGraphics.strokeRect(x, y, glitchSize, glitchSize); } } }); glitchAnimation.add({ targets: glitchGraphics, alpha: { from: 1, to: 0 }, duration: 50 }); } glitchAnimation.play(); this.time.delayedCall(300, () => { glitchGraphics.destroy(); }); } createNegativeSquareParticles(x, y) { const particleCount = 20; const particleSize = 3; const particleSpeed = 2; for (let i = 0; i < particleCount; i++) { const angle = Math.random() * Math.PI * 2; const speed = Math.random() * particleSpeed; const particle = this.particlePool.get(); Object.assign(particle, { x: x, y: y, speedX: Math.cos(angle) * speed, speedY: Math.sin(angle) * speed, size: particleSize, alpha: 1, color: 0xFFA500, // Orange color lifetime: 1000, // 1 second lifetime shape: 'square' }); this.particles.push(particle); } } // Touch-related methods removed } class LoadingScene extends Phaser.Scene { constructor() { super('LoadingScene'); } create() { const { width, height } = this.scale, triangleSize = 30; const triangle = this.add.graphics() .lineStyle(1, 0xFFFF00, 1) .beginPath() .moveTo(0, -triangleSize) .lineTo(-triangleSize, triangleSize) .lineTo(triangleSize, triangleSize) .closePath() .strokePath() .setPosition(width / 2, height / 2 - 50); this.tweens.add({ targets: triangle, angle: 360, duration: 2000, repeat: -1 }); this.add.text(width / 2, height / 2, 'REAL PARTICLES USE MOUSE', { fontSize: '12px', fill: '#FF0000' }).setOrigin(0.5); const loadingText = this.add.text(width / 2, height / 2 + 25, 'LOADING', { fontSize: '16px', fill: '#FFFFFF' }).setOrigin(0.5); this.tweens.add({ targets: loadingText, alpha: 0, duration: 500, ease: 'Power2', yoyo: true, repeat: -1 }); this.add.text(width / 2, height - 20, 'WARNING: This game contains flashing lights and may potentially trigger seizures for people with photosensitive epilepsy.', { fontSize: '8px', fill: '#FF0000', align: 'center', wordWrap: { width: width - 20 } }).setOrigin(0.5); this.time.delayedCall(3000, () => this.scene.start('GameScene')); } } class GameOverScene extends Phaser.Scene { static deathCount = 0; static gameAdvice = [ "FICK'S LAW: PARTICLE ABSORPTION RATE MUST MAINTAIN STEADY STATE", "BROWNIAN MOTION SUGGESTS RAPID DISPLACEMENT FOR HAZARD AVOIDANCE", "ORANGE PARTICLE FIELD EXHIBITS LETHAL DIFFUSION PROPERTIES", "ENERGY GRADIENT MUST BE MAINTAINED ABOVE CRITICAL THRESHOLD", "GREEN TRIANGULAR PARTICLES RESTORE OPTIMAL MASS DISTRIBUTION", "CHAIN REACTIONS AMPLIFY ENERGY TRANSFER COEFFICIENT", "PURPLE VECTORS CREATE LOCALIZED GRAVITATIONAL FLUX - MAINTAIN DISTANCE", "INTERCEPTOR PARTICLES FOLLOW CONCENTRATION GRADIENT - KEEP DIFFUSING", "STAMINA CONSERVATION FOLLOWS SECOND LAW OF THERMODYNAMICS", "LARGER MASS PARTICLES YIELD HIGHER ENERGY BUT REQUIRE MORE WORK", "RED PARTICLE CONTACT CAUSES NEGATIVE MASS DIFFUSION", "NEGATIVE SQUARES INDUCE PHASE TRANSFORMATION IN NEARBY PARTICLES", "CENTRAL POSITION MINIMIZES BOUNDARY COLLISION PROBABILITY", "RAPID DIFFUSION THROUGH PARTICLE CLUSTERS OPTIMIZES ESCAPE", "PARTICLE ABSORPTION INTERVAL CRITICAL FOR SYSTEM STABILITY" ]; constructor() { super('GameOverScene'); this.particles = []; this.particleFactory = null; this.particlePool = null; this.shouldBounce = true; } init(data) { this.consumed = data.consumed; this.playerX = data.playerX; this.playerY = data.playerY; this.isStarved = data.isStarved; this.shouldBounce = true; this.explosionCreated = false; // New flag to track if explosion has been created GameOverScene.deathCount++; } create() { const { width, height } = this.scale; // Clear any remaining graphics from previous scene this.game.scene.scenes.forEach(scene => { if (scene.flashGraphics) { scene.flashGraphics.clear(); } }); // Add a black background this.add.rectangle(0, 0, width, height, 0x000000).setOrigin(0, 0); // Initialize particle factory and pool this.particleFactory = new ParticleFactory(this); this.particlePool = new ParticlePool(this.particleFactory); // Create explosion effect only if it hasn't been created yet if (!this.explosionCreated) { this.createExplosionEffect(this.playerX, this.playerY, this.isStarved); this.explosionCreated = true; } // Delay the appearance of the "Try Again" button and advice this.time.delayedCall(3000, () => { // Add advice text if past second death if (GameOverScene.deathCount > 2) { const randomAdvice = Phaser.Math.RND.pick(GameOverScene.gameAdvice); const adviceText = this.add.text(width / 2, height / 2 - 40, randomAdvice, { fontSize: '10px', fill: '#FFFF00', align: 'center', wordWrap: { width: width - 40 } }).setOrigin(0.5); // Add glowing effect to advice this.tweens.add({ targets: adviceText, alpha: 0.5, duration: 1500, yoyo: true, repeat: -1 }); } const tryAgainButton = this.add.text(width / 2, height / 2, 'TRY AGAIN', { fontSize: '14px', fill: '#FFFFFF' }).setOrigin(0.5).setInteractive(); tryAgainButton.on('pointerdown', () => { this.shouldBounce = false; // Preserve the postFX pipeline before transitioning const postFX = this.cameras.main.getPostPipeline(CRTPostFX); this.scene.start('GameScene', { reset: true, playerX: this.playerX, playerY: this.playerY, particles: this.particles, preserveEffects: true }); }); tryAgainButton.setAlpha(0); this.tweens.add({ targets: tryAgainButton, alpha: 1, duration: 500, ease: 'Power2' }); }); // Create graphics object for particle rendering this.particleGraphics = this.add.graphics(); } createExplosionEffect = (x, y, isStarved = false) => { const particleCount = isStarved ? 60 : 40; // More particles for starvation const triangleSize = isStarved ? 8 : 10; // Smaller triangles for starvation // Release existing particles this.particles.forEach(particle => this.particlePool.release(particle)); this.particles = []; const createParticle = () => { const angle = Math.random() * Math.PI * 2; // Slower, more ethereal movement for starvation const speed = isStarved ? (Math.random() * 1.0 + 0.5) : // Slower for starvation (Math.random() * 2 + 1); // Normal speed otherwise const particle = this.particlePool.get(); return Object.assign(particle, { x, y, speedX: Math.cos(angle) * speed, speedY: Math.sin(angle) * speed, alpha: 1, rotation: Math.random() * Math.PI * 2, shape: 'triangle', size: triangleSize, color: isStarved ? 0xFFFFFF : 0xFFFF00, // White for starvation, yellow otherwise rotationSpeed: isStarved ? (Math.random() * 0.02 - 0.01) : // Slower rotation for starvation 0.02 // Normal rotation otherwise }); }; this.particles = Array(particleCount).fill().map(createParticle); } update(time, delta) { if (!this.shouldBounce) return; // Stop updating if shouldBounce is false this.particleGraphics.clear(); const { width, height } = this.scale; this.particles.forEach(particle => { // Update position particle.x += particle.speedX; particle.y += particle.speedY; // Bounce off edges if (particle.x <= 0 || particle.x >= width) { particle.speedX *= -1; particle.x = Phaser.Math.Clamp(particle.x, 0, width); } if (particle.y <= 0 || particle.y >= height) { particle.speedY *= -1; particle.y = Phaser.Math.Clamp(particle.y, 0, height); } // Update rotation particle.rotation += 0.02; // Draw particle this.particleGraphics.lineStyle(2, particle.color, particle.alpha); this.particleGraphics.save(); this.particleGraphics.translateCanvas(particle.x, particle.y); this.particleGraphics.rotateCanvas(particle.rotation); this.particleGraphics.strokeTriangle( 0, -particle.size / 2, -particle.size / 2, particle.size / 2, particle.size / 2, particle.size / 2 ); this.particleGraphics.restore(); }); } } // CRT shader for scanlines and barrel distortion const fragmentShader = ` precision mediump float; uniform float time; uniform vec2 resolution; uniform sampler2D uMainSampler; varying vec2 outTexCoord; void main(void) { vec2 uv = outTexCoord; // Barrel distortion vec2 cc = uv - 0.5; float dist = dot(cc, cc) * 0.3; uv = uv + cc * (dist); // Check if outside of bounds if (uv.x < 0.0 || uv.x > 1.0 || uv.y < 0.0 || uv.y > 1.0) { gl_FragColor = vec4(0.0, 0.0, 0.0, 1.0); return; } // Scanlines vec4 color = texture2D(uMainSampler, uv); float scanline = sin(uv.y * 800.0) * 0.04; color -= scanline; // Vignette float vignette = length(cc) * 0.5; color *= 1.0 - vignette; gl_FragColor = color; } `; class CRTPostFX extends Phaser.Renderer.WebGL.Pipelines.PostFXPipeline { constructor(game) { super({ game, renderTarget: true, fragShader: fragmentShader, uniforms: [ 'uMainSampler', 'time', 'resolution' ] }); this.time = 0; } onBoot() { this.set2f('resolution', this.renderer.width, this.renderer.height); } onPreRender() { this.set1f('time', this.time); this.time += 0.005; } } const config = { type: Phaser.WEBGL, type: Phaser.AUTO, parent: 'renderDiv', scale: { mode: Phaser.Scale.FIT, autoCenter: Phaser.Scale.CENTER_BOTH, width: 800, height: 600, zoom: 1 / 3, // This will render at one-third resolution }, width: 266, // One-third of the original width (rounded down) height: 200, // One-third of the original height scene: [LoadingScene, GameScene, GameOverScene], physics: { default: 'matter', matter: { gravity: { y: 0 } } }, pixelArt: true, // This will prevent anti-aliasing, giving a sharper pixel look pipeline: { CRTPostFX }, callbacks: { postBoot: function(game) { game.scene.scenes.forEach(scene => { scene.cameras.main.setPostPipeline(CRTPostFX); }); } } }; window.phaserGame = new Phaser.Game(config);