import * as THREE from 'three'; import { RoomLayoutGenerator } from 'RoomLayoutGenerator'; import { WeaponManager } from 'WeaponManager'; import { AudioManager } from 'AudioManager'; import { PowerUpManager } from 'PowerUpManager'; import { EnemyManager } from 'EnemyManager'; import { GLTFLoader } from 'three/addons/loaders/GLTFLoader.js'; import { AnimationMixer } from 'three'; import { SceneCreator } from 'SceneCreator'; export class ThreeScene { constructor(mountRef) { this.mountRef = mountRef; this.scene = new THREE.Scene(); this.isPaused = false; // Scene setup this.camera = new THREE.PerspectiveCamera(75, window.innerWidth / window.innerHeight, 0.1, 1000); this.renderer = new THREE.WebGLRenderer({ alpha: false, antialias: true }); // Euler angles for camera rotation this.euler = new THREE.Euler(0, 0, 0, 'YXZ'); // YXZ order prevents gimbal lock for FPS controls // Player state this.player = { position: new THREE.Vector3(0, 1.8, 0), velocity: new THREE.Vector3(), onGround: true, health: 100, armor: 0 }; // Audio setup this.audioManager = null; // Will be initialized later this.powerUpManager = null; // Will be initialized later this.enemyManager = null; // Will be initialized later // Enemy models this.enemyModel = null; this.enemyDeathModel = null; this.enemyPath = []; // Path points for enemy to follow this.enemyPathIndex = 0; // Current target index in path this.enemyMoveSpeed = 0.015; // Reduced speed for better animation matching this.enemyMixer = null; // Animation mixer for enemy model this.enemyDeathMixer = null; // Animation mixer for enemy death model this.enemyClips = []; // Animation clips this.enemyAnimations = {}; // Named animations this.enemyDeathAnimations = {}; // Named death animations // Controls state this.keys = { forward: false, backward: false, left: false, right: false }; // Game settings this.moveSpeed = 0.12; // Slightly slower for better sense of weight this.gravity = 0.01; this.playerHeight = 1.8; // Consistent player height this.clock = new THREE.Clock(); } init() { // Initial setup this.renderer.setPixelRatio(window.devicePixelRatio); this.renderer.setClearColor(0x000000); this.mountRef.current.appendChild(this.renderer.domElement); this.handleResize(); window.addEventListener('resize', this.handleResize.bind(this)); // Setup controls this.setupControls(); // Create level this.createLevel(); // Initialize audio manager first this.audioManager = new AudioManager(this.camera); this.audioManager.init(); // Create and initialize the weapon manager with audio manager's listener this.weaponManager = new WeaponManager(this.scene, this.camera, this.audioManager.audioListener); this.weaponManager.createWeapons(); // Connect AudioManager to WeaponManager this.weaponManager.setAudioManager(this.audioManager); // Initialize power-up manager this.powerUpManager = new PowerUpManager(this.scene, this.player); this.powerUpManager.init(); // Connect AudioManager to PowerUpManager this.powerUpManager.setAudioManager(this.audioManager); // Initialize enemy manager this.enemyManager = new EnemyManager(this.scene, this.player); this.enemyManager.init(); // Load enemy model this.loadEnemyModel(); // Add camera to scene to ensure weapon models are rendered this.scene.add(this.camera); // Create player feet models this.createPlayerFeet(); // Position camera at player height this.camera.position.y = this.player.position.y; // Weapon manager will use the audio manager's listener this.weaponManager.setupAudio(); this.clock.start(); this.animate(); return () => this.cleanup(); } // Player and weapon management methods setupControls() { // Keyboard controls document.addEventListener('keydown', (event) => { switch (event.code) { case 'KeyW': this.keys.forward = true; break; case 'KeyS': this.keys.backward = true; break; case 'KeyA': this.keys.left = true; break; case 'KeyD': this.keys.right = true; break; case 'KeyP': // Dispatch a custom event that App.js can listen for window.dispatchEvent(new CustomEvent('togglePause')); break; case 'Space': // Get camera direction for shooting const direction = new THREE.Vector3(); this.camera.getWorldDirection(direction); direction.normalize(); this.weaponManager.shoot(this.player.position, direction); break; case 'KeyR': this.weaponManager.reload(); break; } }); document.addEventListener('keyup', (event) => { switch (event.code) { case 'KeyW': this.keys.forward = false; break; case 'KeyS': this.keys.backward = false; break; case 'KeyA': this.keys.left = false; break; case 'KeyD': this.keys.right = false; break; } }); // Mouse look controls this.mountRef.current.addEventListener('click', () => { if (document.pointerLockElement !== this.mountRef.current) { this.mountRef.current.requestPointerLock(); } else { // Get camera direction for shooting const shootDirection = new THREE.Vector3(); this.camera.getWorldDirection(shootDirection); shootDirection.normalize(); this.weaponManager.shoot(this.player.position, shootDirection); } }); document.addEventListener('mousemove', (event) => { if (document.pointerLockElement === this.mountRef.current) { // Use Euler angles with proper rotation order for FPS camera // Horizontal rotation (yaw) this.euler.y -= event.movementX * 0.002; // Vertical rotation (pitch) with limits to prevent over-rotation // Moving mouse up should look up, down should look down this.euler.x -= event.movementY * 0.002; // Clamp the vertical rotation to prevent looking too far up or down this.euler.x = Math.max(-Math.PI/2 + 0.01, Math.min(Math.PI/2 - 0.01, this.euler.x)); // Apply the euler angles to the camera rotation this.camera.rotation.copy(this.euler); // Update player camera rotation for HUD this.player.cameraRotation = { y: this.euler.y }; } }); } createLevel() { // Initialize the SceneCreator this.sceneCreator = new SceneCreator(); // Create a procedural brick texture using SceneCreator const brickTexture = this.sceneCreator.createBrickTexture(); const wallMaterial = new THREE.MeshBasicMaterial({ map: brickTexture }); // Create ceiling texture const ceilingTexture = this.sceneCreator.createCeilingTexture(); const ceilingMaterial = new THREE.MeshBasicMaterial({ map: ceilingTexture, side: THREE.DoubleSide // Make the ceiling visible from both sides }); // Create floor texture const floorTexture = this.sceneCreator.createFloorTexture(); const floorMaterial = new THREE.MeshBasicMaterial({ map: floorTexture, side: THREE.DoubleSide }); // Get a single room from the RoomLayoutGenerator this.roomLayoutGenerator = new RoomLayoutGenerator(); this.rooms = this.roomLayoutGenerator.generateLayout(); // Create the single room using SceneCreator this.createSingleRoom(wallMaterial, floorMaterial, ceilingMaterial); // Position player in the center of the room this.player.position.set(0, this.playerHeight, 0); } /** * Creates a single room for the game */ createSingleRoom(wallMaterial, floorMaterial, ceilingMaterial) { // We'll keep the roomMeshes array for consistency with other code this.roomMeshes = []; const room = this.rooms[0]; // Prepare materials const materials = { wall: wallMaterial, floor: floorMaterial, ceiling: ceilingMaterial }; // Use SceneCreator to create the room const roomGroup = this.sceneCreator.createSingleRoom(room, materials); // Add room to scene this.scene.add(roomGroup); this.roomMeshes.push(roomGroup); } // Texture creation methods have been moved to SceneCreator // Removed createWeapons() since it's now managed by WeaponManager createPlayerFeet() { // Create feet models that will be visible when looking down this.feetModel = new THREE.Group(); // Create left foot const leftFootGeometry = new THREE.BoxGeometry(0.15, 0.1, 0.3); const footMaterial = new THREE.MeshBasicMaterial({ color: 0x333333 }); const leftFoot = new THREE.Mesh(leftFootGeometry, footMaterial); leftFoot.position.set(-0.15, -1.7, -0.1); this.feetModel.add(leftFoot); // Create right foot const rightFootGeometry = new THREE.BoxGeometry(0.15, 0.1, 0.3); const rightFoot = new THREE.Mesh(rightFootGeometry, footMaterial); rightFoot.position.set(0.15, -1.7, -0.1); this.feetModel.add(rightFoot); // Add to camera so feet move with player this.camera.add(this.feetModel); } handleResize() { const width = window.innerWidth; const height = window.innerHeight; const pixelRatio = window.devicePixelRatio; this.camera.aspect = width / height; this.camera.updateProjectionMatrix(); this.renderer.setSize(width, height); this.renderer.setPixelRatio(pixelRatio); this.camera.position.z = 5; } animate() { requestAnimationFrame(this.animate.bind(this)); // Skip game logic updates if paused if (this.isPaused) { // Still render the scene but don't update game state this.renderer.render(this.scene, this.camera); return; } const delta = this.clock.getDelta(); const elapsedTime = this.clock.getElapsedTime(); this.updatePlayerMovement(delta); // Check for player-enemy collision if (this.checkPlayerEnemyCollision()) { // Apply damage to player on collision this.handleEnemyCollision(); } // Weapon sway animation // Update weapon position and sway animation this.weaponManager.updateWeaponPosition(this.clock.getElapsedTime()); // Update feet visibility and animation based on camera pitch if (this.feetModel) { // Show feet only when looking down past a certain angle // Camera rotation.x is positive when looking down if (this.camera.rotation.x > 0.3) { this.feetModel.visible = true; // Animate feet slightly when moving if (this.player.velocity.length() > 0.05) { const walkCycle = Math.sin(this.clock.getElapsedTime() * 5); // Get left and right feet const leftFoot = this.feetModel.children[0]; const rightFoot = this.feetModel.children[1]; // Alternating foot movement leftFoot.position.y = -1.7 + Math.max(0, walkCycle * 0.1); rightFoot.position.y = -1.7 + Math.max(0, -walkCycle * 0.1); } } else { this.feetModel.visible = false; } } // Update bullet positions and check for collisions with enemy // Update bullets using the weapon manager this.weaponManager.updateBullets(delta); // Check for bullet-enemy collisions this.checkBulletEnemyCollisions(); // Update power-ups if (this.powerUpManager) { this.powerUpManager.update(delta); } // Update enemies if (this.enemyManager) { this.enemyManager.update(delta); } // Animate enemy model if it exists if (this.enemyModel) { this.animateEnemyModel(delta, elapsedTime); } // Update enemy death animation if playing if (this.enemyDeathMixer) { this.enemyDeathMixer.update(delta); } this.renderer.render(this.scene, this.camera); } updatePlayerMovement(delta) { // Get forward direction based on camera orientation const direction = new THREE.Vector3(); this.camera.getWorldDirection(direction); direction.y = 0; // Keep movement on the xz plane direction.normalize(); // Get right direction (perpendicular to forward direction) const right = new THREE.Vector3(-direction.z, 0, direction.x); // Calculate desired velocity based on input const targetVelocity = new THREE.Vector3(0, 0, 0); // Use absolute world directions for movement // This ensures WASD always move in the expected direction relative to camera view // Use consistent movement directions regardless of camera orientation const forward = direction.clone(); const backward = direction.clone().negate(); const rightDir = right.clone(); const leftDir = right.clone().negate(); if (this.keys.forward) { targetVelocity.add(forward.multiplyScalar(this.moveSpeed)); } if (this.keys.backward) { targetVelocity.add(backward.multiplyScalar(this.moveSpeed)); } if (this.keys.right) { targetVelocity.add(rightDir.multiplyScalar(this.moveSpeed)); } if (this.keys.left) { targetVelocity.add(leftDir.multiplyScalar(this.moveSpeed)); } // Normalize movement speed when moving diagonally to prevent faster diagonal movement if (targetVelocity.length() > this.moveSpeed) { targetVelocity.normalize().multiplyScalar(this.moveSpeed); } // Add slight acceleration/deceleration for smoother movement feel this.player.velocity.x = this.lerp(this.player.velocity.x, targetVelocity.x, 0.2); this.player.velocity.z = this.lerp(this.player.velocity.z, targetVelocity.z, 0.2); // Update player position with the smoothed velocity this.player.position.x += this.player.velocity.x; this.player.position.z += this.player.velocity.z; // Lock Y position to maintain consistent player height this.player.position.y = this.playerHeight; // Position camera at player position with more stability this.camera.position.copy(this.player.position); // Ensure camera rotation is always set from our euler angles this.camera.rotation.copy(this.euler); if (targetVelocity.length() > 0) { // Significantly reduce bob frequency and amplitude for more stability // Use a more realistic walking cadence (approx 2 steps per second) const stepFrequency = 3.5; // Lower for more stability const bobAmount = Math.sin(this.clock.getElapsedTime() * stepFrequency) * 0.008; // Much smaller amplitude // Only apply bob if player is actually moving at a reasonable speed // This prevents bobbing when barely moving if (targetVelocity.length() > this.moveSpeed * 0.5) { this.camera.position.y += bobAmount; } } } cleanup() { window.removeEventListener('resize', this.handleResize.bind(this)); document.removeEventListener('keydown', this.handleKeyDown); document.removeEventListener('keyup', this.handleKeyUp); document.removeEventListener('mousemove', this.handleMouseMove); // Release pointer lock if active if (document.pointerLockElement === this.mountRef.current) { document.exitPointerLock(); } // Clean up audio if (this.audioManager) { this.audioManager.cleanup(); } // Clean up power-ups if (this.powerUpManager) { this.powerUpManager.cleanup(); } // Clean up enemies if (this.enemyManager) { this.enemyManager.cleanup(); } this.mountRef.current.removeChild(this.renderer.domElement); this.renderer.dispose(); } /** * Loads the Enemy1 GLB model into the scene */ loadEnemyModel() { const gltfLoader = new GLTFLoader(); // Load enemy model gltfLoader.load( 'https://play.rosebud.ai/assets/Enemy1.glb?XFK3', (gltf) => { this.enemyModel = gltf.scene; // Scale the model this.enemyModel.scale.set(1.5, 1.5, 1.5); // Create a patrol path for the enemy this.createEnemyPath(); // Set the initial position to the first point in the path if (this.enemyPath.length > 0) { this.enemyModel.position.copy(this.enemyPath[0]); } else { console.warn('Enemy path is empty. Setting default position.'); this.enemyModel.position.set(10, 0, 10); } // Add the model to the scene this.scene.add(this.enemyModel); // Traverse the model to ensure materials render correctly this.enemyModel.traverse((child) => { if (child.isMesh) { child.castShadow = true; child.receiveShadow = true; // Ensure materials are properly set for rendering if (child.material) { child.material.side = THREE.DoubleSide; } } }); // Setup animation system if (gltf.animations && gltf.animations.length) { // Create an animation mixer for this model this.enemyMixer = new AnimationMixer(this.enemyModel); // Store the animations this.enemyClips = gltf.animations; // Create named references for each animation gltf.animations.forEach((clip) => { // Store the animation by name for easy access this.enemyAnimations[clip.name] = this.enemyMixer.clipAction(clip); console.log(`Found animation: ${clip.name}`); }); // If there's a walking animation, play it if (this.enemyAnimations['Walk']) { this.enemyAnimations['Walk'].play(); } else if (this.enemyAnimations['walk']) { this.enemyAnimations['walk'].play(); } else if (this.enemyClips.length > 0) { // If no walking animation found, play the first available animation const defaultAnimation = this.enemyMixer.clipAction(this.enemyClips[0]); defaultAnimation.play(); console.log(`Playing default animation: ${this.enemyClips[0].name}`); } } else { console.log('No animations found in the model'); } console.log('Enemy model loaded successfully'); }, (xhr) => { const loadingProgress = Math.floor((xhr.loaded / xhr.total) * 100); console.log(`Loading enemy model: ${loadingProgress}%`); }, (error) => { console.error('Error loading enemy model:', error); } ); // Load enemy death model gltfLoader.load( 'https://play.rosebud.ai/assets/Enemy1death.glb?RRR7', (gltf) => { this.enemyDeathModel = gltf.scene; // Scale the death model this.enemyDeathModel.scale.set(1.5, 1.5, 1.5); // Setup death animation if (gltf.animations && gltf.animations.length) { this.enemyDeathMixer = new THREE.AnimationMixer(this.enemyDeathModel); gltf.animations.forEach((clip) => { this.enemyDeathAnimations[clip.name] = this.enemyDeathMixer.clipAction(clip); console.log(`Found death animation: ${clip.name}`); }); } // Hide death model initially this.enemyDeathModel.visible = false; this.scene.add(this.enemyDeathModel); console.log('Enemy death model loaded successfully'); }, (xhr) => { console.log(`Loading enemy death model: ${Math.floor((xhr.loaded / xhr.total) * 100)}%`); }, (error) => { console.error('Error loading enemy death model:', error); } ); } // Helper functions for player state getPlayerAmmoState() { return this.weaponManager.getPlayerAmmoState(); } // Helper method for smooth interpolation (lerp) lerp(start, end, amount) { return (1 - amount) * start + amount * end; } /** * Animates the enemy model with rotation and floating movement * @param {number} delta - Time delta between frames * @param {number} elapsedTime - Total elapsed time */ /** * Creates a patrol path for the enemy to follow */ createEnemyPath() { // Use the SceneCreator to create a better path for enemy navigation if (this.rooms && this.rooms.length > 0 && this.sceneCreator) { // Get the first room (we only have one in our current layout) const room = this.rooms[0]; // Create a perimeter path with 5-unit margin from walls this.enemyPath = this.sceneCreator.createEnemyNavPath(room, 'perimeter', 8, 0); // Optionally create a debug visualization of the path this.createPathVisualization(); } else { // Fallback to the original path if SceneCreator or rooms are not available console.warn("SceneCreator or rooms not available, using default enemy path"); this.enemyPath = [ new THREE.Vector3(10, 0, 10), // Starting position new THREE.Vector3(10, 0, -10), // North new THREE.Vector3(-10, 0, -10), // Northwest new THREE.Vector3(-10, 0, 10), // Southwest new THREE.Vector3(10, 0, 10) // Back to start ]; } } /** * Creates a visual representation of the enemy path for debugging */ createPathVisualization() { // Remove any existing path visualization if (this.pathVisualization) { this.scene.remove(this.pathVisualization); } // Create a new group for path visualization this.pathVisualization = new THREE.Group(); // Create a line to visualize the path const pathMaterial = new THREE.LineBasicMaterial({ color: 0xff0000, // Red color for path linewidth: 2 // Thicker line for better visibility }); const pathGeometry = new THREE.BufferGeometry().setFromPoints(this.enemyPath); const pathLine = new THREE.Line(pathGeometry, pathMaterial); this.pathVisualization.add(pathLine); // Add markers at each waypoint const markerGeometry = new THREE.SphereGeometry(0.5, 8, 8); const markerMaterial = new THREE.MeshBasicMaterial({ color: 0xffff00 }); this.enemyPath.forEach((point) => { const marker = new THREE.Mesh(markerGeometry, markerMaterial); marker.position.copy(point); this.pathVisualization.add(marker); }); // Add to scene this.scene.add(this.pathVisualization); } /** * Animates the enemy model with walking animation and movement * @param {number} delta - Time delta between frames * @param {number} elapsedTime - Total elapsed time */ animateEnemyModel(delta, elapsedTime) { if (!this.enemyModel || this.enemyPath.length === 0) return; // Current target position const targetPos = this.enemyPath[this.enemyPathIndex]; // Calculate direction to target const direction = new THREE.Vector3(); direction.subVectors(targetPos, this.enemyModel.position); // Distance to target const distance = direction.length(); // If we're close enough to the target, move to the next point if (distance < 1.0) { // Increased threshold for smoother transitions // Move to next waypoint this.enemyPathIndex = (this.enemyPathIndex + 1) % this.enemyPath.length; // If we've completed a full circuit, optionally switch to a different path type if (this.enemyPathIndex === 0 && Math.random() < 0.3) { // 30% chance to change path type const pathTypes = ['perimeter', 'cross', 'random']; // Select a different path type than current const currentType = this.currentPathType || 'perimeter'; const availableTypes = pathTypes.filter(type => type !== currentType); const newPathType = availableTypes[Math.floor(Math.random() * availableTypes.length)]; // Get the room and create a new path if (this.rooms && this.rooms.length > 0 && this.sceneCreator) { const room = this.rooms[0]; this.enemyPath = this.sceneCreator.createEnemyNavPath(room, newPathType, 8, 0); this.currentPathType = newPathType; // Update path visualization this.createPathVisualization(); console.log(`Enemy switched to ${newPathType} path type`); } } return; } // Calculate direction vector direction.normalize(); // Apply smooth movement with slight acceleration/deceleration const speedFactor = Math.min(1.0, distance / 10); // Slow down as we approach target const moveSpeed = this.enemyMoveSpeed * (0.8 + speedFactor * 0.4); // 80% to 120% of base speed // Calculate the proposed new position const newPosition = { x: this.enemyModel.position.x + direction.x * moveSpeed, z: this.enemyModel.position.z + direction.z * moveSpeed }; // Check for wall collisions before moving const collisionRadius = 2.0; // Enemy collision radius const room = this.rooms[0]; // Get the current room const halfWidth = room.width / 2; const halfDepth = room.depth / 2; const wallMargin = collisionRadius + 0.5; // Add margin to prevent clipping // Simple box collision detection with walls let collisionDetected = false; // Check each wall boundary if (newPosition.x > halfWidth - wallMargin) { // East wall newPosition.x = halfWidth - wallMargin; collisionDetected = true; } else if (newPosition.x < -halfWidth + wallMargin) { // West wall newPosition.x = -halfWidth + wallMargin; collisionDetected = true; } if (newPosition.z > halfDepth - wallMargin) { // South wall newPosition.z = halfDepth - wallMargin; collisionDetected = true; } else if (newPosition.z < -halfDepth + wallMargin) { // North wall newPosition.z = -halfDepth + wallMargin; collisionDetected = true; } // If collision detected, pick a new target point if (collisionDetected) { console.log("Enemy collision with wall detected, finding new path"); // Skip to next waypoint this.enemyPathIndex = (this.enemyPathIndex + 1) % this.enemyPath.length; } // Update position with collision handling this.enemyModel.position.x = newPosition.x; this.enemyModel.position.z = newPosition.z; // Add a slight bobbing motion for more organic movement this.enemyModel.position.y = Math.sin(elapsedTime * 1.5) * 0.05; // Make the enemy face the direction of movement with smooth rotation if (direction.length() > 0.01) { const targetAngle = Math.atan2(direction.x, direction.z); // Current rotation let currentAngle = this.enemyModel.rotation.y; // Smooth rotation (lerp) const rotationSpeed = 0.1; // Calculate the shortest angle difference accounting for wrapping let angleDiff = targetAngle - currentAngle; while (angleDiff > Math.PI) angleDiff -= Math.PI * 2; while (angleDiff < -Math.PI) angleDiff += Math.PI * 2; // Apply smooth rotation this.enemyModel.rotation.y += angleDiff * rotationSpeed; } // Update animation mixer if (this.enemyMixer) { this.enemyMixer.update(delta); } } /** * Set the pause state of the game * @param {boolean} isPaused - Whether the game should be paused */ setPauseState(isPaused) { this.isPaused = isPaused; // If game is unpaused, reset clock to prevent time jumps if (!isPaused) { this.clock.getDelta(); // Clear accumulated delta } } /** * Handles collision between player and enemy * Applies damage to player and implements a damage cooldown */ handleEnemyCollision() { // Check if player is in cooldown period (to prevent constant damage) const now = performance.now() / 1000; // Current time in seconds // Initialize collision cooldown property if it doesn't exist if (!this.player.lastDamageTime) { this.player.lastDamageTime = 0; this.player.damageCooldown = 1.0; // 1 second between damage applications } // Return early if in cooldown period if (now - this.player.lastDamageTime < this.player.damageCooldown) { return; } // Apply damage to player this.player.health -= 10; // Enemy deals 10 damage per hit // Clamp health to prevent negative values this.player.health = Math.max(0, this.player.health); // Update last damage time this.player.lastDamageTime = now; // Optional: Play damage sound effect if audio manager exists if (this.audioManager) { this.audioManager.playOneShot('https://play.rosebud.ai/assets/pistol-shot-233473.mp3?uEfp', 0.3); } // Check if player died if (this.player.health <= 0) { console.log("Player has died!"); // Additional death handling could be added here } } /** * Checks for collision between player and enemy * @returns {boolean} Whether a collision occurred */ checkPlayerEnemyCollision() { // Skip if enemy model doesn't exist if (!this.enemyModel) return false; // Player position (only x and z matter for horizontal collision) const playerPos = new THREE.Vector2(this.player.position.x, this.player.position.z); // Enemy position (x and z components) const enemyPos = new THREE.Vector2(this.enemyModel.position.x, this.enemyModel.position.z); // Calculate distance between player and enemy const distance = playerPos.distanceTo(enemyPos); // Collision threshold (sum of player and enemy collision radii) // Adjust these values based on your model sizes const playerRadius = 1.0; // Player collision radius const enemyRadius = 2.0; // Enemy collision radius const collisionThreshold = playerRadius + enemyRadius; // Return true if distance is less than collision threshold return distance < collisionThreshold; } /** * Checks for collisions between bullets and the enemy * Applies damage to enemy when hit */ checkBulletEnemyCollisions() { // Skip if enemy model doesn't exist if (!this.enemyModel || !this.enemyModel.userData) { return; } // Initialize enemy health if not already set if (this.enemyModel.userData.health === undefined) { this.enemyModel.userData.health = 100; this.enemyModel.userData.lastHitTime = 0; this.enemyModel.userData.hitCooldown = 0.1; // 100ms between hit registrations } // Get bullets from weapon manager const bullets = this.weaponManager.bullets; if (!bullets || bullets.length === 0) return; // Enemy position and collision radius const enemyPos = new THREE.Vector3( this.enemyModel.position.x, this.enemyModel.position.y + 1, // Adjust to center of enemy this.enemyModel.position.z ); const enemyRadius = 2.0; // Enemy collision radius // Current time for hit cooldown const now = performance.now() / 1000; // Check each bullet for collision with enemy for (let i = bullets.length - 1; i >= 0; i--) { const bullet = bullets[i]; // Calculate distance between bullet and enemy const distance = bullet.position.distanceTo(enemyPos); // Check for collision if (distance < enemyRadius) { // Only register hits outside of cooldown period if (now - this.enemyModel.userData.lastHitTime > this.enemyModel.userData.hitCooldown) { // Apply damage to enemy this.enemyModel.userData.health -= 10; // 10 damage per bullet hit this.enemyModel.userData.lastHitTime = now; // Play hit sound if (this.audioManager) { this.audioManager.playOneShot('https://play.rosebud.ai/assets/pistol-shot-233473.mp3?uEfp', 0.2); } // Flash enemy red when hit this.flashEnemyOnHit(); // Check if enemy is defeated if (this.enemyModel.userData.health <= 0) { this.handleEnemyDefeat(); } } // Remove the bullet this.scene.remove(bullet); bullets.splice(i, 1); // Continue to next bullet continue; } } } /** * Creates a brief flash effect when enemy is hit */ flashEnemyOnHit() { if (!this.enemyModel) return; // Store original materials to restore later if (!this.enemyModel.userData.originalMaterials) { this.enemyModel.userData.originalMaterials = []; this.enemyModel.traverse(child => { if (child.isMesh && child.material) { this.enemyModel.userData.originalMaterials.push({ mesh: child, material: child.material.clone() }); } }); } // Flash red by changing material color this.enemyModel.traverse(child => { if (child.isMesh && child.material) { child.material.color = new THREE.Color(1, 0, 0); child.material.emissive = new THREE.Color(0.5, 0, 0); } }); // Restore original materials after a short delay setTimeout(() => { if (this.enemyModel && this.enemyModel.userData.originalMaterials) { this.enemyModel.userData.originalMaterials.forEach(item => { if (item.mesh) { item.mesh.material.color = item.material.color; item.mesh.material.emissive = item.material.emissive || new THREE.Color(0, 0, 0); } }); } }, 100); } /** * Handles enemy defeat when health reaches zero */ handleEnemyDefeat() { // Log defeat console.log("Enemy defeated!"); // Hide enemy model this.enemyModel.visible = false; // Play death sound if (this.audioManager) { this.audioManager.playOneShot('https://play.rosebud.ai/assets/080902_shotgun-39753.mp3?fhMd', 0.5); } // Show and animate death model if (this.enemyDeathModel) { this.enemyDeathModel.position.copy(this.enemyModel.position); this.enemyDeathModel.rotation.copy(this.enemyModel.rotation); this.enemyDeathModel.visible = true; // Play death animation if (this.enemyDeathAnimations['Death']) { const deathAnimation = this.enemyDeathAnimations['Death']; deathAnimation.reset().play(); // Remove death model after animation completes const animationDuration = deathAnimation.getClip().duration * 1000; // Convert to milliseconds setTimeout(() => { this.enemyDeathModel.visible = false; }, animationDuration); } } // Respawn enemy after delay setTimeout(() => { if (this.enemyModel) { // Reset enemy health this.enemyModel.userData.health = 100; // Move to a random position along path if (this.enemyPath && this.enemyPath.length > 0) { const randomIndex = Math.floor(Math.random() * this.enemyPath.length); this.enemyModel.position.copy(this.enemyPath[randomIndex]); this.enemyPathIndex = randomIndex; } else { // Fallback position if no path exists this.enemyModel.position.set( (Math.random() - 0.5) * 40, 0, (Math.random() - 0.5) * 40 ); } // Make enemy visible again this.enemyModel.visible = true; } }, 3000); // Respawn after 3 seconds } }