import * as THREE from 'three'; import { FBXLoader } from 'three/addons/loaders/FBXLoader.js'; import { OBJLoader } from 'three/addons/loaders/OBJLoader.js'; import { FontLoader } from 'three/addons/loaders/FontLoader.js'; import { TextGeometry } from 'three/addons/geometries/TextGeometry.js'; function loadScript(url) { return new Promise((resolve, reject) => { if (document.querySelector(`script[src="${url}"]`)) { resolve(); return; } var script = document.createElement('script'); script.type = 'text/javascript'; script.src = url; script.onload = () => resolve(); script.onerror = () => reject(new Error('Script loading failed for ' + url)); document.head.appendChild(script); }); } const COLLISION_GROUPS = { PLAYER: 1, WALL: 2, FLOOR: 4, ZOMBIE: 8 }; class WallManager { constructor(scene, world, game) { this.scene = scene; this.world = world; this.game = game; this.walls = []; this.door = null; } getAllWalls() { return this.walls; } addWall(start, end) { const wall = new Wall(this.scene, this.world, start, end); this.walls.push(wall); return wall; } removeWall(wall) { const index = this.walls.indexOf(wall); if (index !== -1) { wall.meshes.forEach(mesh => this.scene.remove(mesh)); wall.bodies.forEach(body => this.world.removeBody(body)); this.walls.splice(index, 1); } } clearAllWalls() { this.walls.forEach(wall => { wall.meshes.forEach(mesh => this.scene.remove(mesh)); wall.bodies.forEach(body => this.world.removeBody(body)); }); this.walls = []; this.clearDoor(); } createWallsFromPositions(wallPositions, doorPosition) { console.log('WallManager - createWallsFromPositions - Starting wall creation'); wallPositions.forEach((wallPosition, index) => { console.log(`WallManager - createWallsFromPositions - Processing wall ${index}:`, wallPosition); this.addWall(wallPosition.start, wallPosition.end); }); if (doorPosition) { console.log('WallManager - createWallsFromPositions - Creating door'); this.createDoor(doorPosition.start, doorPosition.end); } console.log('WallManager - createWallsFromPositions - Finished wall creation'); // Apply wall material to all existing walls const wallPhysicsMaterial = new CANNON.Material('wallMaterial'); this.walls.forEach(wall => { wall.bodies.forEach(body => { body.material = wallPhysicsMaterial; }); }); } createDoor(start, end) { this.door = new Door(this.scene, this.world, start, end, this.game); } getDoor() { return this.door; } clearDoor() { if (this.door) { this.door.meshes.forEach(mesh => this.scene.remove(mesh)); this.door.bodies.forEach(body => this.world.removeBody(body)); this.door = null; } } update() { this.walls.forEach(wall => wall.update()); if (this.door) { this.door.update(); } } } class Wall { constructor(scene, world, start, end) { this.scene = scene; this.world = world; this.start = new THREE.Vector3(start.x, 0, start.z); this.end = new THREE.Vector3(end.x, 0, end.z); this.width = 0.2; // Wall thickness this.height = 4; // Wall height this.wallUnits = this.generateWallUnits(); this.meshes = []; this.bodies = []; this.collisionMeshes = []; this.createWall(); } getStartPosition() { return { x: this.start.x, z: this.start.z }; } getEndPosition() { return { x: this.end.x, z: this.end.z }; } getLength() { return this.start.distanceTo(this.end); } getDirection() { return Math.abs(this.start.x - this.end.x) > Math.abs(this.start.z - this.end.z) ? 'x' : 'z'; } generateWallUnits() { const wallUnits = []; const isHorizontal = this.start.z === this.end.z; const length = isHorizontal ? Math.abs(this.end.x - this.start.x) : Math.abs(this.end.z - this.start.z); const direction = isHorizontal ? Math.sign(this.end.x - this.start.x) : Math.sign(this.end.z - this.start.z); const unitSize = 2; for (let i = 0; i <= length; i += unitSize) { const position = isHorizontal ? new THREE.Vector3(this.start.x + direction * i, 0, this.start.z) : new THREE.Vector3(this.start.x, 0, this.start.z + direction * i); wallUnits.push(position); } if (wallUnits[wallUnits.length - 1].distanceTo(this.end) > 0.01) { wallUnits.push(this.end); } return wallUnits; } createWall() { for (let i = 0; i < this.wallUnits.length - 1; i++) { const start = this.wallUnits[i]; const end = this.wallUnits[i + 1]; const isHorizontal = start.z === end.z; const length = start.distanceTo(end); const geometry = new THREE.BoxGeometry( isHorizontal ? length : this.width, this.height, isHorizontal ? this.width : length ); const material = new THREE.MeshPhongMaterial({ color: 0xa0a0a0 }); const mesh = new THREE.Mesh(geometry, material); const centerPosition = new THREE.Vector3().addVectors(start, end).multiplyScalar(0.5); centerPosition.y = this.height / 2; mesh.position.copy(centerPosition); mesh.name = `Wall_${start.x}_${start.z}_${end.x}_${end.z}`; mesh.layers.enable(1); // Enable layer 1 for raycasting mesh.userData.isWall = true; this.scene.add(mesh); this.meshes.push(mesh); const halfExtents = new CANNON.Vec3( isHorizontal ? length / 2 : this.width / 2, this.height / 2, isHorizontal ? this.width / 2 : length / 2 ); const shape = new CANNON.Box(halfExtents); const wallPhysicsMaterial = new CANNON.Material('wallMaterial'); const body = new CANNON.Body({ mass: 0, // Static body shape: shape, position: new CANNON.Vec3(centerPosition.x, centerPosition.y, centerPosition.z), collisionFilterGroup: COLLISION_GROUPS.WALL, collisionFilterMask: COLLISION_GROUPS.PLAYER | COLLISION_GROUPS.ZOMBIE, material: wallPhysicsMaterial }); this.world.addBody(body); this.bodies.push(body); const boxGeometry = new THREE.BoxGeometry(halfExtents.x * 2, halfExtents.y * 2, halfExtents.z * 2); const wireframeMaterial = new THREE.MeshBasicMaterial({ color: 0x00ff00, wireframe: true }); const wireframeMesh = new THREE.Mesh(boxGeometry, wireframeMaterial); wireframeMesh.position.copy(centerPosition); wireframeMesh.visible = false; // Initially invisible this.scene.add(wireframeMesh); this.collisionMeshes.push(wireframeMesh); } } update() { for (let i = 0; i < this.meshes.length; i++) { this.meshes[i].position.copy(this.bodies[i].position); this.meshes[i].quaternion.copy(this.bodies[i].quaternion); } } } class Door extends Wall { constructor(scene, world, start, end, game) { super(scene, world, start, end); this.game = game; this.lockedColor = 0xFFD700; // Bright yellow-gold color this.unlockedColor = 0xFFFFFF; // White color this.isLocked = true; this.isOpened = false; this.interactionRange = 5; // Range within which the player can interact with the door this.visibilityRange = 20; // Visibility range is twice the interaction range this.screenPosition = null; this.distanceToPlayer = Infinity; this.isInFieldOfView = false; } updateVisibility(playerPosition, camera, gameState) { const doorPosition = this.getPosition(); this.distanceToPlayer = doorPosition.distanceTo(playerPosition); // Check if door is within player's visibility range or if the game state is LEVEL_COMPLETE const isInRange = gameState === this.game.states.LEVEL_COMPLETE || this.distanceToPlayer <= this.visibilityRange; // Check if door is within player's field of view const doorVector = new THREE.Vector3().subVectors(doorPosition, playerPosition).normalize(); const cameraDirection = new THREE.Vector3(0, 0, -1).applyQuaternion(camera.quaternion); const angle = doorVector.angleTo(cameraDirection); this.isInFieldOfView = angle < Math.PI / 4; // Assuming 90-degree FOV this.updateScreenPosition(doorPosition, camera); return { isInRange: isInRange, isInFieldOfView: this.isInFieldOfView }; } isVisible() { return this.distanceToPlayer <= this.visibilityRange && this.isInFieldOfView; } getPosition() { return new THREE.Vector3().addVectors(this.start, this.end).multiplyScalar(0.5); } getScreenPosition() { return this.screenPosition; } updateScreenPosition(doorPosition, camera) { const vector = new THREE.Vector3(doorPosition.x, doorPosition.y, doorPosition.z); vector.project(camera); const widthHalf = this.game.parentDiv.clientWidth / 2; const heightHalf = this.game.parentDiv.clientHeight / 2; this.screenPosition = { x: (vector.x * widthHalf) + widthHalf, y: -(vector.y * heightHalf) + heightHalf }; } createWall() { super.createWall(); this.meshes.forEach(mesh => { mesh.material = new THREE.MeshStandardMaterial({ color: this.lockedColor, emissive: this.lockedColor, emissiveIntensity: 0.5 }); }); } canUnlock(gameState, playerPosition) { return gameState === 'LEVEL_COMPLETE' && this.isPlayerInRange(playerPosition); } unlock() { if (this.isLocked) { this.isLocked = false; this.meshes.forEach(mesh => { mesh.material.color.setHex(this.unlockedColor); mesh.material.emissive.setHex(this.unlockedColor); }); console.log("Door unlocked"); return true; } return false; } tryUnlock(gameState, playerPosition) { if (this.canUnlock(gameState, playerPosition)) { return this.unlock(); } return false; } isPlayerInRange(playerPosition) { const doorCenter = new THREE.Vector3().addVectors(this.start, this.end).multiplyScalar(0.5); const distance = doorCenter.distanceTo(playerPosition); const inRange = distance <= this.interactionRange; return inRange; } tryOpenDoor() { const unlocked = !this.isLocked; if (unlocked && this.isPlayerInRange(this.game.player.body.position)) { this.isOpened = true; this.game.audioPlayer.playSound('doorOpen', this.game.assetConfig.doorOpen.volume); console.log('Door opened'); this.game.setState(this.game.states.LOADING); } } updateStatus(playerPosition, camera) { const doorPosition = this.getPosition(); this.distanceToPlayer = playerPosition.distanceTo(doorPosition); this.checkVisibility(playerPosition, camera); if (this.isVisible) { this.updateScreenPosition(doorPosition, camera); } else { this.screenPosition = null; } } updateScreenPosition(doorPosition, camera) { const vector = new THREE.Vector3(doorPosition.x, doorPosition.y, doorPosition.z); vector.project(camera); const widthHalf = this.game.parentDiv.clientWidth / 2; const heightHalf = this.game.parentDiv.clientHeight / 2; this.screenPosition = { x: (vector.x * widthHalf) + widthHalf, y: -(vector.y * heightHalf) + heightHalf }; } } class CameraController { constructor(camera, sensitivityX = 0.0015, sensitivityY = 0.0015) { this.camera = camera; this.rotationX = 0; this.rotationY = 0; this.sensitivityX = sensitivityX; this.sensitivityY = sensitivityY; this.maxPolarAngle = Math.PI / 2 - 0.1; // Slightly less than 90 degrees this.minPolarAngle = -Math.PI / 2 + 0.1; // Slightly more than -90 degrees this.debugDeltaTime = 0; } handleMouseMovement(movementX, movementY) { this.rotationX -= movementX * this.sensitivityX; this.rotationY -= movementY * this.sensitivityY; this.rotationY = Math.max(this.minPolarAngle, Math.min(this.maxPolarAngle, this.rotationY)); } update(deltaTime) { this.debugDeltaTime = deltaTime; this.camera.rotation.order = 'YXZ'; this.camera.rotation.x = this.rotationY; this.camera.rotation.y = this.rotationX; // Add any time-based camera adjustments here using deltaTime } setSensitivity(sensitivityX, sensitivityY) { this.sensitivityX = sensitivityX; this.sensitivityY = sensitivityY; } } class FireRay { constructor(scene, camera) { this.scene = scene; this.camera = camera; this.ray = null; this.lifespan = 100; // milliseconds this.createRay(); } createRay() { const geometry = new THREE.BufferGeometry().setFromPoints([ new THREE.Vector3(0, 0, -1), // Start point (near the camera) new THREE.Vector3(0, 0, -1000) // End point (far in front of the camera) ]); const material = new THREE.LineBasicMaterial({ color: 0xffff00 }); // Yellow color this.ray = new THREE.Line(geometry, material); this.ray.visible = false; this.scene.add(this.ray); } fire() { if (this.ray) { this.ray.visible = true; this.updatePosition(); setTimeout(() => this.hide(), this.lifespan); } } updatePosition() { if (this.ray) { this.ray.position.copy(this.camera.position); this.ray.rotation.copy(this.camera.rotation); this.ray.updateMatrix(); } } hide() { if (this.ray) { this.ray.visible = false; } } remove() { if (this.ray) { this.scene.remove(this.ray); this.ray.geometry.dispose(); this.ray.material.dispose(); this.ray = null; } } } const parentDiv = document.getElementById('renderDiv'); class AudioPlayer { constructor(game) { this.game = game; this.channels = []; this.maxChannels = 5; // Adjust this number as needed } initialize() { for (let i = 0; i < this.maxChannels; i++) { const audio = new Audio(); this.channels.push(audio); } } playSound(soundName, volume = 1) { const availableChannel = this.channels.find(channel => channel.paused); if (availableChannel) { const sound = this.game.assetLoader.getAsset(soundName); if (sound) { availableChannel.src = sound.src; availableChannel.currentTime = 0; availableChannel.volume = volume; availableChannel.play().catch(error => console.error(`Error playing ${soundName}:`, error)); } else { console.error(`Sound ${soundName} not found`); } } else { console.warn('No available audio channel'); } } playBiteSound() { this.playSound('zombieBiteSound', this.game.assetConfig.zombieBiteSound.volume); } stopSound(soundName) { this.channels.forEach(channel => { if (channel.src.includes(soundName)) { channel.pause(); channel.currentTime = 0; } }); } } class AssetLoader { constructor() { this.assets = new Map(); this.textureLoader = new THREE.TextureLoader(); this.fbxLoader = new FBXLoader(); this.objLoader = new OBJLoader(); } loadImage(url, key) { return new Promise((resolve, reject) => { const img = new Image(); img.onload = () => { this.assets.set(key, img); resolve(img); }; img.onerror = () => reject(`Error loading image ${key}`); img.src = url; }); } loadTexture(url, key) { return new Promise((resolve, reject) => { this.textureLoader.load( url, (texture) => { this.assets.set(key, texture); resolve(texture); }, (progress) => console.log(`Loading texture ${key}: ${(progress.loaded / progress.total * 100).toFixed(2)}%`), (error) => reject(`Error loading texture ${key}: ${error}`) ); }); } loadFBX(url, key) { return new Promise((resolve, reject) => { this.fbxLoader.load( url, (model) => { this.assets.set(key, model); resolve(model); }, (progress) => console.log(`Loading FBX ${key}: ${(progress.loaded / progress.total * 100).toFixed(2)}%`), (error) => reject(`Error loading FBX ${key}: ${error}`) ); }); } loadOBJ(url, key) { return new Promise((resolve, reject) => { this.objLoader.load( url, (model) => { this.assets.set(key, model); resolve(model); }, (progress) => {}, // Remove progress logging (error) => reject(`Error loading OBJ ${key}: ${error}`) ); }); } loadAudio(url, key) { return new Promise((resolve, reject) => { const audio = new Audio(url); audio.addEventListener('canplaythrough', () => { this.assets.set(key, audio); resolve(audio); }, { once: true }); audio.addEventListener('error', () => reject(`Error loading audio ${key}`), { once: true }); audio.load(); }); } getAsset(key) { return this.assets.get(key); } } class LoadingScreen { constructor(game, mapImages) { this.game = game; this.overlay = null; this.image = null; this.text = null; this.mapImages = mapImages; this.createOverlay(); } createOverlay() { this.overlay = document.createElement('div'); this.overlay.style.position = 'fixed'; this.overlay.style.top = '0'; this.overlay.style.left = '0'; this.overlay.style.width = '100%'; this.overlay.style.height = '100%'; this.overlay.style.backgroundColor = 'rgba(0, 0, 0, 1)'; this.overlay.style.display = 'none'; this.overlay.style.flexDirection = 'column'; this.overlay.style.alignItems = 'center'; this.overlay.style.justifyContent = 'center'; this.overlay.style.zIndex = '1000'; this.text = document.createElement('div'); this.text.style.color = 'white'; this.text.style.fontSize = '28px'; // Increased font size this.text.style.position = 'absolute'; this.text.style.top = '10%'; // Positioned at 10% from the top this.text.style.left = '0'; this.text.style.width = '100%'; this.text.style.textAlign = 'center'; this.text.style.textShadow = '2px 2px 4px rgba(0,0,0,0.5)'; // Added text shadow for better visibility this.image = document.createElement('img'); this.image.style.maxWidth = '100%'; // Increased from 80% to 90% this.image.style.maxHeight = '100%'; // Increased from 80% to 90% this.image.style.objectFit = 'contain'; this.image.style.position = 'absolute'; this.image.style.top = '50%'; this.image.style.left = '50%'; this.image.style.transform = 'translate(-50%, -50%)'; // Center the image this.overlay.appendChild(this.text); this.overlay.appendChild(this.image); document.body.appendChild(this.overlay); } show(currentLevelIndex, totalLevels) { this.text.textContent = `Loading Level ${currentLevelIndex + 1}/${totalLevels}...`; this.overlay.style.display = 'flex'; if (this.mapImages && this.mapImages[currentLevelIndex]) { this.image.src = this.mapImages[currentLevelIndex].src; } } hide() { this.overlay.style.display = 'none'; } setImage(imageObj) { if (imageObj instanceof Image) { this.image.src = imageObj.src; } else { console.error('setImage requires an Image object'); } } } class Game { constructor(parentDiv, mapDataList) { this.parentDiv = parentDiv; this.maps = []; this.mapDataList = mapDataList; this.scene = null; this.camera = null; this.renderer = null; this.rendererInstance = null; this.lightsInstance = null; this.fogInstance = null; this.canvas = null; this.world = null; this.uiManager = null; this.isInitialized = false; this.cameraController = null; this.wallManager = null; this.inputHandler = null; this.GRID_SIZE = null; this.CELL_SIZE = null; this.ROOM_SIZE = null; this.WALL_HEIGHT = 12; this.logger = new Logger(); this.zombieSpawnManager = null; this.mapManager = null; this.currentMap = null; this.debugMode = false; this.states = { PREGAME: 'PREGAME', PLAYING: 'PLAYING', INTERMISSION: 'INTERMISSION', LEVEL_RESET: 'LEVEL_RESET', LEVEL_COMPLETE: 'LEVEL_COMPLETE', LOADING: 'LOADING' }; this.currentState = null; this.lastTime = performance.now(); this.gun = null; this.intermissionTimeRemaining = 0; this.loadingScreen = null; this.loadingTimer = 0; this.isFirstTimeLoad = true; this.firstTimeLoadingDuration = 1.5; this.baseLoadingDuration = 3.6; this.loadingDuration = this.firstTimeLoadingDuration; } async init() { try { console.log('Loading scripts...'); await this.loadScripts(); this.assetLoader = new AssetLoader(); await this.loadAssets(); this.audioPlayer = new AudioPlayer(this); this.audioPlayer.initialize(); this.initLoadingScreen() this.initScene(); await this.initWorld(); this.assetLoader = new AssetLoader(); await this.loadAssets(); await this.initWallManager(); await this.initMapManager(); this.initUIManager(); this.initWaveManager(); this.initWaypointManager(); this.initZombieSpawnManager(); await this.mapManager.loadInitialMap() this.initCoreComponents(); this.initUtilities(); this.initRenderer(); this.initLights(); this.initFog(); await this.initializeRoom(); await this.initializePlayer(); await this.initializeControls(); this.isInitialized = true; this.animate(); this.setState(this.states.LOADING); } catch (error) { console.error('Game: Error initializing game:', error); } } async initWorld() { try { if (typeof CANNON === 'undefined') { throw new Error('CANNON physics engine is not loaded'); } this.world = new CANNON.World(); this.world.gravity.set(0, -9.82, 0); // Create a plane for the floor const planeShape = new CANNON.Plane(); const planeBody = new CANNON.Body({ mass: 0, // Static body shape: planeShape, material: new CANNON.Material('groundMaterial') }); planeBody.quaternion.setFromAxisAngle(new CANNON.Vec3(1, 0, 0), -Math.PI / 2); this.world.addBody(planeBody); // Increased player start height this.playerStartHeight = 1.6; console.log('Physics world initialized successfully.'); } catch (error) { console.error('Error initializing physics world:', error); throw error; // Re-throw the error to be caught in the init method } } async initWallManager() { this.wallManager = new WallManager(this.scene, this.world, this); } async initMapManager() { this.mapManager = new MapManager(this); await this.mapManager.loadMapData(this.mapDataList); this.mapManager.createMaps(); console.log(`${this.mapManager.maps.length} maps created successfully.`); if (!this.mapManager.maps || this.mapManager.maps.length === 0) { throw new Error('No maps created. Cannot initialize game.'); } } initRenderer() { this.rendererInstance = new Renderer(THREE, this.canvas, this.parentDiv); this.renderer = this.rendererInstance.create(); } initLights() { this.lightsInstance = new Lights(THREE, this.scene, this.ROOM_SIZE, this.WALL_HEIGHT); this.lightsInstance.init(); } initFog() { this.fogInstance = new Fog(THREE, this.scene, this.ROOM_SIZE); this.fogInstance.createHeightBasedFog(); } initScene() { this.scene = new THREE.Scene(); console.log('Scene initialized'); } initCoreComponents() { this.canvas = this.createCanvas(); this.camera = this.createCamera(); } initUIManager() { if (!this.doorIconImage) { console.error('Door icon not loaded'); return; } this.uiManager = new GameUIManager(this, this.parentDiv, THREE, FontLoader, TextGeometry, this.doorIconImage); this.uiManager.init(); // Initialize UI } initWaveManager() { this.waveManager = new WaveManager(this); } initWaypointManager() { this.waypointManager = new WaypointManager(this, THREE, AStar, Waypoint, DebugLine); } initZombieSpawnManager() { const zombieSpawnPoints = this.mapManager.getZombieSpawnPoints(); this.zombieSpawnManager = new ZombieSpawnManager(this, zombieSpawnPoints); } getWalls() { return this.wallManager.getAllWalls(); } initUtilities() { this.logger = new Logger(); this.raycaster = new THREE.Raycaster(); } async initializeRoom() { this.room = new Room(this.scene, this.ROOM_SIZE, this.WALL_HEIGHT, this.world, THREE, TextGeometry, FontLoader, CANNON); if (!this.room) throw new Error('Failed to create room'); } async initializeControls() { this.fireRay = new FireRay(this.scene, this.camera); this.inputHandler = new InputHandler(this); this.gun = new Gun(this.scene, this.camera, THREE, this.assetLoader, this.gunTexture, this.gunModel, this.shootSound); await this.gun.initialize(); } initLoadingScreen() { this.loadingScreen = new LoadingScreen(this, this.mapImages); } async loadScripts() { await loadScript('https://play.rosebud.ai/assets/script_room.js?TDG0'); await loadScript('https://play.rosebud.ai/assets/script_healthbar.js?FN0M'); await loadScript('https://play.rosebud.ai/assets/script_start_button.js?YvpE'); await loadScript('https://play.rosebud.ai/assets/script_uiManager.js?LGZN'); await loadScript('https://play.rosebud.ai/assets/script_waveManager.js?jc2m'); await loadScript('https://play.rosebud.ai/assets/script_gun.js?IlVZ') await loadScript('https://play.rosebud.ai/assets/script_aStar.js?ZGgC'); await loadScript('https://play.rosebud.ai/assets/script_fog.js?KCaE'); await loadScript('https://play.rosebud.ai/assets/script_renderer.js?slPn'); await loadScript('https://play.rosebud.ai/assets/script_lights.js?WWF3'); await loadScript('https://play.rosebud.ai/assets/script_inputHandler.js?JCbg'); await loadScript('https://play.rosebud.ai/assets/script_waypointManager.js?Od9N'); await loadScript('https://play.rosebud.ai/assets/script_mapManager.js?DTi8'); } setState(newState) { console.log(`[Game] Attempting to change state from ${this.currentState} to ${newState}`); if (this.currentState !== newState) { this.onExitState(this.currentState); this.currentState = newState; this.onEnterState(newState); } } startLoadingTimerLogging() { this.loadingTimerInterval = setInterval(() => { console.log(`[Game] Loading timer: ${this.loadingTimer.toFixed(2)}`); }, 100); } stopLoadingTimerLogging() { if (this.loadingTimerInterval) { clearInterval(this.loadingTimerInterval); this.loadingTimerInterval = null; } } onEnterState(state) { console.log(`[Game] Entering state: ${state}`); switch (state) { case this.states.PREGAME: this.uiManager.updateHealthBar(this.player.health, this.player.maxHealth); break; case this.states.PLAYING: if (this.waveManager.currentWave === 0) { this.audioPlayer.playSound('darkLoop', this.assetConfig.darkLoop.volume); } this.waveManager.startWave(); break; case this.states.INTERMISSION: this.audioPlayer.playSound('darkRise', this.assetConfig.darkRise.volume); this.startIntermissionTimer(); break; case this.states.LEVEL_RESET: this.zombieSpawnManager.markAllZombiesAsDead(); this.zombieSpawnManager.clearZombies(); this.player.reset(); this.waveManager.reset(); this.zombieSpawnManager.stopSpawnTimer(); this.setState(this.states.PREGAME); break; case this.states.LEVEL_COMPLETE: const door = this.wallManager.getDoor(); door.unlock(); this.audioPlayer.playSound('brightChime', this.assetConfig.brightChime.volume); break; case this.states.LOADING: console.log('[Game] Entering LOADING state'); this.loadingScreen.show(this.mapManager.getCurrentMapIndex(), this.mapManager.getMapCount()); if (!this.isFirstTimeLoad) { this.audioPlayer.playSound('loadingScreenMusic', this.assetConfig.loadingScreenMusic.volume); } this.loadingTimer = 0; // Reset the loading timer this.startLoadingTimerLogging(); break; default: console.error(`Invalid game state: ${state}`); } } onExitState(state) { switch (state) { case this.states.PREGAME: break; case this.states.PLAYING: break; case this.states.INTERMISSION: this.intermissionTimeRemaining = 0; break; case this.states.GAME_OVER: break; case this.states.LOADING: if (this.loadingScreen) { this.loadingScreen.hide(); } this.stopLoadingTimerLogging(); if (this.isFirstTimeLoad) { this.loadingDuration = this.baseLoadingDuration; this.isFirstTimeLoad = false; } break; case this.states.LEVEL_COMPLETE: this.zombieSpawnManager.markAllZombiesAsDead(); this.zombieSpawnManager.clearZombies(); this.player.reset(); this.waveManager.reset(); this.zombieSpawnManager.stopSpawnTimer(); this.mapManager.loadNextMap(); break; } } startIntermissionTimer() { this.intermissionTimeRemaining = 5; // 5 seconds intermission } getZombies() { return this.zombieSpawnManager.getZombies(); } // Asset configuration object assetConfig = { gunTexture: { url: 'https://play.rosebud.ai/assets/BLK64.png?B9l1' }, gunModel: { url: 'https://play.rosebud.ai/assets/01_gun_fbx.fbx?3ijb' }, characterModel: { url: 'https://play.rosebud.ai/assets/mc_character_model.obj?1v5W' }, shootSound: { url: 'https://play.rosebud.ai/assets/snd_pistol_shot.wav?V6gU', volume: 0.1 }, zombieDeathSound1: { url: 'https://play.rosebud.ai/assets/snd_groan_01.wav?kZv4', volume: 1.0 }, zombieDeathSound2: { url: 'https://play.rosebud.ai/assets/snd_groan_03.wav?SQdQ', volume: 0.7 }, zombieBiteSound: { url: 'https://play.rosebud.ai/assets/snd_bite.wav?ld4X', volume: 0.15 }, doorIconImage: { url: 'https://play.rosebud.ai/assets/door_icon_225x225.png?fbRz' }, darkRise: { url: 'https://play.rosebud.ai/assets/snd_dark_rise.wav?0T9Q', volume: .5 }, darkLoop: { url: 'https://play.rosebud.ai/assets/snd_dark_loop.wav?SueG', volume: .7 }, brightChime: { url: 'https://play.rosebud.ai/assets/snd_bright_chime.mp3?8rdX', volume: 0.6 }, doorOpen: { url: 'https://play.rosebud.ai/assets/snd_door_open.wav?HbKX', volume: 0.7 }, loadingScreenMusic: { url: 'https://play.rosebud.ai/assets/snd_upbeat_loop.wav?vxde', volume: .8 }, map1Image: { url: 'https://play.rosebud.ai/assets/bigmap01.png?m3Oq' }, map2Image: { url: 'https://play.rosebud.ai/assets/bigmap02.png?9qsK' }, map3Image: { url: 'https://play.rosebud.ai/assets/bigmap03_02.png?aRRg' } }; async loadAssets() { try { const [ gunTexture, gunModel, characterModel, shootSound, zombieDeathSound1, zombieDeathSound2, zombieBiteSound, darkRiseSound, darkLoopSound, brightChimeSound, doorOpenSound, doorIconImage, loadingScreenMusic, map1Image, map2Image, map3Image ] = await Promise.all([ this.assetLoader.loadTexture(this.assetConfig.gunTexture.url, 'gunTexture'), this.assetLoader.loadFBX(this.assetConfig.gunModel.url, 'gunModel'), this.assetLoader.loadOBJ(this.assetConfig.characterModel.url, 'characterModel'), this.assetLoader.loadAudio(this.assetConfig.shootSound.url, 'shootSound'), this.assetLoader.loadAudio(this.assetConfig.zombieDeathSound1.url, 'zombieDeathSound1'), this.assetLoader.loadAudio(this.assetConfig.zombieDeathSound2.url, 'zombieDeathSound2'), this.assetLoader.loadAudio(this.assetConfig.zombieBiteSound.url, 'zombieBiteSound'), this.assetLoader.loadAudio(this.assetConfig.darkRise.url, 'darkRise'), this.assetLoader.loadAudio(this.assetConfig.darkLoop.url, 'darkLoop'), this.assetLoader.loadAudio(this.assetConfig.brightChime.url, 'brightChime'), this.assetLoader.loadAudio(this.assetConfig.doorOpen.url, 'doorOpen'), this.assetLoader.loadImage(this.assetConfig.doorIconImage.url, 'doorIconImage'), this.assetLoader.loadAudio(this.assetConfig.loadingScreenMusic.url, 'loadingScreenMusic'), this.assetLoader.loadImage(this.assetConfig.map1Image.url, 'map1Image'), this.assetLoader.loadImage(this.assetConfig.map2Image.url, 'map2Image'), this.assetLoader.loadImage(this.assetConfig.map3Image.url, 'map3Image'), ]); // Set up assets this.gunTexture = gunTexture; this.gunModel = gunModel; this.characterModel = characterModel; this.shootSound = shootSound; this.zombieDeathSounds = [zombieDeathSound1, zombieDeathSound2]; this.zombieBiteSound = zombieBiteSound; this.mapImages = [map1Image, map2Image, map3Image]; this.doorIconImage = doorIconImage; // This is now an Image object, not a texture this.loadingScreenMusic = loadingScreenMusic; // Set up audio volumes this.shootSound.volume = this.assetConfig.shootSound.volume; this.zombieDeathSounds.forEach((sound, index) => { sound.volume = this.assetConfig[`zombieDeathSound${index + 1}`].volume; }); this.zombieBiteSound.volume = this.assetConfig.zombieBiteSound.volume; this.darkRiseSound = darkRiseSound; this.darkRiseSound.volume = this.assetConfig.darkRise.volume; this.darkLoopSound = darkLoopSound; this.darkLoopSound.volume = this.assetConfig.darkLoop.volume; this.brightChimeSound = brightChimeSound; this.brightChimeSound.volume = this.assetConfig.brightChime.volume; this.doorOpenSound = doorOpenSound; this.doorOpenSound.volume = this.assetConfig.doorOpen.volume; this.loadingScreenMusic.volume = this.assetConfig.loadingScreenMusic.volume; } catch (error) { console.error('Error loading assets:', error); throw error; } } async initializePlayer() { this.cameraController = new CameraController(this.camera); this.player = new Player(this.camera, this, this.cameraController); await this.player.initialize(); } loadCharacterModel() { const objLoader = new OBJLoader(); objLoader.load( 'https://play.rosebud.ai/assets/mc_character_model.obj?1v5W', (obj) => { this.characterModel = obj; }, (progress) => { console.log('Character model loading progress: ' + (progress.loaded / progress.total * 100) + '%'); }, (error) => { console.error('An error occurred while loading the character model:', error); } ); } createCanvas() { let canvas = document.getElementById('threeRenderCanvas'); if (!canvas) { canvas = document.createElement('canvas'); canvas.id = 'threeRenderCanvas'; this.parentDiv.appendChild(canvas); } return canvas; } shoot() { if (this.gun) { const rayDirection = new THREE.Vector3(0, 0, -1).applyQuaternion(this.camera.quaternion); const rayOrigin = this.camera.position.clone(); this.raycaster.set(rayOrigin, rayDirection); const result = this.gun.shoot(this.raycaster, this.zombieSpawnManager.getZombies(), this.uiManager); if (result.hit) { if (result.type === 'startButton') { this.handleStartButtonHit(); } else { // Handle zombie hit this.visualizeImpact(result.position); } } else if (this.logger) { this.logger.log('Combat', 'No hit', 'HitDetection'); } } } handleStartButtonHit() { this.logger.log('UI', 'Start button hit', 'HitDetection'); if (this.currentState === this.states.PREGAME || this.currentState === this.states.GAME_OVER) { this.setState(this.states.PLAYING); } } handleZombieHit(intersection) { const hitZombie = this.zombies.find(zombie => zombie.model === intersection.object.parent); if (hitZombie) { this.logger.log('Combat', `Zombie hit at: ${intersection.point.toArray().join(', ')}`, 'HitDetection'); hitZombie.takeDamage(1); this.visualizeImpact(intersection.point); } } visualizeImpact(intersectionPoint) { if (intersectionPoint) { const sphereGeometry = new THREE.SphereGeometry(0.1); const sphereMaterial = new THREE.MeshBasicMaterial({ color: 0xffff00 }); const intersectionSphere = new THREE.Mesh(sphereGeometry, sphereMaterial); intersectionSphere.position.copy(intersectionPoint); intersectionSphere.name = 'intersectionPoint'; this.scene.add(intersectionSphere); setTimeout(() => { const intersectionSphere = this.scene.getObjectByName('intersectionPoint'); if (intersectionSphere) this.scene.remove(intersectionSphere); }, 100); } } createCamera() { const camera = new THREE.PerspectiveCamera( 75, this.parentDiv.clientWidth / this.parentDiv.clientHeight, 0.1, 1000 ); camera.position.set(0, 1.6, -10); camera.lookAt(16, 1.6, -10); return camera; } animate() { if (!this.isInitialized) { console.warn('Game is not fully initialized. Waiting for initialization to complete...'); requestAnimationFrame(() => this.animate()); return; } requestAnimationFrame(() => this.animate()); const currentTime = performance.now(); const deltaTime = (currentTime - this.lastTime) / 1000; // Convert to seconds this.lastTime = currentTime; try { switch (this.currentState) { case this.states.LOADING: this.loadingTimer += deltaTime; if (this.loadingTimer >= this.loadingDuration) { this.setState(this.states.PREGAME); this.loadingTimer = 0; // Reset the timer } return; // Skip all other updates during LOADING state case this.states.INTERMISSION: this.intermissionTimeRemaining -= deltaTime; if (this.intermissionTimeRemaining <= 0) { this.setState(this.states.PLAYING); } break; case this.states.PREGAME: case this.states.PLAYING: case this.states.LEVEL_COMPLETE: case this.states.LEVEL_RESET: // Handle other state actions break; default: console.warn(`Unknown game state: ${this.currentState}`); } if (this.cameraController) { this.cameraController.update(deltaTime); } if (this.world) { this.world.step(deltaTime); } else { console.error('Physics world is not initialized'); } if (this.zombieSpawnManager) { this.zombieSpawnManager.spawnZombieIfNeeded(deltaTime); const zombies = this.zombieSpawnManager.getZombies(); zombies.forEach(zombie => { if (zombie && zombie.body && zombie.update && !zombie.isDead) { zombie.update(this.camera, deltaTime, this.currentState); } }); this.zombieSpawnManager.clearZombies() } if (this.getWalls()) { this.getWalls().forEach(wall => { if (wall && wall.update) { wall.update(); } }); } if (this.player) { this.player.update(deltaTime); if (this.uiManager) { this.uiManager.update(deltaTime); } } if (this.gun) { this.gun.update(deltaTime); } if (this.renderer && this.scene && this.camera) { this.renderer.render(this.scene, this.camera); } else { console.error('Renderer, scene, or camera is not initialized'); } } catch (error) { console.error('Error in animation loop:', error); } } toggleDebugMode() { this.debugMode = !this.debugMode; console.log(`Debug mode ${this.debugMode ? 'enabled' : 'disabled'}`); this.updateDebugVisibility(); } updateDebugVisibility() { if (this.zombieSpawnManager) { this.zombieSpawnManager.getZombies().forEach(zombie => { if (zombie && typeof zombie.updateDebugVisibility === 'function') { zombie.updateDebugVisibility(this.debugMode); } }); } if (this.waypointManager) { this.waypointManager.updateDebugVisibility(this.debugMode); } if (this.player && this.player.debugMesh) { this.player.debugMesh.visible = this.debugMode; } } } class Player { constructor(camera, game, cameraController) { this.audioPlayer = new AudioPlayer(this); this.camera = camera; this.game = game; this.cameraController = cameraController; this.moveSpeed = 7.5; this.keys = { w: false, a: false, s: false, d: false }; this.maxHealth = 100; this.health = this.maxHealth; this.isDead = false; this.invulnerabilityTime = 200; // milliseconds this.invulnerabilityTimer = 0; this.initialPosition = new CANNON.Vec3(0, 2.0, -12); // Renamed and new properties for door field of view this.doorInFieldOfView = false; this.doorFieldOfViewAngle = Math.PI / 4; // 45 degrees this.doorFieldOfViewDistance = 20; // Maximum distance to check for door in field of view this.doorStateLogInterval = 4; // Log door state every 4 seconds this.lastDoorStateLogTime = 0; } async initialize() { this.createDebugMesh(); this.createBody(); this.game.logger.log('Player', 'Player body created', 'Initialization'); } createBody() { if (this.game.world) { const radius = 0.5; const height = 2.0; const shape = new CANNON.Cylinder(radius, radius, height, 8); this.body = new CANNON.Body({ mass: 120, shape: shape, position: this.initialPosition.clone(), linearDamping: 0.0, fixedRotation: true, collisionFilterGroup: COLLISION_GROUPS.PLAYER, collisionFilterMask: COLLISION_GROUPS.PLAYER | COLLISION_GROUPS.WALL | COLLISION_GROUPS.FLOOR | COLLISION_GROUPS.ZOMBIE }); this.game.world.addBody(this.body); const playerPhysicsMaterial = new CANNON.Material('playerMaterial'); const groundPhysicsMaterial = new CANNON.Material('groundMaterial'); const zombiePhysicsMaterial = new CANNON.Material('zombieMaterial'); const wallPhysicsMaterial = new CANNON.Material('wallMaterial'); const playerGroundContact = new CANNON.ContactMaterial(playerPhysicsMaterial, groundPhysicsMaterial, { friction: 0.01, restitution: 0.1, contactEquationStiffness: 1e8, contactEquationRelaxation: 3 }); const playerZombieContact = new CANNON.ContactMaterial(playerPhysicsMaterial, zombiePhysicsMaterial, { friction: 0.01, restitution: 0.3, contactEquationStiffness: 1e8, contactEquationRelaxation: 3 }); const playerWallContact = new CANNON.ContactMaterial(playerPhysicsMaterial, wallPhysicsMaterial, { friction: 0.001, // Very low friction restitution: 0.001, // Very low restitution contactEquationStiffness: 1e9, // Higher stiffness for more responsive contacts contactEquationRelaxation: 1 // Lower relaxation for faster resolution }); this.game.world.addContactMaterial(playerGroundContact); this.game.world.addContactMaterial(playerZombieContact); this.game.world.addContactMaterial(playerWallContact); this.body.material = playerPhysicsMaterial; this.body.ccdSpeedThreshold = 1; this.body.ccdIterations = 5; this.body.addEventListener("collide", this.onCollide.bind(this)); // Apply wall material to existing walls this.game.getWalls().forEach(wall => { wall.bodies.forEach(body => { body.material = wallPhysicsMaterial; }); }); } else { console.error('Physics world not initialized when creating player'); } } takeDamage(amount) { if (!this.isDead && this.invulnerabilityTimer <= 0) { this.health -= amount; this.invulnerabilityTimer = this.invulnerabilityTime; if (this.health <= 0) { this.health = 0; this.die(); } // Call the showDamageOverlay method of the GameUIManager if (this.game.uiManager) { this.game.uiManager.showDamageOverlay(); } } } die() { if (!this.isDead) { this.isDead = true; this.keys = { w: false, a: false, s: false, d: false }; this.body.velocity.set(0, 0, 0); this.game.setState(this.game.states.LEVEL_RESET); } } reset() { this.health = this.maxHealth; this.isDead = false; this.lastDamageTime = 0; if (this.body) { this.game.world.removeBody(this.body); } this.createBody(); this.keys = { w: false, a: false, s: false, d: false }; if (this.game.healthBar) { this.game.healthBar.update(this.health, this.maxHealth); } this.game.camera.position.copy(this.initialPosition); this.game.camera.position.y += 0.8; // Adjust camera height this.game.logger.log('Player', 'Player reset to initial position', 'Initialization'); } getPosition() { if (this.body && this.body.position) { return new THREE.Vector3( this.body.position.x, this.body.position.y, this.body.position.z ); } return null; // Return null if the body or its position is not available } calculateDoorScreenPosition(doorPosition) { const vector = new THREE.Vector3(doorPosition.x, doorPosition.y, doorPosition.z); vector.project(this.game.camera); const widthHalf = this.game.parentDiv.clientWidth / 2; const heightHalf = this.game.parentDiv.clientHeight / 2; return { x: (vector.x * widthHalf) + widthHalf, y: -(vector.y * heightHalf) + heightHalf }; } update(deltaTime) { if (!this.isDead && this.body) { const moveDirection = new CANNON.Vec3(); const forward = new CANNON.Vec3( -Math.sin(this.camera.rotation.y), 0, -Math.cos(this.camera.rotation.y) ); const right = new CANNON.Vec3( Math.cos(this.camera.rotation.y), 0, -Math.sin(this.camera.rotation.y) ); if (this.keys.w) moveDirection.vadd(forward, moveDirection); if (this.keys.s) moveDirection.vsub(forward, moveDirection); if (this.keys.a) moveDirection.vsub(right, moveDirection); if (this.keys.d) moveDirection.vadd(right, moveDirection); if (moveDirection.lengthSquared() > 0) { moveDirection.normalize(); moveDirection.scale(this.moveSpeed, moveDirection); } this.body.velocity.x = moveDirection.x; this.body.velocity.z = moveDirection.z; this.body.velocity.y = this.body.velocity.y; this.camera.position.copy(this.body.position); this.camera.position.y += 0.8; if (this.body.position.y < this.game.playerStartHeight) { this.body.position.y = this.game.playerStartHeight; this.body.velocity.y = 0; } if (this.body.position.y < -10) { this.game.logger.log('Player', 'Player has fallen through the floor!', 'Error'); } if (this.debugMesh) { this.debugMesh.position.copy(this.body.position); } // Update invulnerability timer if (this.invulnerabilityTimer > 0) { this.invulnerabilityTimer -= deltaTime * 1000; // Convert deltaTime to milliseconds } // Check if door is in field of view this.checkDoorVisibility(); } } checkDoorVisibility() { const door = this.game.wallManager.getDoor(); if (!door) return; const doorVisibility = door.updateVisibility(this.body.position, this.camera, this.game.currentState); this.doorInFieldOfView = doorVisibility.isInFieldOfView; this.doorInRange = doorVisibility.isInRange; } onKeyDown(event) { if (event.key.toLowerCase() in this.keys) { this.keys[event.key.toLowerCase()] = true; } } onKeyUp(event) { if (event.key.toLowerCase() in this.keys) { this.keys[event.key.toLowerCase()] = false; } } onCollide(event) { const otherBody = event.body; const currentTime = Date.now(); if (otherBody.collisionFilterGroup === COLLISION_GROUPS.ZOMBIE) { const zombieDamage = 10; // Set the damage amount for zombie collisions this.takeDamage(zombieDamage); const collidedZombie = this.game.zombieSpawnManager.getZombies().find(zombie => zombie.body === otherBody); } } createDebugMesh() { const geometry = new THREE.CylinderGeometry(0.33, 0.33, 1.33, 8); const material = new THREE.MeshBasicMaterial({ color: 0x0000ff, wireframe: true }); this.debugMesh = new THREE.Mesh(geometry, material); this.debugMesh.visible = this.game.debugMode; this.game.scene.add(this.debugMesh); } } class Logger { constructor(logInterval = 5000, logLimit = 6000) { this.logs = {}; this.logInterval = logInterval; this.lastLogTime = Date.now(); this.colors = { 'Player': '#FF6B6B', 'CurrentScene': '#4ECDC4', 'Enemies': '#45B7D1', 'GameLoop': '#FFA07A', 'UI': '#98D8C8', 'Combat': '#32CD32', }; this.defaultColor = '#808080'; this.logLimit = logLimit; this.logCount = 0; } log(type, message, subcategory = 'General') { if (!this.logs[type]) { this.logs[type] = {}; } if (!this.logs[type][subcategory]) { this.logs[type][subcategory] = []; } this.logs[type][subcategory].push({ timestamp: Date.now(), message: message }); if (Date.now() - this.lastLogTime >= this.logInterval) { this.printLogs(); } } printLogs() { const currentTime = Date.now(); const formatTime = (timestamp) => { const date = new Date(timestamp); return date.toLocaleTimeString('en-US', { hour12: true }); }; if (this.logCount >= this.logLimit) { console.clear(); this.logCount = 0; console.log('%cConsole cleared due to log limit reached', 'color: #FF0000; font-weight: bold;'); } console.group(`%cLogs (${formatTime(this.lastLogTime)} - ${formatTime(currentTime)})`, 'color: #00008B; font-weight: bold;'); for (const [type, subcategories] of Object.entries(this.logs)) { const color = this.colors[type] || this.defaultColor; const totalLogs = Object.values(subcategories).reduce((sum, logs) => sum + logs.length, 0); console.groupCollapsed(`%c${type} (${totalLogs})`, `color: ${color}; font-weight: bold;`); for (const [subcategory, logs] of Object.entries(subcategories)) { if (logs.length > 0) { console.groupCollapsed(`%c${subcategory} (${logs.length})`, `color: ${color}; font-weight: normal;`); logs.forEach(log => { console.log(`%c[${formatTime(log.timestamp)}] ${log.message}`, `color: ${color};`); this.logCount++; }); console.groupEnd(); } } console.groupEnd(); } console.groupEnd(); this.logs = {}; this.lastLogTime = currentTime; } } class ZombieSpawnManager { constructor(game) { console.log('ZombieSpawnManager constructor called.'); this.game = game; this.spawnPoints = []; this.zombies = []; this.recentlyUsedSpawnPoints = []; this.mapSectors = []; this.sectorSpawnCounts = {}; // Base static assignments this.baseZombieSpeed = 3.5; this.zombieSpeedIncreaseRate = 0.2; this.maxZombieSpeed = 10; this.baseSpawnRate = 2; // Changed to seconds this.spawnRateDecreaseRate = 0.15; // Changed to seconds this.minSpawnRate = 0.3; // Changed to seconds this.baseSpawnCount = 8; this.spawnCountIncrement = 3; // New zombies added per wave this.maxSpawnCount = 40; this.initialSpawnCount = 8; // Dynamic assignments this.zombieSpeed = this.baseZombieSpeed; this.spawnRate = this.baseSpawnRate; this.spawnCount = this.baseSpawnCount; this.zombiesSpawned = 0; this.zombiesKilled = 0; this.spawnTimer = 0; this.testingMode = false; this.minSpawnDistanceFromPlayer = 10; // Minimum distance from player to spawn zombies console.log('ZombieSpawnManager initialized.'); } updateWaveSettings(waveNumber) { // Calculate andf update settings based on wave number this.zombieSpeed = Math.min(this.baseZombieSpeed + waveNumber * this.zombieSpeedIncreaseRate, this.maxZombieSpeed); this.spawnRate = Math.max(this.baseSpawnRate - waveNumber * this.spawnRateDecreaseRate, this.minSpawnRate); // New logic for spawn count calculation if (waveNumber > 1) { this.spawnCount = Math.min(this.baseSpawnCount + (this.spawnCountIncrement * waveNumber - 1), this.maxSpawnCount); } else { this.spawnCount = this.baseSpawnCount; } this.zombiesSpawned = 0; this.zombiesKilled = 0; console.log(`Wave ${waveNumber} settings updated:`, `Speed: ${this.zombieSpeed.toFixed(2)}, Rate: ${this.spawnRate}, ` + `Count: ${this.spawnCount}`); } isWaveComplete() { return this.zombiesKilled >= this.spawnCount; } resetForNewWave() { this.zombiesSpawned = 0; this.zombiesKilled = 0; } handleZombieHit(intersection) { const hitZombie = this.zombies.find(zombie => zombie.model === intersection.object.parent); if (hitZombie) { this.game.logger.log('Combat', `Zombie hit at: ${intersection.point.toArray().join(', ')}`, 'HitDetection'); hitZombie.takeDamage(1); this.game.visualizeImpact(intersection.point); } } clearSpawnPoints() { console.log('Clearing zombie spawn points'); this.spawnPoints = []; this.stopSpawnTimer(); console.log('Zombie spawn points cleared'); } setupSpawnPoints(currentMap) { if (!currentMap) { console.error('Current map is not available'); return; } const spawnPoints = currentMap.getZombieSpawnPoints(); console.log('Map spawn points:', spawnPoints); this.spawnPoints = Array.isArray(spawnPoints) ? spawnPoints : [spawnPoints]; console.log(`ZombieSpawnManager setup with ${this.spawnPoints.length} spawn points.`); // Initialize map sectors this.initializeMapSectors(); } initializeMapSectors() { const sectorSize = 10; // Adjust this value based on your map size const mapSize = this.game.ROOM_SIZE; const sectorsPerSide = Math.ceil(mapSize / sectorSize); for (let x = 0; x < sectorsPerSide; x++) { for (let z = 0; z < sectorsPerSide; z++) { this.mapSectors.push(`${x},${z}`); } } // Initialize sector spawn counts this.mapSectors.forEach(sector => { this.sectorSpawnCounts[sector] = 0; }); } setTestingMode(isEnabled) { this.testingMode = isEnabled; } spawnZombies() { this.clearZombies(); this.zombiesSpawned = 0; this.zombiesKilled = 0; if (this.testingMode) { // In testing mode, spawn only one zombie if (this.canSpawnZombie()) { this.spawnZombie(); } } else { // Normal mode: spawn initial zombies for (let i = 0; i < this.initialSpawnCount && this.canSpawnZombie(); i++) { this.spawnZombie(); } this.spawnTimer = 0; // Reset spawn timer } } spawnZombieIfNeeded(deltaTime) { if (this.canSpawnZombie()) { this.spawnTimer += deltaTime; if (this.spawnTimer >= this.spawnRate) { this.spawnZombie(); this.spawnTimer -= this.spawnRate; // Reset timer, keeping leftover time } } } selectSpawnPoint() { const playerPosition = this.game.player.getPosition(); if (!playerPosition) { console.warn('Player position not available. Using default spawn point selection.'); return this.defaultSpawnPointSelection(); } // Filter out recently used spawn points and those too close to the player const availableSpawnPoints = this.spawnPoints.filter(sp => { const distanceToPlayer = Math.sqrt( Math.pow(sp.x - playerPosition.x, 2) + Math.pow(sp.z - playerPosition.z, 2) ); if (distanceToPlayer < this.minSpawnDistanceFromPlayer) { return false; } return !this.recentlyUsedSpawnPoints.includes(sp); }); if (availableSpawnPoints.length === 0) { console.log('No valid spawn points available. Resetting recently used spawn points.'); this.recentlyUsedSpawnPoints = []; return this.defaultSpawnPointSelection(); } // Calculate weights for each spawn point based on sector balance const weights = availableSpawnPoints.map(sp => { const sector = this.getSectorForPoint(sp); const sectorCount = this.sectorSpawnCounts[sector] || 0; return 1 / (sectorCount + 1); // Higher weight for less used sectors }); // Select a spawn point using weighted random selection const totalWeight = weights.reduce((sum, weight) => sum + weight, 0); let randomValue = Math.random() * totalWeight; let selectedIndex = 0; for (let i = 0; i < weights.length; i++) { randomValue -= weights[i]; if (randomValue <= 0) { selectedIndex = i; break; } } const selectedSpawnPoint = availableSpawnPoints[selectedIndex]; this.updateRecentlyUsedSpawnPoints(selectedSpawnPoint); return selectedSpawnPoint; } defaultSpawnPointSelection() { // Fallback to the original selection method if no valid points are available return this.spawnPoints[Math.floor(Math.random() * this.spawnPoints.length)]; } updateRecentlyUsedSpawnPoints(selectedSpawnPoint) { this.recentlyUsedSpawnPoints.push(selectedSpawnPoint); if (this.recentlyUsedSpawnPoints.length > Math.min(5, this.spawnPoints.length / 2)) { this.recentlyUsedSpawnPoints.shift(); } const sector = this.getSectorForPoint(selectedSpawnPoint); this.sectorSpawnCounts[sector] = (this.sectorSpawnCounts[sector] || 0) + 1; } getSectorForPoint(point) { // Implement logic to determine which sector a point belongs to // This is a simple example; you may need to adjust based on your map structure const sectorSize = 10; // Adjust this value based on your map size const x = Math.floor(point.x / sectorSize); const z = Math.floor(point.z / sectorSize); return `${x},${z}`; } canSpawnZombie() { return this.zombiesSpawned < this.spawnCount && this.game.currentState === this.game.states.PLAYING; } spawnZombie() { if (!this.canSpawnZombie()) { this.stopSpawnTimer(); return; } const spawnPoint = this.selectSpawnPoint(); if (spawnPoint && spawnPoint.x !== undefined && spawnPoint.z !== undefined) { const zombiePosition = new THREE.Vector3(spawnPoint.x, 0, spawnPoint.z); const zombie = new Zombie(this.game, this.game.scene, zombiePosition, this.zombieSpeed, THREE, CANNON); zombie.loadModel().then(() => { if (this.game.waypointManager.getWaypoints().length > 0) { this.setZombiePath(zombie); this.zombies.push(zombie); this.zombiesSpawned++; } else { console.warn('No waypoints available for zombie pathing'); } }).catch(error => { console.error('Failed to load zombie model:', error); setTimeout(() => this.spawnZombieIfNeeded(), 1000); }); } else { console.warn('Invalid spawn point:', spawnPoint); setTimeout(() => this.spawnZombieIfNeeded(), 1000); } } markAllZombiesAsDead() { const livingZombies = this.zombies.filter(zombie => !zombie.isDead); livingZombies.forEach(zombie => { zombie.isDead = true; // Optionally, stop any ongoing zombie behaviors here // For example: zombie.stopAllBehaviors(); }); console.log(`Marked ${livingZombies.length} zombies as dead. Total zombies: ${this.zombies.length}`); } setZombiePath(zombie) { const waypoints = this.game.waypointManager.getWaypoints(); zombie.setPath(waypoints); } stopSpawnTimer() { if (this.spawnTimer) { clearInterval(this.spawnTimer); this.spawnTimer = null; } } spawnZombieIfNeeded() { if (this.zombiesSpawned < this.spawnCount) { this.spawnZombie(); } else { this.stopSpawnTimer(); } } clearZombies() { const zombiesToRemove = this.zombies.filter(zombie => zombie.isDead); zombiesToRemove.forEach(zombie => { this.game.world.removeBody(zombie.body); this.game.scene.remove(zombie.model); zombie.cleanup(); }); this.zombies = this.zombies.filter(zombie => !zombie.isDead); } getZombies() { return this.zombies; } incrementKilledCount() { this.zombiesKilled++; } } const ZombieState = { PATROL: 'PATROL', CHASE: 'CHASE' }; class Zombie { static nextId = 0; constructor(game, scene, position, speed, THREE, CANNON) { // Base static assignments this.game = game; this.scene = scene; this.position = position; this.THREE = THREE; this.CANNON = CANNON; this.speed = speed; this.health = 2; this.isDead = false; this.flashDuration = 200; this.attackRange = 2.5; this.attackCooldown = 2; // Attack cooldown in seconds this.damage = 10; this.waypointThreshold = 1.0; this.pathUpdateInterval = 5; // Path update interval in seconds this.turnRate = Math.PI; // Radians per second this.targetRotation = 0; this.repulsionStrength = 0.3; // Decreased from 0.5 to 0.3 to maintain direction towards player this.repulsionDistance = 3; // Minimum distance before repulsion takes effect this.losTimeout = 2000; // Time in milliseconds before changing state after losing sight this.lastLOSTime = Date.now(); // Last time the zombie had line of sight to the player // Dynamic assignments and calculations this.id = Zombie.nextId++; this.model = null; this.lastHitTime = 0; this.isAttacking = false; this.currentState = ZombieState.PATROL; this.direction = new CANNON.Vec3(1, 0, 0); this.goalPosition = null; this.currentPath = []; this.currentPathIndex = 0; this.debugMesh = null; // Timer properties this.stateTimer = 0; this.minStateTime = 3; // Minimum time (in seconds) before a state can change this.attackTimer = 0; this.pathUpdateTimer = 0; // Material definitions this.glowingMaterial = new THREE.MeshStandardMaterial({ color: 0x00ff00, emissive: 0x00ff00, emissiveIntensity: 0.7, metalness: 0.3, roughness: 0.4 }); this.hitMaterial = new THREE.MeshStandardMaterial({ color: 0xff0000, emissive: 0xff0000, emissiveIntensity: 0.7, metalness: 0.3, roughness: 0.4 }); // Initialize components this.raycaster = new THREE.Raycaster(); this.initializePhysics(); } initializePhysics() { const radius = 0.1; // Reduced by ~33% const height = 1.33; // Reduced by ~33% const shape = new this.CANNON.Cylinder(radius, radius, height, 16); this.body = new this.CANNON.Body({ mass: 80, shape: shape, position: new this.CANNON.Vec3(this.position.x, this.position.y + height / 2, this.position.z), material: new this.CANNON.Material('zombieMaterial'), linearDamping: 0.0, angularDamping: 0.0, fixedRotation: true }); this.body.ccdSpeedThreshold = 1; this.body.ccdIterations = 5; this.body.collisionFilterGroup = COLLISION_GROUPS.ZOMBIE; this.body.collisionFilterMask = COLLISION_GROUPS.PLAYER | COLLISION_GROUPS.WALL | COLLISION_GROUPS.FLOOR | COLLISION_GROUPS.ZOMBIE; const zombieGroundContact = new this.CANNON.ContactMaterial( this.body.material, this.game.world.defaultMaterial, { friction: 0.5, restitution: 0.3, contactEquationStiffness: 1e8, contactEquationRelaxation: 3 } ); this.game.world.addContactMaterial(zombieGroundContact); // Add zombie-wall contact material const wallPhysicsMaterial = new this.CANNON.Material('wallMaterial'); const zombieWallContact = new this.CANNON.ContactMaterial(this.body.material, wallPhysicsMaterial, { friction: 0.001, // Very low friction restitution: 0.001, // Very low restitution contactEquationStiffness: 1e9, // Higher stiffness for more responsive contacts contactEquationRelaxation: 1 // Lower relaxation for faster resolution }); this.game.world.addContactMaterial(zombieWallContact); this.body.addEventListener("collide", this.onCollide.bind(this)); this.game.world.addBody(this.body); this.body.velocity.set(this.direction.x * this.speed, 0, this.direction.z * this.speed); this.currentWaypointIndex = 0; this.path = []; this.waypointThreshold = 1.0; } createDebugMesh() { const geometry = new this.THREE.CylinderGeometry(0.5, 0.5, 2.0, 16); const material = new this.THREE.MeshBasicMaterial({ color: 0xff0000, wireframe: true }); this.debugMesh = new this.THREE.Mesh(geometry, material); this.scene.add(this.debugMesh); this.updateDebugVisibility(this.game.debugMode); } updateDebugVisibility(isVisible) { if (this.debugMesh) { this.debugMesh.visible = isVisible; } if (this.pathLine) { this.pathLine.visible = isVisible; } if (this.stateLabel) { this.stateLabel.visible = isVisible; } } setPath(waypoints) { this.path = waypoints; const efficientWaypoint = this.findMostEfficientWaypointInLOS(); if (efficientWaypoint) { this.currentWaypointIndex = this.path.indexOf(efficientWaypoint); } } findMostEfficientWaypointInLOS() { let bestWaypoint = null; let shortestPathLength = Infinity; const playerPosition = this.game.player.body.position; const zombiePosition = this.body.position; for (const waypoint of this.game.waypointManager.waypoints) { if (this.checkLOSToWaypoint(waypoint)) { const distanceToWaypoint = zombiePosition.distanceTo(waypoint.position); // Calculate the path from waypoint to player const pathToPlayer = this.game.waypointManager.getPath(waypoint.position, playerPosition); if (pathToPlayer) { // Calculate the total path length let pathLength = distanceToWaypoint; // Start with distance to waypoint for (let i = 0; i < pathToPlayer.length - 1; i++) { pathLength += pathToPlayer[i].position.distanceTo(pathToPlayer[i + 1].position); } if (pathLength < shortestPathLength) { shortestPathLength = pathLength; bestWaypoint = waypoint; } } } } return bestWaypoint; } checkLOSToWaypoint(waypoint) { const raycaster = new THREE.Raycaster(); const zombiePosition = new THREE.Vector3(this.body.position.x, this.body.position.y + 1, this.body.position.z); const direction = new THREE.Vector3().subVectors(waypoint.position, zombiePosition).normalize(); raycaster.set(zombiePosition, direction); raycaster.layers.set(1); // Set raycaster to use layer 1 (walls) const intersects = raycaster.intersectObjects(this.game.scene.children, true) .filter(intersect => intersect.object.userData.isWall); return intersects.length === 0; } moveToNextWaypoint() { if (this.path.length === 0) return; if (this.hasReachedWaypoint()) { this.chooseNextWaypoint(); } this.moveTowardsWaypoint(); } hasReachedWaypoint() { const currentWaypoint = this.path[this.currentWaypointIndex]; const zombiePosition = new THREE.Vector3(this.body.position.x, this.body.position.y, this.body.position.z); const distanceToWaypoint = zombiePosition.distanceTo(currentWaypoint.position); return distanceToWaypoint < this.waypointThreshold; } chooseNextWaypoint() { const currentWaypoint = this.path[this.currentWaypointIndex]; const accessibleWaypoints = currentWaypoint.accessibleWaypoints.filter(wp => wp !== currentWaypoint); if (accessibleWaypoints.length > 0) { const randomIndex = Math.floor(Math.random() * accessibleWaypoints.length); const nextWaypoint = accessibleWaypoints[randomIndex]; this.currentWaypointIndex = this.path.indexOf(nextWaypoint); console.log(`Zombie ${this.id}: Moving to random waypoint ${this.currentWaypointIndex}`); } else { console.log(`Zombie ${this.id}: No accessible waypoints from current position`); } } moveTowardsWaypoint() { const targetWaypoint = this.path[this.currentWaypointIndex]; const direction = new CANNON.Vec3( targetWaypoint.position.x - this.body.position.x, 0, targetWaypoint.position.z - this.body.position.z ); direction.normalize(); this.body.velocity.set( direction.x * this.speed, this.body.velocity.y, direction.z * this.speed ); } onCollide(event) { if (!this.body || !this.body.position) { return; } const otherBody = event.body; if (!otherBody || !otherBody.position) { return; } const zombiePos = this.body.position; const otherPos = otherBody.position; const distance = zombiePos.distanceTo(otherPos); const relativeVelocity = event.contact ? event.contact.getImpactVelocityAlongNormal() : 0; let collisionType = 'Unknown'; if (otherBody.collisionFilterGroup === COLLISION_GROUPS.WALL) { collisionType = 'Wall'; } else if (otherBody.collisionFilterGroup === COLLISION_GROUPS.PLAYER) { collisionType = 'Player'; } else if (otherBody.collisionFilterGroup === COLLISION_GROUPS.FLOOR) { collisionType = 'Floor'; } else if (otherBody.collisionFilterGroup === COLLISION_GROUPS.ZOMBIE) { collisionType = 'Other Zombie'; } } async loadModel() { const characterModel = this.game.assetLoader.getAsset('characterModel'); if (!characterModel) { return; } this.model = characterModel.clone(); this.model.position.copy(this.body.position); this.model.position.y -= 0.5; // Adjust model position to align with physics body this.model.scale.set(0.2, 0.2, 0.2); this.model.rotation.y = Math.PI; // Rotate the model to face the correct direction // Apply glowing material to all meshes in the model and set isZombie flag this.model.traverse((child) => { if (child.isMesh) { child.material = this.glowingMaterial; child.userData.isZombie = true; child.userData.zombieInstance = this; // Add reference to this zombie instance } }); this.scene.add(this.model); this.createDebugMesh(); // Add this line to create the debug mesh this.createStateLabel(); // Create the state label } updateStateTimer(deltaTime) { this.stateTimer += deltaTime; } canChangeState() { return this.stateTimer >= this.minStateTime; } resetStateTimer() { this.stateTimer = 0; this.lastStateChangeTime = Date.now(); } setState(newState) { if (!newState || typeof newState !== 'string') { console.error(`Invalid state provided for zombie ${this.id}`); return; } if (this.currentState !== newState && this.stateTimer >= this.minStateTime) { this.currentState = newState; this.stateTimer = 0; try { this.onEnterState(newState); } catch (error) { console.error(`Error in onEnterState for zombie ${this.id}:`, error); } } } update(camera, deltaTime) { if (!this.model || !this.body || !this.body.position) { console.warn(`Zombie ${this.id}: Model, body, or position is undefined. Attempting to recover.`); this.recoverFromError(); return; } try { // Update timers this.stateTimer += deltaTime; this.attackTimer += deltaTime; this.pathUpdateTimer += deltaTime; this.updateGoalPosition(); const hasLOS = this.checkPlayerLOS(); const currentTime = Date.now(); if (hasLOS) { this.lastLOSTime = currentTime; if (this.currentState !== ZombieState.CHASE) { this.setState(ZombieState.CHASE); } } else if (this.currentState === ZombieState.CHASE && currentTime - this.lastLOSTime > this.losTimeout) { this.setState(ZombieState.PATROL); } if (this.currentState) { this.updateState(); } else { console.warn(`Zombie ${this.id}: Current state is undefined. Setting to PATROL.`); this.setState(ZombieState.PATROL); } this.updatePosition(deltaTime); this.updateVisuals(); this.updateCurrentPath(); } catch (error) { console.error(`Error in zombie ${this.id} update method:`, error.message); this.recoverFromError(); } } recoverFromError() { console.warn(`Attempting to recover zombie ${this.id}`); if (!this.body || !this.body.position) { this.initializePhysics(); } if (!this.model) { this.loadModel(); } this.setState(ZombieState.PATROL); } updateCurrentPath() { if (this.pathUpdateTimer >= this.pathUpdateInterval) { // Update the current path logic here, regardless of debug mode if (this.currentState === ZombieState.PATROL) { this.updatePatrolPath(); } else if (this.currentState === ZombieState.CHASE) { this.updateChasePath(); } this.pathUpdateTimer = 0; } } updatePatrolPath() { this.updatePath(); } updateChasePath() { const playerPosition = this.game.player.body.position; this.currentPath = this.game.waypointManager.getPath(this.body.position, playerPosition) || []; this.currentPathIndex = 0; } updateState() { if (!this.currentState) { console.warn(`Zombie ${this.id}: Current state is undefined. Setting to PATROL.`); this.setState(ZombieState.PATROL); return; } try { switch (this.currentState) { case ZombieState.PATROL: this.updatePatrolState(); break; case ZombieState.CHASE: this.updateChaseState(); break; default: console.error(`Invalid zombie state: ${this.currentState}`); this.setState(ZombieState.PATROL); } if (this.isPlayerInRange()) { this.attackPlayer(); } } catch (error) { console.error(`Error in updateState for zombie ${this.id}:`, error); this.setState(ZombieState.PATROL); } } updatePosition(deltaTime) { if (this.body.position.y < 1.0) { this.body.position.y = 1.0; } this.model.position.copy(this.body.position); this.model.position.y -= 1.0; if (this.body.velocity.lengthSquared() > 0.1) { this.targetRotation = Math.atan2(-this.body.velocity.x, -this.body.velocity.z); const currentRotation = this.model.rotation.y; const angleDifference = (this.targetRotation - currentRotation + Math.PI) % (2 * Math.PI) - Math.PI; const rotationStep = Math.sign(angleDifference) * Math.min(Math.abs(angleDifference), this.turnRate * deltaTime); this.model.rotation.y += rotationStep; } } updateVisuals() { if (this.debugMesh) { this.debugMesh.position.copy(this.body.position); this.debugMesh.quaternion.copy(this.body.quaternion); this.debugMesh.visible = this.game.debugMode; } // Handle hit flash effect if (Date.now() - this.lastHitTime < this.flashDuration) { this.model.traverse((child) => { if (child.isMesh) { child.material = this.hitMaterial; } }); } else { this.model.traverse((child) => { if (child.isMesh) { child.material = this.glowingMaterial; } }); } // Update state label this.updateStateDebugCube(); } updateStateDebugCube() { if (this.stateLabel) { this.stateLabel.visible = this.game.debugMode; if (this.game.debugMode) { this.stateLabel.position.copy(this.body.position); this.stateLabel.position.y += 2; // Position above the zombie this.updateStateLabel(this.currentState); } } } recoverFromError() { console.warn(`Attempting to recover zombie ${this.id}`); if (!this.body || !this.body.position) { this.initializePhysics(); } if (!this.model) { this.loadModel(); } this.setState(ZombieState.PATROL); } updatePatrolState() { if (!this.body || !this.body.position) { return; } const currentTime = Date.now(); if (currentTime - this.lastPathUpdateTime > this.pathUpdateInterval) { this.updatePath(); this.lastPathUpdateTime = currentTime; } if (this.currentPath && this.currentPath.length > 0) { const targetWaypoint = this.currentPath[this.currentPathIndex]; if (targetWaypoint && targetWaypoint.position) { const distance = this.body.position.distanceTo(targetWaypoint.position); if (distance < this.waypointThreshold) { this.currentPathIndex++; if (this.currentPathIndex >= this.currentPath.length) { this.updatePath(); } } else { this.moveTowardsPosition(targetWaypoint.position); } } else { this.updatePath(); } } else { this.updatePath(); } if (this.game.debugMode) { this.visualizeCurrentPath(); } } updatePath() { const playerPosition = this.game.player.body.position; const zombiePosition = this.body.position; this.currentPath = this.game.waypointManager.getPath(zombiePosition, playerPosition) || []; this.currentPathIndex = 0; if (this.currentPath.length > 0) { const efficientWaypoint = this.findMostEfficientWaypointInLOS(); if (efficientWaypoint) { this.currentPathIndex = this.currentPath.indexOf(efficientWaypoint); } } } moveTowardsPosition(targetPosition) { if (!this.body || !this.body.position || !this.body.velocity) { return; } if (!targetPosition || typeof targetPosition.x !== 'number' || typeof targetPosition.z !== 'number') { return; } const direction = new CANNON.Vec3( targetPosition.x - this.body.position.x, 0, targetPosition.z - this.body.position.z ); if (direction.length() === 0) { return; } direction.normalize(); this.body.velocity.set( direction.x * this.speed, this.body.velocity.y, direction.z * this.speed ); } moveRandomly() { if (Math.random() < 0.02) { // Change direction roughly every 3 seconds (assuming 60 FPS) const angle = Math.random() * Math.PI * 2; this.body.velocity.set( Math.cos(angle) * this.speed, this.body.velocity.y, Math.sin(angle) * this.speed ); } } updateChaseState() { if (this.game.player && this.game.player.body && this.game.player.body.position) { const playerPosition = this.game.player.body.position; const zombiePosition = this.body.position; let direction = new CANNON.Vec3( playerPosition.x - zombiePosition.x, 0, playerPosition.z - zombiePosition.z ); direction.normalize(); // Calculate repulsion force const repulsionForce = this.calculateRepulsionForce(); // Check for nearby walls and adjust direction const wallAvoidanceDirection = this.getWallAvoidanceDirection(); // Combine all forces direction.vadd(wallAvoidanceDirection, direction); direction.vadd(repulsionForce, direction); direction.normalize(); const newVelocity = new CANNON.Vec3( direction.x * this.speed, this.body.velocity.y, direction.z * this.speed ); this.body.velocity.copy(newVelocity); } else { // If player position is not available, transition to PATROL state this.setState(ZombieState.PATROL); } // Only recalculate the path if enough time has passed const currentTime = Date.now(); if (currentTime - this.lastPathUpdateTime >= this.pathUpdateCooldown) { if (!this.currentPath || this.currentPath.length === 0) { console.warn(`Zombie ${this.id}: Current path is undefined or empty in CHASE state. Recalculating path.`); this.updateChasePath(); } this.lastPathUpdateTime = currentTime; } } getWallAvoidanceDirection() { const avoidanceDirection = new CANNON.Vec3(0, 0, 0); const zombiePosition = this.body.position; const rayDirections = [ new CANNON.Vec3(1, 0, 0), new CANNON.Vec3(-1, 0, 0), new CANNON.Vec3(0, 0, 1), new CANNON.Vec3(0, 0, -1), new CANNON.Vec3(1, 0, 1).normalize(), new CANNON.Vec3(1, 0, -1).normalize(), new CANNON.Vec3(-1, 0, 1).normalize(), new CANNON.Vec3(-1, 0, -1).normalize() ]; const raycaster = new THREE.Raycaster(); const wallDetectionDistance = 4; // Distance to detect walls const raycastVerticalOffset = 0.5; // Offset for raycast origin const avoidanceStrength = 0.65; // Reduced from 1.5 to 0.3 for subtler avoidance const wallLayer = 1; // Layer for wall objects rayDirections.forEach(direction => { const rayOrigin = new THREE.Vector3( zombiePosition.x, zombiePosition.y + raycastVerticalOffset, zombiePosition.z ); const rayDirection = new THREE.Vector3(direction.x, direction.y, direction.z); raycaster.set(rayOrigin, rayDirection); raycaster.layers.set(wallLayer); const intersects = raycaster.intersectObjects(this.game.scene.children, true) .filter(intersect => intersect.object.userData.isWall); if (intersects.length > 0 && intersects[0].distance < wallDetectionDistance) { const distanceToWall = intersects[0].distance; const avoidanceForce = (wallDetectionDistance - distanceToWall) * avoidanceStrength; avoidanceDirection.x -= direction.x * avoidanceForce; avoidanceDirection.z -= direction.z * avoidanceForce; } }); return avoidanceDirection; } checkPlayerLOS() { if (!this.raycaster) { try { this.raycaster = new THREE.Raycaster(); } catch (error) { console.error('Failed to create Raycaster:', error); return false; } } if (!this.body?.position || !this.game?.player?.body?.position) { console.warn('Missing required properties for LOS check'); return false; } const zombiePosition = this.body.position; const playerPosition = this.game.player.body.position; const direction = new THREE.Vector3().subVectors(playerPosition, zombiePosition).normalize(); const distanceToPlayer = zombiePosition.distanceTo(playerPosition); // Cast a single ray toward the player this.raycaster.set(zombiePosition, direction); const intersects = this.raycaster.intersectObjects(this.game.scene.children, true) .filter(intersect => intersect.object?.userData?.isWall || intersect.object?.userData?.isZombie); // Check if any intersecting object blocks the line of sight const hasLOS = !(intersects.length > 0 && intersects[0].distance < distanceToPlayer); if (hasLOS) { this.lastLOSTime = Date.now(); } return hasLOS; } updateDebugVisualization(zombiePosition, playerPosition, intersects) { // Debug line visualization if (!this.losDebugLine) { this.losDebugLine = new DebugLine(this.game.scene, zombiePosition, playerPosition, 0xff0000); } else { this.losDebugLine.updatePositions(zombiePosition, playerPosition); } this.losDebugLine.setVisibility(this.game.debugMode); // Intersection point visualization if (this.game.debugMode) { intersects.forEach(intersect => { const sphere = new THREE.Mesh( new THREE.SphereGeometry(0.1), new THREE.MeshBasicMaterial({ color: 0xff0000 }) ); sphere.position.copy(intersect.point); this.game.scene.add(sphere); setTimeout(() => this.game.scene.remove(sphere), 1000); }); } } setState(newState) { if (!newState || typeof newState !== 'string') { console.error(`Invalid state provided for zombie ${this.id}`); return; } const currentTime = Date.now(); if (this.currentState !== newState) { if (newState === ZombieState.PATROL && currentTime - this.lastLOSTime <= this.losTimeout) { // Don't change to PATROL if we've seen the player recently return; } this.currentState = newState; try { this.onEnterState(newState); } catch (error) { console.error(`Error in onEnterState for zombie ${this.id}:`, error); } } } onEnterState(state) { this.updateStateLabel(state); } createStateLabel() { const geometry = new THREE.BoxGeometry(0.5, 0.5, 0.5); const material = new THREE.MeshBasicMaterial({ color: 0xffff00 }); this.stateLabel = new THREE.Mesh(geometry, material); this.stateLabel.visible = false; this.scene.add(this.stateLabel); } updateStateLabel(state) { if (this.stateLabel) { switch (state) { case ZombieState.PATROL: this.stateLabel.material.color.setHex(0x00ff00); // Green for patrol break; case ZombieState.CHASE: this.stateLabel.material.color.setHex(0xff0000); // Red for chase break; default: this.stateLabel.material.color.setHex(0xffff00); // Yellow for unknown state } } } updateDebugLine() { if (this.debugLine) { const positions = this.debugLine.geometry.attributes.position.array; const zombiePos = this.body.position; const targetWaypoint = this.path[this.currentWaypointIndex]; // Set start point of the line (zombie position) positions[0] = zombiePos.x; positions[1] = zombiePos.y; positions[2] = zombiePos.z; // Set end point of the line (current target waypoint position) positions[3] = targetWaypoint.position.x; positions[4] = targetWaypoint.position.y; positions[5] = targetWaypoint.position.z; this.debugLine.geometry.attributes.position.needsUpdate = true; // Update line color based on LOS const hasLOS = this.checkLOSToWaypoint(targetWaypoint); this.debugLine.material.color.setHex(hasLOS ? 0x00ff00 : 0xff0000); } } isPlayerInRange() { const zombiePosition = this.body.position; const playerPosition = this.game.player.body.position; const distance = zombiePosition.distanceTo(playerPosition); return distance <= this.attackRange; } attackPlayer() { if (this.attackTimer >= this.attackCooldown) { this.game.player.takeDamage(this.damage); this.attackTimer = 0; // Play the bite sound using AudioPlayer this.game.audioPlayer.playBiteSound(); } } // The updateSearchState method has been removed takeDamage(amount) { this.health -= amount; this.lastHitTime = Date.now(); if (this.health <= 0) { this.die(); } } playDeathSound() { if (this.game.zombieDeathSounds && this.game.zombieDeathSounds.length > 0) { const randomIndex = Math.floor(Math.random() * this.game.zombieDeathSounds.length); const sound = this.game.zombieDeathSounds[randomIndex]; if (sound) { sound.currentTime = 0; // Set the volume according to the asset configuration sound.volume = this.game.assetConfig[`zombieDeathSound${randomIndex + 1}`].volume; sound.play(); } } } die() { if (!this.isDead) { this.isDead = true; try { this.playDeathSound(); this.game.zombieSpawnManager.incrementKilledCount(); this.game.waveManager.checkWaveComplete(); } catch (error) { console.error('Error during zombie death:', error); } } } cleanup() { if (this.model) { this.scene.remove(this.model); } if (this.debugMesh) { this.scene.remove(this.debugMesh); this.debugMesh.geometry.dispose(); this.debugMesh.material.dispose(); this.debugMesh = null; } if (this.body) { this.game.world.removeBody(this.body); this.body = null; } } updateGoalPosition() { const currentTime = Date.now(); if (currentTime - this.lastGoalUpdateTime >= 1000) { // Update every 1 second this.goalPosition = this.game.player.body.position.clone(); this.lastGoalUpdateTime = currentTime; } } calculateRepulsionForce() { const repulsionForce = new CANNON.Vec3(0, 0, 0); const zombies = this.game.zombieSpawnManager.getZombies(); for (const otherZombie of zombies) { if (otherZombie !== this && !otherZombie.isDead) { const distance = this.body.position.distanceTo(otherZombie.body.position); if (distance < this.repulsionDistance) { const direction = new CANNON.Vec3().copy(this.body.position).vsub(otherZombie.body.position); direction.normalize(); const force = direction.scale(this.repulsionStrength * (1 - distance / this.repulsionDistance)); repulsionForce.vadd(force, repulsionForce); } } } return repulsionForce; } } class Waypoint { constructor(scene, x, z) { this.position = new THREE.Vector3(x, 0.1, z); // Slightly above the floor this.accessibleWaypoints = []; this.createVisual(scene); } createVisual(scene) { const geometry = new THREE.BoxGeometry(0.5, 0.5, 0.5); // Changed to cube const material = new THREE.MeshBasicMaterial({ color: 0xff0000 }); this.mesh = new THREE.Mesh(geometry, material); this.mesh.position.copy(this.position); this.mesh.visible = false; // Set to invisible by default scene.add(this.mesh); } updateVisibility(isVisible) { if (this.mesh) { this.mesh.visible = isVisible; } } addAccessibleWaypoint(waypoint) { if (!this.accessibleWaypoints.includes(waypoint)) { this.accessibleWaypoints.push(waypoint); } } } class DebugLine { constructor(scene, startPoint, endPoint, color = 0x00ff00, linewidth = 1) { this.scene = scene; this.startPoint = startPoint.clone(); this.endPoint = endPoint.clone(); this.color = color; this.linewidth = linewidth; this.line = null; this.createLine(); } createLine() { const geometry = new THREE.BufferGeometry().setFromPoints([ this.startPoint, this.endPoint ]); const material = new THREE.LineBasicMaterial({ color: this.color, linewidth: this.linewidth }); this.line = new THREE.Line(geometry, material); this.line.visible = false; // Initially invisible this.scene.add(this.line); } setVisibility(isVisible) { if (this.line) { this.line.visible = isVisible; } } updatePositions(startPoint, endPoint) { this.startPoint.copy(startPoint); this.endPoint.copy(endPoint); const positions = this.line.geometry.attributes.position.array; positions[0] = startPoint.x; positions[1] = startPoint.y; positions[2] = startPoint.z; positions[3] = endPoint.x; positions[4] = endPoint.y; positions[5] = endPoint.z; this.line.geometry.attributes.position.needsUpdate = true; } remove() { if (this.line) { this.scene.remove(this.line); this.line.geometry.dispose(); this.line.material.dispose(); this.line = null; } } } const mapDataList = [ 'https://play.rosebud.ai/assets/bigMap01.json?bvJx', 'https://play.rosebud.ai/assets/bigMap02.json?MZMD', 'https://play.rosebud.ai/assets/bigMap03.json?BpfA', ]; const game = new Game(parentDiv, mapDataList); game.init();