import * as THREE from 'three'; import { Player, Enemy, Projectile, WORLD_BOUNDS, ENEMY_TYPES } from 'GameObjects'; export class GameEngine { constructor(scene, camera, playerStats = {}) { this.scene = scene; this.camera = camera; this.player = new Player(playerStats); this.enemies = []; this.projectiles = []; this.score = 0; this.lastSpawnTime = 0; this.enemyMeshes = []; this.projectileMeshes = []; this.initPlayer(); } initPlayer() { // Create player mesh const playerGeometry = new THREE.CircleGeometry(this.player.size, 32); const playerMaterial = new THREE.MeshBasicMaterial({ color: 0x00ff88, transparent: true, opacity: 0.8, }); this.playerMesh = new THREE.Mesh(playerGeometry, playerMaterial); // Add shield ring const shieldGeometry = new THREE.RingGeometry( this.player.size + 5, this.player.size + 8, 32 ); const shieldMaterial = new THREE.MeshBasicMaterial({ color: 0x4287f5, transparent: true, opacity: 0, blending: THREE.AdditiveBlending }); this.shieldMesh = new THREE.Mesh(shieldGeometry, shieldMaterial); this.playerMesh.add(this.shieldMesh); // Add player glow const glowGeometry = new THREE.CircleGeometry(this.player.size * 1.2, 32); const glowMaterial = new THREE.MeshBasicMaterial({ color: 0x00ff88, transparent: true, opacity: 0.3, blending: THREE.AdditiveBlending, }); const glowMesh = new THREE.Mesh(glowGeometry, glowMaterial); glowMesh.position.z = -1; // Place glow behind player this.playerMesh.add(glowMesh); this.scene.add(this.playerMesh); } spawnEnemy(currentTime) { const BASE_SPAWN_INTERVAL = 1200; const DIFFICULTY_SCALE = 0.92; const currentLevel = Math.floor(this.score / 800); const currentSpawnInterval = BASE_SPAWN_INTERVAL * Math.pow(DIFFICULTY_SCALE, currentLevel); if (!this.isPaused && currentTime - this.lastSpawnTime > currentSpawnInterval) { const angle = Math.random() * Math.PI * 2; const spawnRadius = 600; const x = this.player.position.x + Math.cos(angle) * spawnRadius; const y = this.player.position.y + Math.sin(angle) * spawnRadius; const enemyType = this.determineEnemyType(); const enemy = new Enemy(x, y, enemyType); // Create base shape const shape = new THREE.Shape(); const enemyConfig = ENEMY_TYPES[enemyType]; switch (enemyConfig.shape) { case 'triangle': this.createTriangleShape(shape, enemy.size); break; case 'square': this.createSquareShape(shape, enemy.size); break; case 'pentagon': this.createPolygonShape(shape, enemy.size, 5); break; case 'octagon': this.createPolygonShape(shape, enemy.size, 8); break; default: shape.absarc(0, 0, enemy.size, 0, Math.PI * 2); } const geometry = new THREE.ShapeGeometry(shape); const material = new THREE.MeshBasicMaterial({ color: enemyConfig.color, transparent: true, opacity: 0.9 }); const enemyMesh = new THREE.Mesh(geometry, material); // Add trail effect for certain enemy types if (['DASHER', 'BERSERKER'].includes(enemyType)) { const trailGeometry = geometry.clone(); const trailMaterial = new THREE.MeshBasicMaterial({ color: enemyConfig.color, transparent: true, opacity: 0.3, blending: THREE.AdditiveBlending }); const trail = new THREE.Mesh(trailGeometry, trailMaterial); trail.scale.multiplyScalar(1.2); trail.position.z = -0.1; enemyMesh.add(trail); } this.enemies.push(enemy); this.scene.add(enemyMesh); this.enemyMeshes.push(enemyMesh); this.lastSpawnTime = currentTime; } } getEnemyGeometry(enemy) { const segments = { circle: 32, triangle: 3, square: 4, pentagon: 5, octagon: 8 }; // Use proper number of segments based on enemy shape const segmentCount = segments[enemy.shape] || 32; return new THREE.CircleGeometry(enemy.size, segmentCount); } determineEnemyType() { const roll = Math.random(); const score = this.score; if (score < 800) { return 'SWARMER'; } else if (score < 2000) { if (roll < 0.6) return 'SWARMER'; return 'DASHER'; } else if (score < 4000) { if (roll < 0.4) return 'SWARMER'; if (roll < 0.7) return 'DASHER'; return 'TANK'; } else if (score < 6000) { if (roll < 0.3) return 'SWARMER'; if (roll < 0.5) return 'DASHER'; if (roll < 0.7) return 'TANK'; if (roll < 0.9) return 'SPLITTER'; return 'TELEPORTER'; } else { if (roll < 0.2) return 'SWARMER'; if (roll < 0.4) return 'DASHER'; if (roll < 0.6) return 'TANK'; if (roll < 0.75) return 'SPLITTER'; if (roll < 0.9) return 'TELEPORTER'; return 'BERSERKER'; } } update(deltaTime, currentTime, keys) { this.isPaused = deltaTime === 0; // Handle shield regeneration for shield class if (this.player.classPath === 'shield' && this.player.shield < this.player.stats.shieldCapacity) { this.player.shieldRegenTime += deltaTime; if (this.player.shieldRegenTime >= 2) { // 2 second delay before regen this.player.shield = Math.min( this.player.shield + (20 * deltaTime * this.player.stats.shieldRegenRate), this.player.stats.shieldCapacity ); } } if (!this.isPaused) { this.updatePlayer(deltaTime, keys); this.updateEnemies(deltaTime); this.updateProjectiles(deltaTime); this.handleCollisions(); this.cleanupObjects(); this.spawnEnemy(currentTime); this.handleShooting(currentTime); } this.updateCamera(); } createTriangleShape(shape, size) { const angles = [0, 120, 240].map(a => a * Math.PI / 180); shape.moveTo(Math.cos(angles[0]) * size, Math.sin(angles[0]) * size); for (let i = 1; i < angles.length; i++) { shape.lineTo(Math.cos(angles[i]) * size, Math.sin(angles[i]) * size); } shape.closePath(); } createSquareShape(shape, size) { shape.moveTo(-size, -size); shape.lineTo(size, -size); shape.lineTo(size, size); shape.lineTo(-size, size); shape.closePath(); } createPolygonShape(shape, size, sides) { const angles = Array.from({length: sides}, (_, i) => (i * 2 * Math.PI / sides)); shape.moveTo(Math.cos(angles[0]) * size, Math.sin(angles[0]) * size); for (let i = 1; i < angles.length; i++) { shape.lineTo(Math.cos(angles[i]) * size, Math.sin(angles[i]) * size); } shape.closePath(); } handleShooting(currentTime) { if (currentTime - this.player.lastShot > this.player.stats.shootDelay) { let nearestEnemy = null; let minDistance = Infinity; this.enemies.forEach(enemy => { const distance = enemy.position.distanceTo(this.player.position); if (distance < minDistance) { minDistance = distance; nearestEnemy = enemy; } }); if (nearestEnemy) { const baseDirection = new THREE.Vector2() .subVectors(nearestEnemy.position, this.player.position) .normalize(); // Calculate spread angles based on projectile count const projectileCount = this.player.stats.projectileCount; const spreadAngle = Math.min(10, projectileCount * 5); // Max 10 degrees between projectiles for (let i = 0; i < projectileCount; i++) { // Calculate angle for current projectile const angleOffset = (i - (projectileCount - 1) / 2) * (spreadAngle * Math.PI / 180); // Rotate base direction by angleOffset const direction = baseDirection.clone().rotateAround(new THREE.Vector2(0, 0), angleOffset); const projectile = new Projectile( this.player.position.x, this.player.position.y, direction, this.player.stats.projectileSize ); this.projectiles.push(projectile); const projectileGeometry = new THREE.CircleGeometry(this.player.stats.projectileSize, 16); let projectileMaterial; // Class-specific projectile effects switch (this.player.classPath) { case 'multishot': projectileMaterial = new THREE.MeshBasicMaterial({ color: 0x00ff7f, // Updated to match new class color transparent: true, opacity: 0.8, blending: THREE.AdditiveBlending }); break; case 'shield': projectileMaterial = new THREE.MeshBasicMaterial({ color: 0x4287f5, transparent: true, opacity: 0.8, blending: THREE.AdditiveBlending }); break; case 'piercing': projectileMaterial = new THREE.MeshBasicMaterial({ color: 0xff4242, transparent: true, opacity: 0.9, blending: THREE.AdditiveBlending }); break; case 'bruiser': projectileMaterial = new THREE.MeshBasicMaterial({ color: 0xffd700, transparent: true, opacity: 0.9 }); break; case 'timeweaver': projectileMaterial = new THREE.MeshBasicMaterial({ color: 0x9932cc, transparent: true, opacity: 0.8, blending: THREE.AdditiveBlending }); break; default: projectileMaterial = new THREE.MeshBasicMaterial({ color: 0x00ffff, transparent: true, opacity: 0.8 }); } const projectileMesh = new THREE.Mesh(projectileGeometry, projectileMaterial); projectileMesh.position.set(projectile.position.x, projectile.position.y, 0); // Add class-specific effects if (this.player.classPath) { const trailGeometry = new THREE.CircleGeometry(this.player.stats.projectileSize * 0.8, 16); const trailMaterial = projectileMaterial.clone(); trailMaterial.opacity = 0.3; const trail = new THREE.Mesh(trailGeometry, trailMaterial); trail.position.z = -0.1; projectileMesh.add(trail); // Add specific class effects switch (this.player.classPath) { case 'piercing': const pierceGlow = new THREE.PointLight(0xff4242, 0.5, 30); projectileMesh.add(pierceGlow); break; case 'bruiser': projectileMesh.scale.set(1.2, 1.2, 1); const shockwave = new THREE.RingGeometry( this.player.stats.projectileSize * 1.2, this.player.stats.projectileSize * 1.5, 16 ); const shockwaveMaterial = new THREE.MeshBasicMaterial({ color: 0xffd700, transparent: true, opacity: 0.3, blending: THREE.AdditiveBlending }); const shockwaveMesh = new THREE.Mesh(shockwave, shockwaveMaterial); projectileMesh.add(shockwaveMesh); break; case 'timeweaver': const timeDistortion = new THREE.RingGeometry( this.player.stats.projectileSize * 0.8, this.player.stats.projectileSize * 2, 16 ); const distortionMaterial = new THREE.MeshBasicMaterial({ color: 0x9932cc, transparent: true, opacity: 0.2, blending: THREE.AdditiveBlending }); const distortionMesh = new THREE.Mesh(timeDistortion, distortionMaterial); projectileMesh.add(distortionMesh); break; } } this.scene.add(projectileMesh); this.projectileMeshes.push(projectileMesh); } this.player.lastShot = currentTime; } } } handleLevelUp() { if (this.onLevelUp) { this.onLevelUp(this.player.getUpgradeChoices()); } } setGameOverCallback(callback) { this.gameOver = callback; } setLevelUpCallback(callback) { this.onLevelUp = callback; } updatePlayer(deltaTime, keys) { this.player.update(keys, deltaTime); this.playerMesh.position.set(this.player.position.x, this.player.position.y, 0); // Update shield visual if (this.player.classPath === 'shield') { const shieldRatio = this.player.shield / this.player.stats.shieldCapacity; this.shieldMesh.material.opacity = shieldRatio * 0.6; // Pulse effect when shield is active if (this.player.shield > 0) { const pulseScale = 1 + Math.sin(Date.now() * 0.005) * 0.1; this.shieldMesh.scale.set(pulseScale, pulseScale, 1); } } } updateEnemies(deltaTime) { this.enemies.forEach((enemy, index) => { enemy.update(this.player.position, deltaTime); this.enemyMeshes[index].position.set(enemy.position.x, enemy.position.y, 0); }); } updateProjectiles(deltaTime) { this.projectiles.forEach((projectile, index) => { projectile.update(deltaTime); this.projectileMeshes[index].position.set(projectile.position.x, projectile.position.y, 0); }); } handleCollisions() { // Check enemy collisions with player this.enemies.forEach((enemy, i) => { if (enemy.position.distanceTo(this.player.position) < enemy.size + this.player.size) { let damage = enemy.damage; // Enhanced shield protection if (this.player.classPath === 'shield' && this.player.shield > 0) { // If damage would kill the player, shield takes the full hit instead if (damage >= this.player.health) { this.player.shield = 0; // Shield breaks damage = 0; // No damage to health } else { // Normal shield damage reduction const absorbedDamage = Math.min(this.player.shield, damage); damage -= absorbedDamage; this.player.shield -= absorbedDamage; } // Create shield hit effect const shieldFlash = new THREE.RingGeometry( this.player.size * 1.2, this.player.size * 1.4, 32 ); const flashMaterial = new THREE.MeshBasicMaterial({ color: 0x4287f5, transparent: true, opacity: 0.8, blending: THREE.AdditiveBlending }); const flashMesh = new THREE.Mesh(shieldFlash, flashMaterial); flashMesh.position.copy(this.playerMesh.position); this.scene.add(flashMesh); // Remove flash effect setTimeout(() => { this.scene.remove(flashMesh); flashMesh.geometry.dispose(); flashMesh.material.dispose(); }, 200); } if (damage > 0 && this.player.takeDamage(damage)) { this.gameOver(this.score); } } }); // Check projectile hits const projectilesToRemove = []; const enemiesToRemove = []; this.projectiles.forEach((projectile, projectileIndex) => { this.enemies.forEach((enemy, enemyIndex) => { if (projectile.position.distanceTo(enemy.position) < projectile.size + enemy.size) { // Handle class-specific hit effects let shouldRemoveProjectile = true; let damage = this.player.stats.projectileDamage; // Initialize pierceCount if not exists if (this.player.classPath === 'piercing') { projectile.pierceCount = projectile.pierceCount || 0; } switch (this.player.classPath) { case 'piercing': // Piercing projectiles continue through enemies and deal bonus damage shouldRemoveProjectile = projectile.pierceCount >= this.player.stats.projectilePiercing; damage *= this.player.stats.piercingDamageMultiplier; projectile.pierceCount = (projectile.pierceCount || 0) + 1; break; case 'bruiser': // Bruiser bullets have knockback effect const knockbackDir = projectile.velocity.clone().normalize(); enemy.position.add( knockbackDir.multiplyScalar(this.player.stats.knockbackForce || 100) ); break; case 'timeweaver': // Time Weaver applies slow effect enemy.speed *= (1 - this.player.stats.slowEffect); enemy.slowDuration = this.player.stats.slowDuration || 1; break; } if (shouldRemoveProjectile) { projectilesToRemove.push(projectileIndex); } // Create hit flash effect using enemy shape const shape = new THREE.Shape(); const enemyConfig = ENEMY_TYPES[enemy.type]; switch (enemyConfig.shape) { case 'triangle': this.createTriangleShape(shape, enemy.size * 1.2); break; case 'square': this.createSquareShape(shape, enemy.size * 1.2); break; case 'pentagon': this.createPolygonShape(shape, enemy.size * 1.2, 5); break; case 'octagon': this.createPolygonShape(shape, enemy.size * 1.2, 8); break; default: shape.absarc(0, 0, enemy.size * 1.2, 0, Math.PI * 2); } const geometry = new THREE.ShapeGeometry(shape); const flashColor = new THREE.Color(enemyConfig.color); flashColor.lerp(new THREE.Color(0xffffff), 0.6); const material = new THREE.MeshBasicMaterial({ color: flashColor, transparent: true, opacity: 0.8, blending: THREE.AdditiveBlending }); const hitFlash = new THREE.Mesh(geometry, material); hitFlash.position.copy(this.enemyMeshes[enemyIndex].position); this.scene.add(hitFlash); // Remove flash after 100ms setTimeout(() => { this.scene.remove(hitFlash); hitFlash.geometry.dispose(); hitFlash.material.dispose(); }, 100); if (enemy.takeDamage(this.player.stats.projectileDamage)) { // Create destruction particles before removing enemy const particleCount = enemy.type === 'TANK' ? 15 : 8; const enemyPos = this.enemyMeshes[enemyIndex].position; const color = ENEMY_TYPES[enemy.type].color; for (let i = 0; i < particleCount; i++) { const angle = (i / particleCount) * Math.PI * 2; const speed = 150; // Create shape-matching particles const shape = new THREE.Shape(); const particleSize = enemy.size / 4; switch (enemyConfig.shape) { case 'triangle': this.createTriangleShape(shape, particleSize); break; case 'square': this.createSquareShape(shape, particleSize); break; case 'pentagon': this.createPolygonShape(shape, particleSize, 5); break; case 'octagon': this.createPolygonShape(shape, particleSize, 8); break; default: shape.absarc(0, 0, particleSize, 0, Math.PI * 2); } const geometry = new THREE.ShapeGeometry(shape); const material = new THREE.MeshBasicMaterial({ color: color, transparent: true, opacity: 0.8, blending: THREE.AdditiveBlending }); // Create the main particle const particle = new THREE.Mesh(geometry, material); particle.position.copy(enemyPos); particle.userData.velocity = new THREE.Vector2( Math.cos(angle) * speed, Math.sin(angle) * speed ); particle.userData.rotationSpeed = (Math.random() - 0.5) * 15; particle.userData.decay = 1.0; // Create trail segments const trailCount = 3; const trailSegments = []; for (let t = 0; t < trailCount; t++) { const trailGeometry = geometry.clone(); const trailMaterial = material.clone(); trailMaterial.opacity = 0.3 * (1 - t / trailCount); const trailSegment = new THREE.Mesh(trailGeometry, trailMaterial); trailSegment.scale.multiplyScalar(0.8 - t * 0.15); particle.add(trailSegment); trailSegments.push(trailSegment); } particle.userData.trailSegments = trailSegments; this.scene.add(particle); // Animate and remove particle const startTime = Date.now(); const animate = () => { const elapsed = (Date.now() - startTime) / 1000; particle.userData.decay -= elapsed; if (particle.userData.decay > 0) { const newX = particle.position.x + particle.userData.velocity.x * elapsed; const newY = particle.position.y + particle.userData.velocity.y * elapsed; // Update trail positions particle.userData.trailSegments.forEach((trail, index) => { const trailDelay = (index + 1) * 0.1; const trailX = particle.position.x - particle.userData.velocity.x * elapsed * trailDelay; const trailY = particle.position.y - particle.userData.velocity.y * elapsed * trailDelay; trail.position.set( -(newX - trailX), -(newY - trailY), -0.1 * (index + 1) ); trail.material.opacity = particle.userData.decay * (1 - index * 0.2); }); particle.position.set(newX, newY, 0); particle.rotation.z += particle.userData.rotationSpeed * elapsed; // Add scale animation const scaleProgress = 1 - particle.userData.decay; const scale = 1 + scaleProgress * 0.5; particle.scale.set(scale, scale, 1); // Color transition from enemy color to white const baseColor = new THREE.Color(color); const targetColor = new THREE.Color(0xffffff); const colorProgress = Math.min(1, (1 - particle.userData.decay) * 2); const currentColor = baseColor.clone().lerp(targetColor, colorProgress); particle.material.color = currentColor; particle.material.opacity = particle.userData.decay; requestAnimationFrame(animate); } else { // Clean up all materials and geometries particle.userData.trailSegments.forEach(trail => { if (trail && trail.geometry) trail.geometry.dispose(); if (trail && trail.material) trail.material.dispose(); }); if (particle) { this.scene.remove(particle); if (particle.geometry) particle.geometry.dispose(); if (particle.material) particle.material.dispose(); } } }; animate(); } enemiesToRemove.push(enemyIndex); this.score += enemy.points; if (this.player.gainXP(enemy.points * 0.5)) { this.handleLevelUp(); } } } }); }); // Remove enemies and projectiles enemiesToRemove.sort((a, b) => b - a).forEach(index => { const mesh = this.enemyMeshes[index]; this.scene.remove(mesh); mesh.geometry.dispose(); mesh.material.dispose(); this.enemyMeshes.splice(index, 1); this.enemies.splice(index, 1); }); projectilesToRemove.sort((a, b) => b - a).forEach(index => { const mesh = this.projectileMeshes[index]; this.scene.remove(mesh); mesh.geometry.dispose(); mesh.material.dispose(); this.projectileMeshes.splice(index, 1); this.projectiles.splice(index, 1); }); } cleanupObjects() { const CLEANUP_DISTANCE = 1200; const VISIBLE_DISTANCE = 800; // Only remove objects that are both far from player and outside visible area const playerPos = this.player.position; // Clean up enemies for (let i = this.enemies.length - 1; i >= 0; i--) { const distance = this.enemies[i].position.distanceTo(playerPos); if (distance > CLEANUP_DISTANCE) { this.scene.remove(this.enemyMeshes[i]); this.enemyMeshes[i].geometry.dispose(); this.enemyMeshes[i].material.dispose(); this.enemyMeshes.splice(i, 1); this.enemies.splice(i, 1); } } // Clean up projectiles for (let i = this.projectiles.length - 1; i >= 0; i--) { const distance = this.projectiles[i].position.distanceTo(playerPos); if (distance > VISIBLE_DISTANCE || this.projectiles[i].isDead()) { this.scene.remove(this.projectileMeshes[i]); this.projectileMeshes[i].geometry.dispose(); this.projectileMeshes[i].material.dispose(); this.projectileMeshes.splice(i, 1); this.projectiles.splice(i, 1); } } } updateCamera() { const cameraTargetX = this.player.position.x; const cameraTargetY = this.player.position.y; this.camera.position.x += (cameraTargetX - this.camera.position.x) * 0.1; this.camera.position.y += (cameraTargetY - this.camera.position.y) * 0.1; } dispose() { // Cleanup all meshes and geometries this.scene.remove(this.playerMesh); this.playerMesh.geometry.dispose(); this.playerMesh.material.dispose(); this.enemyMeshes.forEach(mesh => { this.scene.remove(mesh); mesh.geometry.dispose(); mesh.material.dispose(); }); this.projectileMeshes.forEach(mesh => { this.scene.remove(mesh); mesh.geometry.dispose(); mesh.material.dispose(); }); this.enemies = []; this.projectiles = []; this.enemyMeshes = []; this.projectileMeshes = []; } }