import * as THREE from 'three'; import { GLTFLoader } from 'three/addons/loaders/GLTFLoader.js'; import { scene } from 'renderer'; // Assuming 'scene' is exported from renderer.js import { state } from 'state'; // To potentially access player position later import { playSound } from 'audio'; // Import playSound using import map alias import { ASSETS, ENEMY_SETTINGS, WORLD_SETTINGS } from 'config'; // Import config values // const ENEMY_MODEL_URL = 'https://play.rosebud.ai/assets/quad_shell.glb?7PI3'; // Moved to config: ASSETS.ENEMY_MODEL_URL export class Enemy { constructor(physicsSystem, initialPosition = new THREE.Vector3(0, 1, -10)) { this.physics = physicsSystem; this.model = null; this.mixer = null; this.animationActions = {}; this.activeActionName = null; this.clock = new THREE.Clock(); this.targetPosition = new THREE.Vector3(); // this.speed = 2; // General movement speed - now ENEMY_SETTINGS.WALK_SPEED or ENEMY_SETTINGS.RUN_SPEED this.walkSpeed = ENEMY_SETTINGS.WALK_SPEED; this.runSpeed = ENEMY_SETTINGS.RUN_SPEED; this.chaseDistanceThreshold = ENEMY_SETTINGS.CHASE_DISTANCE; this.attackDistanceThreshold = ENEMY_SETTINGS.ATTACK_DISTANCE; this.attackCooldown = ENEMY_SETTINGS.ATTACK_COOLDOWN; this.currentAttackCooldown = 0; // Timer for cooldown this.colliderRadius = ENEMY_SETTINGS.COLLIDER_RADIUS; // The collider's center Y should be its radius above the ground (y=0) // if the model's pivot is at its base. // If initialPosition.y is intended as ground level, then collider's center is radius above it. // Assuming initialPosition.y is the desired y-coordinate for the *base* of the enemy. const colliderCenterY = initialPosition.y + this.colliderRadius; const colliderPos = new THREE.Vector3(initialPosition.x, colliderCenterY, initialPosition.z); this.collider = new THREE.Sphere(colliderPos, this.colliderRadius); this.velocity = new THREE.Vector3(); this.onFloor = false; this._isAngry = false; // Internal state for anger this.playedAlarmSound = false; // Flag to ensure alarm sound plays only once this.health = ENEMY_SETTINGS.MAX_HEALTH; this.isDead = false; // To prevent multiple death calls and for cleanup this.markForRemoval = false; // Flag for main.js to remove this enemy this.hasAppliedDamageThisAttack = false; // Flag to track if damage was applied in current attack anim // Neutral state behavior this.neutralState = 'idle'; // 'idle' or 'walking' this.neutralStateTimer = 0; this.neutralStateDuration = Math.random() * (ENEMY_SETTINGS.NEUTRAL_STATE_DURATION_MAX - ENEMY_SETTINGS.NEUTRAL_STATE_DURATION_MIN) + ENEMY_SETTINGS.NEUTRAL_STATE_DURATION_MIN; this.walkTargetPosition = new THREE.Vector3(); this.stateTransitionCooldown = 0; // Timer to prevent rapid state switching (e.g., chase <-> idle) this.MIN_STATE_TRANSITION_TIME = ENEMY_SETTINGS.MIN_STATE_TRANSITION_TIME; this.hitSparkParticles = []; // For storing hit spark meshes this.deathSparkParticles = []; // For storing death spark meshes this.isPerformingLook = false; // Flag to manage 'Look' animation sequence this.MIN_LOOK_COOLDOWN = ENEMY_SETTINGS.LOOK_ANIM_COOLDOWN_MIN; this.MAX_LOOK_COOLDOWN = ENEMY_SETTINGS.LOOK_ANIM_COOLDOWN_MAX; this.lookAnimationCooldown = THREE.MathUtils.randFloat(this.MIN_LOOK_COOLDOWN, this.MAX_LOOK_COOLDOWN); // Time until next look if (this.physics) { this.physics.addEnemy(this); } else { console.warn("Enemy created without a physics system."); } this.loadModel(); // Position will be set by physics initially } // Getter and Setter for isAngry to control sound playback get isAngry() { return this._isAngry; } set isAngry(value) { if (this._isAngry === value) return; // No change this._isAngry = value; if (this._isAngry && !this.playedAlarmSound && !this.isDead) { playSound('enemy_alarm', 0.7); this.playedAlarmSound = true; } // If becoming not angry, reset the alarm sound flag (optional, depends on desired behavior) // if (!this._isAngry) { // this.playedAlarmSound = false; // } } loadModel() { const loader = new GLTFLoader(); loader.load(ASSETS.ENEMY_MODEL_URL, (gltf) => { this.model = gltf.scene; // Initial position is set by the collider, model will sync in update() this.model.scale.set(ENEMY_SETTINGS.MODEL_SCALE, ENEMY_SETTINGS.MODEL_SCALE, ENEMY_SETTINGS.MODEL_SCALE); this.model.traverse((child) => { if (child.isMesh) { child.castShadow = true; child.receiveShadow = true; // Optional: Change material if needed // child.material = new THREE.MeshStandardMaterial({ color: 0xff0000 }); } }); scene.add(this.model); // Animation setup if (gltf.animations && gltf.animations.length) { this.mixer = new THREE.AnimationMixer(this.model); gltf.animations.forEach((clip) => { const action = this.mixer.clipAction(clip); this.animationActions[clip.name] = action; // Default properties for animations if (['Walk', 'Run', 'Idle', 'Look'].includes(clip.name)) { action.setLoop(THREE.LoopRepeat); } else { action.setLoop(THREE.LoopOnce); action.clampWhenFinished = true; // Ensure non-looping anims hold last frame } }); // Ensure 'TurnOff' specifically clamps when finished for the lingering effect if (this.animationActions['TurnOff']) { this.animationActions['TurnOff'].clampWhenFinished = true; } this.playAnimation('Idle'); // Start with Idle animation } console.log('Enemy model loaded and added to scene with animations.'); }, undefined, (error) => { console.error('Error loading enemy model:', error); }); } // Removed extra closing brace here playAnimation(name, loop = THREE.LoopRepeat, crossFadeDuration = 0.3) { if (!this.mixer || !this.animationActions[name]) { // console.warn(`Animation action "${name}" not found for enemy.`); return; } const newActionToPlay = this.animationActions[name]; const currentActiveAnimAction = this.activeActionName ? this.animationActions[this.activeActionName] : null; if (currentActiveAnimAction === newActionToPlay) { // It's the same animation. if (newActionToPlay.isRunning() && newActionToPlay.loop === loop) { // Already running with the correct loop mode and type. Do nothing. return; } // Not running (e.g. finished LoopOnce) or loop mode needs to change. newActionToPlay.reset(); // Reset to play from start or ensure fresh state newActionToPlay.setLoop(loop); if (!newActionToPlay.isRunning()) { newActionToPlay.play(); } // activeActionName is already correct. No crossfade needed. return; } // Transitioning to a different animation. newActionToPlay.reset(); newActionToPlay.setLoop(loop); newActionToPlay.play(); if (currentActiveAnimAction) { currentActiveAnimAction.crossFadeTo(newActionToPlay, crossFadeDuration, true); } this.activeActionName = name; } updateNeutralBehavior(dt) { this.neutralStateTimer -= dt; if (this.neutralStateTimer <= 0) { this.neutralStateTimer = Math.random() * 5 + 3; // Reset timer 3-8s const randomChoice = Math.random(); if (randomChoice < 0.6) { // 60% chance to walk this.neutralState = 'walking'; // Pick a random point within a certain radius of current position // const wanderRadius = 10; // Moved to config: ENEMY_SETTINGS.WANDER_RADIUS this.walkTargetPosition.set( this.collider.center.x + THREE.MathUtils.randFloatSpread(ENEMY_SETTINGS.WANDER_RADIUS), this.collider.center.y, // Keep Y the same for ground movement this.collider.center.z + THREE.MathUtils.randFloatSpread(ENEMY_SETTINGS.WANDER_RADIUS) ); // Clamp walkTargetPosition to be within map bounds // Assuming GROUND_PLANE_SIZE is accessible or passed somehow. For now, hardcoding a common value. // It would be better to get this from main.js or physics system. const mapBoundary = WORLD_SETTINGS.GROUND_PLANE_SIZE / 2 - this.colliderRadius; this.walkTargetPosition.x = THREE.MathUtils.clamp(this.walkTargetPosition.x, -mapBoundary, mapBoundary); this.walkTargetPosition.z = THREE.MathUtils.clamp(this.walkTargetPosition.z, -mapBoundary, mapBoundary); } else { // 40% chance to idle this.neutralState = 'idle'; } } if (this.neutralState === 'walking') { const direction = new THREE.Vector3(); direction.subVectors(this.walkTargetPosition, this.collider.center); direction.y = 0; // Move on XZ plane const distanceToWalkTargetSq = direction.lengthSq(); if (distanceToWalkTargetSq > 0.25 * 0.25) { // If not very close to target (squared distance check) direction.normalize(); this.velocity.x = direction.x * this.walkSpeed; this.velocity.z = direction.z * this.walkSpeed; // Only play Walk if actually moving significantly if (Math.abs(this.velocity.x) > 0.01 || Math.abs(this.velocity.z) > 0.01) { this.playAnimation('Walk'); const lookAtPos = new THREE.Vector3(this.walkTargetPosition.x, this.model.position.y, this.walkTargetPosition.z); this.model.lookAt(lookAtPos); } else { // If velocity is near zero (e.g. stuck), switch to idle to avoid walking in place this.playAnimation('Idle'); this.velocity.x = 0; // Ensure velocity is reset this.velocity.z = 0; } } else { // Reached target or very close this.neutralState = 'idle'; // Switch to idle this.neutralStateTimer = Math.random() * 2 + 1; // Idle for a short time this.velocity.x = 0; // Ensure velocity is reset this.velocity.z = 0; this.playAnimation('Idle'); // Ensure idle animation plays } } else { // 'idle' state this.velocity.x = 0; this.velocity.z = 0; this.lookAnimationCooldown -= dt; if (this.isPerformingLook) { // If we are in the 'Look' animation, the mixer is updating it. // The 'finished' event of the 'Look' action will set isPerformingLook to false // and transition back to 'Idle'. We don't need to do much here. } else { // Not currently performing 'Look'. Play 'Idle'. this.playAnimation('Idle'); // Check if it's time to 'Look' if (this.lookAnimationCooldown <= 0 && this.activeActionName === 'Idle' && this.animationActions['Look']) { this.isPerformingLook = true; this.playAnimation('Look', THREE.LoopOnce); const lookAction = this.animationActions['Look']; const onLookFinish = (event) => { if (event.action === lookAction && this.mixer) { this.mixer.removeEventListener('finished', onLookFinish); // Only transition back to Idle if we were indeed Looking AND still in a neutral idle state. if (this.isPerformingLook && this.neutralState === 'idle' && !this.isAngry) { // Smoothly transition back to Idle instead of an instant switch. // The playAnimation method handles crossfading. // We need to ensure 'Look' is the activeActionName before calling playAnimation for Idle. if (this.activeActionName === 'Look') { this.playAnimation('Idle', THREE.LoopRepeat, 0.2); // Use a short crossfade } else { // If something else took over (e.g. angry), don't force Idle here. // Just ensure 'Idle' is the fallback if no other state dictates an animation. if (!this.isAngry && this.neutralState === 'idle' && this.activeActionName !== 'Idle') { this.playAnimation('Idle', THREE.LoopRepeat, 0.2); } } } // Always reset these regardless of whether Idle was played, to allow next look cycle this.isPerformingLook = false; this.lookAnimationCooldown = THREE.MathUtils.randFloat(this.MIN_LOOK_COOLDOWN, this.MAX_LOOK_COOLDOWN); } }; if (this.mixer) { this.mixer.addEventListener('finished', onLookFinish); } else { // No mixer, cannot properly handle 'Look' animation finishing. this.isPerformingLook = false; this.lookAnimationCooldown = THREE.MathUtils.randFloat(this.MIN_LOOK_COOLDOWN, this.MAX_LOOK_COOLDOWN); } } } } } update(dt, playerPosition) { if (!this.model || !this.collider || !this.mixer) return; // The model's y position should be the collider's center y minus its radius, // if the model's pivot point is at its visual base. const modelYPosition = this.collider.center.y - this.colliderRadius; this.model.position.set(this.collider.center.x, modelYPosition, this.collider.center.z); this.mixer.update(dt); // Update attack cooldown if (this.currentAttackCooldown > 0) { this.currentAttackCooldown -= dt; } if (this.stateTransitionCooldown > 0) { this.stateTransitionCooldown -= dt; } // Update spark particles this.updateSparkParticles(dt, this.hitSparkParticles); this.updateSparkParticles(dt, this.deathSparkParticles); if (this.isAngry) { // Uses the getter if (playerPosition) { this.targetPosition.copy(playerPosition); const distanceToPlayer = this.collider.center.distanceTo(this.targetPosition); const direction = new THREE.Vector3(); direction.subVectors(this.targetPosition, this.collider.center); direction.y = 0; const lookAtPosition = new THREE.Vector3(this.targetPosition.x, this.model.position.y, this.targetPosition.z); // Always look at the player when angry, unless mid-attack animation that shouldn't turn. // For most of our animations (Attack, Run, Idle), looking at player is fine. if (this.activeActionName !== 'Attack' || (this.animationActions['Attack'] && !this.animationActions['Attack'].isRunning())) { this.model.lookAt(lookAtPosition); } // Attack Logic: Highest priority if conditions met if (distanceToPlayer <= this.attackDistanceThreshold && this.currentAttackCooldown <= 0) { this.velocity.x = 0; this.velocity.z = 0; this.playAnimation('Attack', THREE.LoopOnce); this.currentAttackCooldown = this.attackCooldown; this.stateTransitionCooldown = this.MIN_STATE_TRANSITION_TIME; // Prevent immediate switch after attack this.hasAppliedDamageThisAttack = false; // Reset before starting new attack animation // console.log("Enemy: Attacking!"); // Chase Logic: If not attacking, and in chase range } else if ((this.activeActionName !== 'Attack' || !this.animationActions['Attack']?.isRunning()) && distanceToPlayer > this.attackDistanceThreshold && distanceToPlayer < this.chaseDistanceThreshold) { if (this.activeActionName === 'Run') { // If already running, continue if (direction.lengthSq() > 0.01) direction.normalize(); // Only normalize if there's a significant direction else direction.set(0,0,0); // Prevent NaN issues if direction is zero vector this.velocity.x = direction.x * this.runSpeed; this.velocity.z = direction.z * this.runSpeed; // Only play Run if actually moving significantly if (Math.abs(this.velocity.x) > 0.01 || Math.abs(this.velocity.z) > 0.01) { this.playAnimation('Run'); } else { // If velocity is near zero (e.g. stuck or player very close and slightly behind), switch to idle. this.playAnimation('Idle'); this.velocity.x = 0; // Ensure velocity is reset this.velocity.z = 0; } } else { // Not running? Try to switch to Run. if (this.stateTransitionCooldown <= 0) { // Cooldown allows switching if (direction.lengthSq() > 0.01) direction.normalize(); else direction.set(0,0,0); this.velocity.x = direction.x * this.runSpeed; this.velocity.z = direction.z * this.runSpeed; if (Math.abs(this.velocity.x) > 0.01 || Math.abs(this.velocity.z) > 0.01) { this.playAnimation('Run'); this.stateTransitionCooldown = this.MIN_STATE_TRANSITION_TIME; // Set cooldown for *starting* Run } else { this.playAnimation('Idle'); this.velocity.x = 0; this.velocity.z = 0; } } else { // Cooldown is active, cannot switch to Run from another state (e.g. Idle). // Ensure velocity is 0 if it's not an attack. this.velocity.x = 0; this.velocity.z = 0; // If not attacking and not already idling, play idle. // This handles cases where cooldown prevents Run, but current anim isn't Idle. if (this.activeActionName !== 'Idle' && (this.activeActionName !== 'Attack' || !this.animationActions['Attack']?.isRunning())) { this.playAnimation('Idle'); } } } // console.log("Enemy: Chasing!"); // Idle/Wait Logic: If not attacking and not in chase conditions } else if (this.activeActionName !== 'Attack' || !this.animationActions['Attack']?.isRunning()) { if (this.activeActionName === 'Idle') { // If already idling, continue this.velocity.x = 0; this.velocity.z = 0; this.playAnimation('Idle'); // Ensure idle animation plays } else { // Not idling? Try to switch to Idle. if (this.stateTransitionCooldown <= 0) { // Cooldown allows switching this.velocity.x = 0; this.velocity.z = 0; this.playAnimation('Idle'); this.stateTransitionCooldown = this.MIN_STATE_TRANSITION_TIME * 0.5; // Set cooldown for *starting* Idle } else { // Cooldown is active. Ensure velocity is zero. // The animation might still be Run if it just transitioned out of chase range. // This allows the Run animation to blend out if crossfade is active. // If it's stuck in Run visually but should be idle, it means the stateTransitionCooldown // from starting Run is still active. We must ensure velocity is zero. this.velocity.x = 0; this.velocity.z = 0; // If the current animation is a movement one but velocity is zero (due to cooldown), // and not an attack, it's safer to force Idle if it's not already trying to play Idle. if ((this.activeActionName === 'Run' || this.activeActionName === 'Walk') && this.activeActionName !== 'Idle') { // Don't force Idle immediately if it's already fading out of Run/Walk. // This can be tricky; for now, just ensuring velocity is zero is key. // A more robust solution might involve checking if a crossfade is active. } } } // console.log(`Enemy: Idle/Waiting. Distance: ${distanceToPlayer.toFixed(2)}, Cooldown: ${this.currentAttackCooldown.toFixed(2)}, TransitionCD: ${this.stateTransitionCooldown.toFixed(2)}`); } // De-aggro Logic: If player gets too far and enemy is not in the middle of an attack if (distanceToPlayer >= this.chaseDistanceThreshold && (this.activeActionName !== 'Attack' || !this.animationActions['Attack']?.isRunning())) { // Player too far and not in middle of attack, stop chasing this.isAngry = false; // Uses the setter this.neutralStateTimer = 0; // Force neutral behavior re-evaluation // console.log("Enemy: Player out of range, becoming neutral."); } } else { // No player position available this.isAngry = false; // Uses the setter this.neutralStateTimer = 0; // console.log("Enemy: No player target, becoming neutral."); } } else { // Not angry this.updateNeutralBehavior(dt); } } takeDamage(amount) { if (!this.model || this.isDead) return; // Can't take damage if no model or already dead this.health -= amount; this.isAngry = true; // Uses the setter, which will trigger the alarm sound if appropriate this.playAnimation('Hit', THREE.LoopOnce); this.createSparks(ENEMY_SETTINGS.HIT_SPARK_COUNT, this.hitSparkParticles, ENEMY_SETTINGS.HIT_SPARK_SPEED_MULTIPLIER, ENEMY_SETTINGS.HIT_SPARK_COLOR); playSound('enemy_hit', 0.5); // Play enemy hit sound console.log(`Enemy took ${amount} damage, health: ${this.health}`); if (this.health <= 0) { // No need to check isDead again here as die() handles it this.die(); } } die() { if (this.isDead) return; // Already dead this.isDead = true; console.log("Enemy died, playing TurnOff animation."); this.isAngry = false; // Uses the setter this.velocity.set(0, 0, 0); this.playAnimation('TurnOff', THREE.LoopOnce); playSound('enemy_death', 0.8); // Play enemy death sound with higher volume this.createSparks(ENEMY_SETTINGS.DEATH_SPARK_COUNT, this.deathSparkParticles, ENEMY_SETTINGS.DEATH_SPARK_SPEED_MULTIPLIER, ENEMY_SETTINGS.DEATH_SPARK_COLOR, true); // Disable further game logic updates for this enemy immediately // The physics body and model will be removed after animation. const originalUpdate = this.update; this.update = (dt, playerPosition) => { // Only update mixer while dying if (this.mixer) { this.mixer.update(dt); } // CRITICAL: Continue updating death sparks during the death animation this.updateSparkParticles(dt, this.deathSparkParticles); // Optionally, update hit sparks too if they could be lingering, though less critical here this.updateSparkParticles(dt, this.hitSparkParticles); }; const onAnimationFinish = (event) => { if (this.mixer && event.action === this.animationActions['TurnOff']) { console.log("TurnOff animation finished. Starting linger timer."); this.mixer.removeEventListener('finished', onAnimationFinish); // Remove listener to prevent multiple calls // Linger for a bit to let sparks play out setTimeout(() => { console.log("Linger timer expired. Cleaning up enemy."); if (this.model && this.model.parent) { scene.remove(this.model); this.model.traverse(child => { if (child.isMesh) { child.geometry.dispose(); if (child.material.isMaterial) { this.cleanMaterial(child.material); } else if (Array.isArray(child.material)) { child.material.forEach(this.cleanMaterial); } } }); } // Clean up spark particles more robustly this.clearAllSparks(); if (this.physics) { this.physics.removeEnemy(this); } this.markForRemoval = true; }, 1500); // Linger for 1.5 seconds } }; if (this.mixer && this.animationActions['TurnOff']) { this.mixer.addEventListener('finished', onAnimationFinish); } else { // If no animation/mixer, clean up immediately console.warn("No TurnOff animation or mixer found for enemy, cleaning up immediately."); if (this.model && this.model.parent) { scene.remove(this.model); } if (this.physics) { this.physics.removeEnemy(this); } this.markForRemoval = true; } } // Helper to dispose materials and their textures cleanMaterial(material) { material.dispose(); for (const key of Object.keys(material)) { const value = material[key]; if (value && typeof value === 'object' && 'isTexture' in value) { value.dispose(); } // Closes if statement } // Closes for loop } // Closes cleanMaterial method clearAllSparks() { const clearList = (list) => { list.forEach(p => { if (p.mesh.parent) scene.remove(p.mesh); // sparkGeometry is shared, so don't dispose it here. // Only dispose the cloned material. if (p.mesh.material) p.mesh.material.dispose(); }); list.length = 0; }; clearList(this.hitSparkParticles); clearList(this.deathSparkParticles); } // This correctly closes the clearAllSparks method createSparks(count, particleArray, speedMultiplier = 1, color = 0xffff00, isDeathSpark = false) { // Default color yellow if (!this.model) return; // Using thin boxes for a more "streaky" spark. For death, they are slightly larger. // Increase spark dimensions for a bigger effect const sparkWidth = isDeathSpark ? 0.05 : 0.03; // Doubled width const sparkHeight = isDeathSpark ? 0.24 : 0.16; // Doubled height const sparkDepth = isDeathSpark ? 0.05 : 0.03; // Doubled depth const sparkGeometry = new THREE.BoxGeometry(sparkWidth, sparkHeight, sparkDepth); // Slightly increased emissive intensity for brighter, larger sparks const sparkMaterial = new THREE.MeshBasicMaterial({ color: color, emissive: color, emissiveIntensity: 3.0 }); for (let i = 0; i < count; i++) { const sparkMesh = new THREE.Mesh(sparkGeometry, sparkMaterial.clone()); sparkMesh.position.copy(this.model.position); // Slightly increased offset radius for larger sparks const offsetRadius = isDeathSpark ? 0.5 : 0.3; sparkMesh.position.x += THREE.MathUtils.randFloatSpread(offsetRadius); sparkMesh.position.y += THREE.MathUtils.randFloatSpread(offsetRadius) + (this.colliderRadius * 0.6); // Bias spawn point slightly higher sparkMesh.position.z += THREE.MathUtils.randFloatSpread(offsetRadius); scene.add(sparkMesh); const baseSpeed = isDeathSpark ? 3.5 : 2.5; // Slightly increased base speed const upwardBias = isDeathSpark ? 1.8 * speedMultiplier : 0.9 * speedMultiplier; let velocity = new THREE.Vector3( THREE.MathUtils.randFloatSpread(baseSpeed * speedMultiplier), THREE.MathUtils.randFloatSpread(baseSpeed * speedMultiplier) + upwardBias, THREE.MathUtils.randFloatSpread(baseSpeed * speedMultiplier) ); // For death sparks, add a bit of outward radial velocity from the enemy's core if (isDeathSpark) { const radialDir = new THREE.Vector3().subVectors(sparkMesh.position, this.model.position).normalize(); velocity.addScaledVector(radialDir, speedMultiplier * 0.7); // Stronger outward push } const life = (Math.random() * (isDeathSpark ? 0.45 : 0.35)) + (isDeathSpark ? 0.35 : 0.25); // Slightly longer life particleArray.push({ mesh: sparkMesh, velocity: velocity, life: life, initialLife: life, initialRotation: new THREE.Euler(Math.random() * Math.PI, Math.random() * Math.PI, Math.random() * Math.PI), isDeathSpark: isDeathSpark, // Store if it's a death spark for custom animation rotationSpeed: new THREE.Vector3( // Random rotation speed for each spark THREE.MathUtils.randFloat(1, 5) * (isDeathSpark ? 2 : 1), // Death sparks rotate faster THREE.MathUtils.randFloat(1, 5) * (isDeathSpark ? 2 : 1), THREE.MathUtils.randFloat(1, 5) * (isDeathSpark ? 2 : 1) ) }); sparkMesh.rotation.copy(particleArray[particleArray.length-1].initialRotation); } } updateSparkParticles(dt, particleArray) { for (let i = particleArray.length - 1; i >= 0; i--) { const particle = particleArray[i]; particle.life -= dt; if (particle.life <= 0) { if (particle.mesh.parent) scene.remove(particle.mesh); // sparkGeometry is shared. Dispose only the cloned material. if (particle.mesh.material) particle.mesh.material.dispose(); particleArray.splice(i, 1); } else { particle.mesh.position.addScaledVector(particle.velocity, dt); particle.velocity.y -= (this.physics?.GRAVITY || 9.8) * dt * 0.2; // Slightly more gravity effect on sparks // Animate sparks with their individual rotation speeds // Ensure rotationSpeed exists before trying to use it if (particle.rotationSpeed) { particle.mesh.rotation.x += particle.rotationSpeed.x * dt; particle.mesh.rotation.y += particle.rotationSpeed.y * dt; particle.mesh.rotation.z += particle.rotationSpeed.z * dt; } // Fade out and shrink const lifeRatio = Math.max(0, particle.life / particle.initialLife); if (particle.mesh.material.isMaterial) { particle.mesh.material.opacity = lifeRatio; particle.mesh.material.transparent = true; } // Shrink sparks as they die const scale = lifeRatio * 0.8 + 0.2; // Shrink to 20% of original size particle.mesh.scale.set(scale, scale, scale); } } } }