import * as THREE from 'three'; import { Enemy } from 'Enemy'; import { Boss } from 'Boss'; export class EnemyManager { constructor(scene) { this.COIN_MERGE_RADIUS = 1.0; // Distance within which coins will merge this.COIN_GRAVITATE_RADIUS = 2.0; // Distance for initial gravitation this.COIN_PLAYER_ATTRACTION_RADIUS = 3.0; // Distance at which coins start moving to player this.bossDefeated = false; // Flag to track if boss was already defeated this.COIN_ATTRACTION_SPEED = 0.05; // Speed for merging (halved from 0.1) this.COIN_GRAVITATION_SPEED = 0.01; // Slower speed for general gravitation (halved from 0.02) this.COIN_PLAYER_ATTRACTION_SPEED = 0.0375; // Halved from 0.075 for slower player attraction // Boss system this.boss = null; this.isBossFight = false; this.COIN_ATTRACTION_SPEED = 0.1; // Speed for merging this.COIN_GRAVITATION_SPEED = 0.02; // Slower speed for general gravitation // Store current level from ThreeScene this.currentLevel = window.threeScene?.currentLevel || 1; // Round system properties this.currentRound = 1; this.roundDuration = 60000; // 60 seconds in milliseconds this.roundStartTime = Date.now(); this.roundTimer = null; this.enemyProjectiles = []; Enemy.setProjectilesRef(this.enemyProjectiles); this.scene = scene; this.projectileManager = null; this.enemies = []; this.coins = []; // Wave spawning properties this.waveTimer = 0; this.waveInterval = 3000; // Time between waves this.lastWaveTime = Date.now(); this.possibleWaveSizes = [1, 3, 5, 7]; this.isSpawningWave = false; this.currentWaveEnemies = 0; this.enemySpacing = 1.2; // Vertical space between enemies in formation // Load coin texture and create material const textureLoader = new THREE.TextureLoader(); this.coinTexture = textureLoader.load('https://play.rosebud.ai/assets/ForgottenWorlds-SMS-Zenny-LargeCoin.png?M23U'); this.coinTexture.encoding = THREE.sRGBEncoding; this.coinMaterial = new THREE.MeshBasicMaterial({ map: this.coinTexture, transparent: true, side: THREE.FrontSide }); } update() { const currentTime = Date.now(); // Check round timer this.checkRoundTimer(); // Update boss if active if (this.isBossFight && this.boss) { this.boss.update(window.threeScene.player, this); } // Update coins this.updateCoins(); // Update enemy projectiles const projectilesToRemove = []; this.enemyProjectiles.forEach((projectile, index) => { // Move projectile projectile.position.x += projectile.velocity.x; projectile.position.y += projectile.velocity.y || 0; // Check if projectile is off screen (both sides, top, and bottom) if (projectile.position.x < -12 || projectile.position.x > 12 || projectile.position.y < -8 || projectile.position.y > 8) { projectilesToRemove.push(index); } }); // Remove off-screen projectiles projectilesToRemove.reverse().forEach(index => { const projectile = this.enemyProjectiles[index]; this.scene.remove(projectile); projectile.geometry.dispose(); projectile.material.dispose(); this.enemyProjectiles.splice(index, 1); }); // Only handle wave spawning if not in boss fight if (!this.isBossFight) { // Handle wave spawning if (!this.isSpawningWave && currentTime - this.lastWaveTime > this.waveInterval) { this.startNewWave(); } // If we're in the middle of spawning a wave, continue spawning if (this.isSpawningWave) { this.continueWaveSpawn(); } } // Update existing enemies const enemiesToRemove = []; this.enemies.forEach((enemy, index) => { const isOffScreen = enemy.update(); if (isOffScreen) { enemiesToRemove.push(index); } }); // Remove enemies that are off screen enemiesToRemove.reverse().forEach(index => { const enemy = this.enemies[index]; if (enemy) { enemy.cleanup(); this.enemies.splice(index, 1); } }); } startNewRound() { this.currentRound++; // Increase difficulty with each round this.waveInterval = Math.max(1500, 3000 - (this.currentRound * 200)); // Waves come faster this.shootInterval = Math.max(1000, 2000 - (this.currentRound * 100)); // Enemies shoot faster // Reset round timer this.roundStartTime = Date.now(); // Update the round display if (window.threeScene && window.threeScene.scorePanel) { window.threeScene.scorePanel.updateRound(this.currentRound); } } checkRoundTimer() { const currentTime = Date.now(); const timeElapsed = currentTime - this.roundStartTime; const timeRemaining = Math.max(0, this.roundDuration - timeElapsed); // Update timer display if (window.threeScene && window.threeScene.scorePanel) { window.threeScene.scorePanel.updateTimer(Math.ceil(timeRemaining / 1000)); } // Check if round is over if (timeRemaining <= 0) { if (!this.isBossFight && !this.bossDefeated) { this.startBossFight(); } } } startBossFight() { this.isBossFight = true; // Clear existing enemies this.enemies.forEach(enemy => enemy.cleanup()); this.enemies = []; // Stop background scrolling if (window.threeScene) { window.threeScene.isScrolling = false; } // Create boss if not exists if (!this.boss) { this.boss = new Boss(this.scene); } this.boss.activate(); } endBossFight() { this.isBossFight = false; // Resume background scrolling if (window.threeScene) { window.threeScene.isScrolling = true; } // Ensure boss is fully cleaned up if (this.boss) { this.boss.cleanup(); this.boss = null; } // Set a flag to prevent spawning a new boss immediately this.bossDefeated = true; // Show store immediately after boss cleanup if (window.threeScene?.setShowStore) { window.threeScene.setShowStore(true, true); } // Start new round only after store is closed // This is now handled by the StoreScreen component's onClose callback } startNewWave() { // Randomly select wave size from possible sizes const waveSize = this.possibleWaveSizes[Math.floor(Math.random() * this.possibleWaveSizes.length)]; // Calculate formation parameters const totalHeight = (waveSize - 1) * this.enemySpacing; this.waveStartY = -totalHeight / 2; // Initialize wave spawning this.currentWaveSize = waveSize; this.currentWaveEnemies = 0; this.isSpawningWave = true; this.enemySpawnDelay = 150; // Delay between each enemy in the wave this.lastEnemySpawnTime = Date.now(); } continueWaveSpawn() { const currentTime = Date.now(); // Check if it's time to spawn the next enemy in the wave if (currentTime - this.lastEnemySpawnTime > this.enemySpawnDelay) { // Calculate position in formation const spawnY = this.waveStartY + (this.currentWaveEnemies * this.enemySpacing); const spawnPosition = new THREE.Vector3(12, spawnY, 1); // Create enemy and pass currentLevel const enemy = new Enemy(this.scene, spawnPosition); // Ensure enemy has access to the current level if (enemy && !window.threeScene) { // If window.threeScene isn't available, create a fallback window.threeScene = { currentLevel: this.currentLevel }; } this.enemies.push(enemy); this.currentWaveEnemies++; this.lastEnemySpawnTime = currentTime; // Check if wave is complete if (this.currentWaveEnemies >= this.currentWaveSize) { this.isSpawningWave = false; this.lastWaveTime = currentTime; } } } checkProjectileCollisions(projectiles) { const projectilesToRemove = []; const enemiesToRemove = []; // Check boss collisions if in boss fight if (this.isBossFight && this.boss && this.boss.active && this.boss.mesh) { projectiles.forEach((projectile, projectileIndex) => { const bossBounds = { left: this.boss.mesh.position.x - 1.5, right: this.boss.mesh.position.x + 1.5, top: this.boss.mesh.position.y + 1.5, bottom: this.boss.mesh.position.y - 1.5 }; const projectileX = projectile.position.x; const projectileY = projectile.position.y; if (projectileX >= bossBounds.left && projectileX <= bossBounds.right && projectileY >= bossBounds.bottom && projectileY <= bossBounds.top) { // Create hit effect this.projectileManager.createHitEffect(projectile.position); const isBossDead = this.boss.takeDamage(34); if (isBossDead) { this.boss.cleanup(); this.boss = null; this.endBossFight(); } projectilesToRemove.push(projectileIndex); } }); } // Regular enemy collisions projectiles.forEach((projectile, projectileIndex) => { // Skip if projectile is invalid or already marked for removal if (!projectile || !projectile.position || projectilesToRemove.includes(projectileIndex)) return; // Boss collision handling if (this.isBossFight && this.boss && this.boss.active && this.boss.mesh) { const bossBounds = { left: this.boss.mesh.position.x - 1.5, right: this.boss.mesh.position.x + 1.5, top: this.boss.mesh.position.y + 1.5, bottom: this.boss.mesh.position.y - 1.5 }; if (this.checkCollision(projectile.position, bossBounds)) { this.projectileManager?.createHitEffect(projectile.position); const isBossDead = this.boss.takeDamage(34); if (isBossDead) { this.boss.cleanup(); this.boss = null; this.endBossFight(); } projectilesToRemove.push(projectileIndex); return; } } // Regular enemy collision handling this.enemies.forEach((enemy, enemyIndex) => { // Skip if enemy is invalid or already marked for removal if (!enemy?.mesh?.position || enemiesToRemove.includes(enemyIndex)) return; const enemyBounds = { left: enemy.mesh.position.x - 0.4, right: enemy.mesh.position.x + 0.4, top: enemy.mesh.position.y + 0.3, bottom: enemy.mesh.position.y - 0.3 }; // Check if projectile is within enemy bounds if (this.checkCollision(projectile.position, enemyBounds)) { // Create hit effect at projectile position this.projectileManager.createHitEffect(projectile.position); const isDead = enemy?.takeDamage(34); if (isDead) { // Only add to remove list if enemy exists and not already marked if (enemy && enemy.mesh && !enemiesToRemove.includes(enemyIndex)) { enemiesToRemove.push(enemyIndex); // Store enemy position before removal for effects const enemyPosition = enemy.mesh.position.clone(); // Create larger explosion effect on death for (let i = 0; i < 3; i++) { const offset = new THREE.Vector3( (Math.random() - 0.5) * 0.3, (Math.random() - 0.5) * 0.3, 0 ); this.projectileManager.createHitEffect( enemyPosition.clone().add(offset) ); } // Spawn coin at enemy position this.spawnCoin(enemyPosition); } } projectilesToRemove.push(projectileIndex); } }); }); return { projectilesToRemove, enemiesToRemove }; } spawnCoin(position) { // Create coin with appropriate size (scaled up from original 13x16) const coinSize = 0.3; const coinAspectRatio = 13/16; const geometry = new THREE.PlaneGeometry(coinSize * coinAspectRatio, coinSize); const coin = new THREE.Mesh(geometry, this.coinMaterial.clone()); coin.position.copy(position); coin.position.z = 1; // Add coin properties coin.rotationSpeed = -0.05; // Negative value for opposite rotation coin.value = 1; // Base coin value coin.size = coinSize; coin.isMoving = false; coin.targetPosition = null; this.coins.push(coin); this.scene.add(coin); } updateCoins() { const player = window.threeScene?.player; const coinsToRemove = new Set(); const gravitatingCoins = new Set(); const playerAttractedCoins = new Set(); // First pass: identify coins that should merge or gravitate for (let i = 0; i < this.coins.length; i++) { if (coinsToRemove.has(i)) continue; const nearbyCoinIndices = []; const coin = this.coins[i]; for (let j = i + 1; j < this.coins.length; j++) { if (coinsToRemove.has(j)) continue; const otherCoin = this.coins[j]; const distance = coin.position.distanceTo(otherCoin.position); if (distance < this.COIN_MERGE_RADIUS) { // Close enough to merge nearbyCoinIndices.push(j); } else if (distance < this.COIN_GRAVITATE_RADIUS) { // Close enough to gravitate gravitatingCoins.add(i); gravitatingCoins.add(j); } } // If we found enough nearby coins to merge if (nearbyCoinIndices.length >= 2) { // Need at least 3 coins total // Calculate center position for merged coin const centerPosition = new THREE.Vector3(); centerPosition.copy(coin.position); nearbyCoinIndices.forEach(index => { centerPosition.add(this.coins[index].position); }); centerPosition.divideScalar(nearbyCoinIndices.length + 1); // Mark coins for merging nearbyCoinIndices.forEach(index => { const movingCoin = this.coins[index]; movingCoin.isMoving = true; movingCoin.targetPosition = centerPosition; coinsToRemove.add(index); }); // Set up the main coin for merging coin.isMoving = true; coin.targetPosition = centerPosition; coinsToRemove.add(i); // Create merged coin at center // Create merged coin at center const mergedValue = (nearbyCoinIndices.length + 1) * coin.value; const mergedSize = coin.size * 1.5; // Make merged coin larger const coinAspectRatio = 13/16; // From original coin dimensions const mergedGeometry = new THREE.PlaneGeometry( mergedSize * coinAspectRatio, mergedSize ); const mergedCoin = new THREE.Mesh(mergedGeometry, this.coinMaterial.clone()); mergedCoin.position.copy(centerPosition); mergedCoin.position.z = 1; mergedCoin.rotationSpeed = -0.05; // Negative value for opposite rotation mergedCoin.value = mergedValue; mergedCoin.size = mergedSize; this.coins.push(mergedCoin); this.scene.add(mergedCoin); } } // Update all coins this.coins.forEach((coin, index) => { // Rotate all coins coin.rotation.z += coin.rotationSpeed; if (coin.isMoving && coin.targetPosition) { // Handle merging movement const direction = new THREE.Vector3() .subVectors(coin.targetPosition, coin.position) .normalize(); coin.position.add( direction.multiplyScalar(this.COIN_ATTRACTION_SPEED) ); if (coin.position.distanceTo(coin.targetPosition) < 0.1) { coin.isMoving = false; coin.targetPosition = null; } } else if (!coinsToRemove.has(index)) { // Check if coin should be attracted to player if (player && player.mesh) { const distanceToPlayer = coin.position.distanceTo(player.mesh.position); if (distanceToPlayer < this.COIN_PLAYER_ATTRACTION_RADIUS) { // Move towards player const direction = new THREE.Vector3() .subVectors(player.mesh.position, coin.position) .normalize(); coin.position.add( direction.multiplyScalar(this.COIN_PLAYER_ATTRACTION_SPEED) ); playerAttractedCoins.add(index); } } // Only handle regular gravitation if not being attracted to player if (!playerAttractedCoins.has(index) && gravitatingCoins.has(index)) { // Handle gravitation towards other coins let gravitationCenter = new THREE.Vector3(); let nearbyCount = 0; // Find average position of nearby coins this.coins.forEach((otherCoin, otherIndex) => { if (index !== otherIndex && !coinsToRemove.has(otherIndex)) { const distance = coin.position.distanceTo(otherCoin.position); if (distance < this.COIN_GRAVITATE_RADIUS) { gravitationCenter.add(otherCoin.position); nearbyCount++; } } }); if (nearbyCount > 0) { // Calculate center point of nearby coins gravitationCenter.divideScalar(nearbyCount); // Move towards center const direction = new THREE.Vector3() .subVectors(gravitationCenter, coin.position) .normalize(); coin.position.add( direction.multiplyScalar(this.COIN_GRAVITATION_SPEED) ); } } } }); // Remove merged coins if (coinsToRemove.size > 0) { // Convert Set to Array and sort in descending order const indicesToRemove = Array.from(coinsToRemove).sort((a, b) => b - a); indicesToRemove.forEach(index => { const coin = this.coins[index]; this.scene.remove(coin); coin.geometry.dispose(); coin.material.dispose(); this.coins.splice(index, 1); }); } } cleanup() { // Clean up enemies with null check this.enemies.forEach(enemy => { if (enemy && typeof enemy.cleanup === 'function') { enemy.cleanup(); } }); // Clean up boss if (this.boss) { this.boss.cleanup(); this.boss = null; } this.enemies = []; // Clean up any remaining enemy projectiles this.enemyProjectiles.forEach(projectile => { this.scene.remove(projectile); projectile.geometry.dispose(); projectile.material.dispose(); }); this.enemyProjectiles = []; // Clean up coins this.coins.forEach(coin => { this.scene.remove(coin); coin.geometry.dispose(); coin.material.dispose(); }); this.coins = []; } // Helper method to check collision between a point and bounds checkCollision(point, bounds) { return point.x >= bounds.left && point.x <= bounds.right && point.y >= bounds.bottom && point.y <= bounds.top; } // Method to check collision between enemies/projectiles and player checkPlayerCollision(player) { if (!player?.mesh?.position) return false; const collisionRadius = 0.5; // Collision threshold for player let isHit = false; const PROJECTILE_DAMAGE = 10; // Damage per projectile hit const ENEMY_CONTACT_DAMAGE = 20; // Damage from touching enemies const BOSS_CONTACT_DAMAGE = 30; // Damage from touching boss const FIRE_BREATH_DAMAGE = 15; // Damage from fire breath per hit // Check enemy collisions this.enemies.forEach(enemy => { if (enemy && enemy.mesh && player.mesh) { const distance = enemy.mesh.position.distanceTo(player.mesh.position); if (distance < collisionRadius * 1.5) { // Slightly larger radius for enemy contact isHit = true; player.takeDamage(ENEMY_CONTACT_DAMAGE); } } }); // Check boss collision if (this.isBossFight && this.boss && this.boss.mesh && player.mesh) { const distance = this.boss.mesh.position.distanceTo(player.mesh.position); if (distance < collisionRadius * 2.5) { // Larger radius for boss isHit = true; player.takeDamage(BOSS_CONTACT_DAMAGE); } } // Check coin collection const coinsToCollect = []; this.coins.forEach((coin, index) => { const distance = coin.position.distanceTo(player.mesh.position); if (distance < collisionRadius) { coinsToCollect.push({index, value: coin.value || 1}); } }); // Remove collected coins coinsToCollect.reverse().forEach(({index, value}) => { const coin = this.coins[index]; this.scene.remove(coin); coin.geometry.dispose(); coin.material.dispose(); this.coins.splice(index, 1); // Trigger collection effect with coin value if (player.onCoinCollected) { for (let i = 0; i < value; i++) { player.onCoinCollected(); // Call once per coin value } } }); // Check enemy projectile collisions with player const projectilesToRemove = []; this.enemyProjectiles.forEach((projectile, index) => { if (player && player.mesh) { const distance = projectile.position.distanceTo(player.mesh.position); if (distance < collisionRadius) { projectilesToRemove.push(index); isHit = true; // Apply damage if player is not invulnerable if (!player.isInvulnerable) { const isDead = player.takeDamage(PROJECTILE_DAMAGE); // Create hit effect at collision point if (window.threeScene?.projectileManager) { window.threeScene.projectileManager.createHitEffect(projectile.position); } // Check if player is dead if (isDead) { console.log('Player defeated!'); // Here you could add game over logic } } } } }); // Check fire breath collisions if boss exists and is active if (this.isBossFight && this.boss && this.boss.fireBreathActive) { this.boss.fireParticles.forEach(particle => { if (particle && particle.isFireBreath && player && player.mesh) { const distance = particle.position.distanceTo(player.mesh.position); if (distance < (collisionRadius + particle.collisionRadius)) { isHit = true; player.takeDamage(FIRE_BREATH_DAMAGE); } } }); } // Remove collided projectiles projectilesToRemove.reverse().forEach(index => { const projectile = this.enemyProjectiles[index]; this.scene.remove(projectile); projectile.geometry.dispose(); projectile.material.dispose(); this.enemyProjectiles.splice(index, 1); }); return isHit; } }