import * as THREE from 'three'; import { OrbitControls } from 'three/addons/controls/OrbitControls.js'; import { EffectComposer } from 'three/addons/postprocessing/EffectComposer.js'; import { RenderPass } from 'three/addons/postprocessing/RenderPass.js'; import { UnrealBloomPass } from 'three/addons/postprocessing/UnrealBloomPass.js'; import { SMAAPass } from 'three/addons/postprocessing/SMAAPass.js'; import { FBXLoader } from 'three/addons/loaders/FBXLoader.js'; import { OBJLoader } from 'three/addons/loaders/OBJLoader.js'; import { GLTFLoader } from 'three/addons/loaders/GLTFLoader.js'; import { BasicSkyShader, MaterialManager, LightingManager, MeshManager, } from 'https://play.rosebud.ai/assets/ThreeJSScripts.js?hZgy'; const SCRIPT_ASSETS = [{ name: "script_waveManager", url: "https://play.rosebud.ai/assets/script_waveManager.js?XvZe", }, { name: "script_enemyManager", url: "https://play.rosebud.ai/assets/script_enemyManager.js?hiTN", }, { name: "script_enemyLoader", url: "https://play.rosebud.ai/assets/script_enemyLoader.js?dJBV", }, { name: "script_gunConfigs", url: "https://play.rosebud.ai/assets/script_gunConfigs.js?dQmR", }, { name: "script_hud", url: "https://play.rosebud.ai/assets/script_hud.js?ILA5", }, { name: "script_gun", url: "https://play.rosebud.ai/assets/script_gun.js?tno0", }, { name: "script_gunManager", url: "https://play.rosebud.ai/assets/script_gunManager.js?gIgy", }, { name: "script_gunController", url: "https://play.rosebud.ai/assets/script_gunController.js?uwz2", }, { name: "script_imageLoader", url: "https://play.rosebud.ai/assets/script_imageLoader.js?WOO6", }, { name: "script_gunHUDContainer", url: "https://play.rosebud.ai/assets/script_gunHUDContainer.js?ud4U", }, { name: "script_gunLoadoutPanel", url: "https://play.rosebud.ai/assets/script_gunLoadoutPanel.js?eUZI", }, { name: "script_ammoDisplay", url: "https://play.rosebud.ai/assets/script_ammoDisplay.js?1fAj", }, { name: "script_modelLoader", url: "https://play.rosebud.ai/assets/script_modelLoader.js?Q3eR", }, { name: "script_gunMount", url: "https://play.rosebud.ai/assets/script_gunMount.js?U0JM", }, { name: "script_enemyAnimationController", url: "https://play.rosebud.ai/assets/script_enemyAnimationController.js?NkNJ", }, { name: "script_skybox", url: "https://play.rosebud.ai/assets/script_skybox.js?zcTS", }, { name: "script_particleEffect", url: "https://play.rosebud.ai/assets/script_particleEffect.js?sS2f", }, { name: "script_tilemapGen", url: "https://play.rosebud.ai/assets/script_tilemapGen.js?MxBz", }, { name: "script_tilemap", url: "https://play.rosebud.ai/assets/script_tilemap.js?lD0A", }, { name: "script_obstacle", url: "https://play.rosebud.ai/assets/script_obstacle.js?mlER", }, { name: "script_tile", url: "https://play.rosebud.ai/assets/script_tile.js?6zQm", }, { name: "script_wall", url: "https://play.rosebud.ai/assets/script_wall.js?Ee3J", }, { name: "script_crosshair", url: "https://play.rosebud.ai/assets/script_crosshair.js?Iyom" }, { name: "script_waveTracker", url: "https://play.rosebud.ai/assets/script_waveTracker.js?C7jJ" }, { name: "script_visibleRay", url: "https://play.rosebud.ai/assets/script_visibleRay.js?0uMy" }, { name: "script_cameraController", url: "https://play.rosebud.ai/assets/script_cameraController.js?cejF" }, { name: "script_audioManager", url: "https://play.rosebud.ai/assets/script_audioManager.js?atO4" }, { name: "script_ray", url: "https://play.rosebud.ai/assets/script_ray.js?83cF" }, { name: "script_astar", url: "https://play.rosebud.ai/assets/script_astar.js?vyaq" }, { name: "script_navmesh", url: "https://play.rosebud.ai/assets/script_navmesh.js?aBZq" }, { name: "script_inputHandler", url: "https://play.rosebud.ai/assets/script_inputHandler.js?GbXi" }, { name: "script_gameOver", url: "https://play.rosebud.ai/assets/script_gameOver.js?mvhA" }]; const MODEL_ASSETS = { SMG: { url: 'https://play.rosebud.ai/assets/mdl_mac-10.glb?hSv0', type: 'glb', scale: 0.25 }, PISTOL: { url: 'https://play.rosebud.ai/assets/semi_auto_pistol_g-17.glb?cJ4S', type: 'glb', scale: 2.5 }, XBOT: { url: 'https://play.rosebud.ai/assets/mdl_xbot.fbx?y7Qq', type: 'fbx', scale: 0.10, animations: { idle: 'https://play.rosebud.ai/assets/anim_xbot_ZombieIdle.fbx?PNi0', walk: 'https://play.rosebud.ai/assets/anim_xbot_ZombieWalk.fbx?NK76', attack: 'https://play.rosebud.ai/assets/anim_xbot_ZombieAttack.fbx?kExF' } }, }; const SOUND_ASSETS = { effects: { intermission: { url: 'https://play.rosebud.ai/assets/snd_intermission.wav?Fe8T', volume: 0.5, key: 'intermission' }, intro_voice: { url: 'https://play.rosebud.ai/assets/snd_voiceintro_v2.mp3?CdWq', volume: 1, key: 'intro_voice' }, intro_rise: { url: 'https://play.rosebud.ai/assets/snd_dark_rise.wav?Kv8m', volume: 0.5, key: 'intro_rise' }, hit_bullet: { url: 'https://play.rosebud.ai/assets/snd_bullet_hit.wav?5GSg', volume: 0.45, key: 'hit_bullet' }, hit_player: { url: 'https://play.rosebud.ai/assets/snd_zombieAttack.wav?FcCC', volume: 0.5, key: 'hit_player' }, zombie_death: { url: 'https://play.rosebud.ai/assets/snd_zombieDead.mp3?Jr8y', volume: 1, key: 'zombie_death' }, gunshot_pistol: { url: 'https://play.rosebud.ai/assets/snd_pistol_shot.wav?V6gU', volume: 0.1, key: 'gunshot_pistol' }, gunshot_smg: { url: 'https://play.rosebud.ai/assets/silencer_shoot.mp3?5rqE', volume: 0.25, key: 'gunshot_smg' }, reload_weapon: { url: 'https://play.rosebud.ai/assets/snd_reload.wav?qYEe', volume: 0.5, key: 'reload_weapon' } }, music: {}, ambient: {} }; const IMAGE_ASSETS = { AMMO_ICON: { url: 'https://play.rosebud.ai/assets/ammo_icon.png?SAvS', type: 'png', scale: 1.0, iconSize: { width: '32px', height: '24px' } }, PISTOL_ICON: { url: 'https://play.rosebud.ai/assets/pistol_icon.png?n62A', type: 'png', scale: 1.0, flipX: true, iconSize: { width: '32px', height: '24px' } }, SMG_ICON: { url: 'https://play.rosebud.ai/assets/ui_mac10s_v4.png?yIug', type: 'png', scale: 1.0, flipX: true, iconSize: { width: '72px', height: '32px' } } }; const APP_SETTINGS = { loadouts: { player: { primary: 'smg', secondary: 'pistol', defaultWeapon: 'smg' // Weapon to equip on spawn }, basic_enemy: { primary: 'enemy_pistol', secondary: null, defaultWeapon: 'enemy_pistol' // Updated to use enemy-specific pistol } }, enemySpawns: { spawnHeight: 5, // Height above ground for enemy spawn safeTileDistance: 5 // Minimum number of tiles away from player for spawning }, tilemap: { width: 18, height: 14, tileSize: 20, enemySpawns: [{ // North corners - Left side x: 2, z: 3 }, { x: 8, z: 3 }, // North corners - Right side { x: 13, z: 3 }, { x: 19, z: 3 }, // Mid-map spawns - Left side { x: 2, z: 7 }, { x: 8, z: 7 }, // Mid-map spawns - Right side { x: 13, z: 7 }, { x: 19, z: 7 }, // South corners - Left side { x: 2, z: 10 }, { x: 8, z: 10 }, // South corners - Right side { x: 13, z: 10 }, { x: 19, z: 10 }, // East-West mid spawns - Left side { x: 1, z: 6 }, { x: 9, z: 6 }, // East-West mid spawns - Right side { x: 12, z: 6 }, { x: 20, z: 6 } ], obstacles: [ // Beginning barrier - Left side { x: 3, z: 2 }, { x: 4, z: 2 }, { x: 5, z: 2 }, { x: 6, z: 2 }, // Beginning barrier - Right side { x: 15, z: 2 }, { x: 16, z: 2 }, { x: 17, z: 2 }, { x: 18, z: 2 }, // Middle barrier center map - Left side { x: 4, z: 7 }, { x: 5, z: 7 }, // Middle barrier center map - Right side { x: 16, z: 7 }, { x: 17, z: 7 }, // Extends from east wall - Left side { x: 9, z: 5 }, { x: 8, z: 5 }, { x: 7, z: 5 }, // Extends from east wall - Right side { x: 21, z: 5 }, { x: 20, z: 5 }, { x: 19, z: 5 }, // Extends west wall - Left side { x: 2, z: 5 }, { x: 1, z: 5 }, { x: 0, z: 5 }, // Extends west wall - Right side { x: 14, z: 5 }, { x: 13, z: 5 }, { x: 12, z: 5 }, // Extends from east wall - Left side { x: 9, z: 9 }, { x: 8, z: 9 }, { x: 7, z: 9 }, // Extends from east wall - Right side { x: 21, z: 9 }, { x: 20, z: 9 }, { x: 19, z: 9 }, // Extends west wall - Left side { x: 2, z: 9 }, { x: 1, z: 9 }, { x: 0, z: 9 }, // Extends west wall - Right side { x: 14, z: 9 }, { x: 13, z: 9 }, { x: 12, z: 9 }, // Side corridors - Left side { x: 2, z: 7 }, { x: 7, z: 7 }, // Side corridors - Right side { x: 14, z: 7 }, { x: 19, z: 7 }, // Far corners - Left side { x: 1, z: 11 }, { x: 8, z: 11 }, // Far corners - Right side { x: 13, z: 11 }, { x: 20, z: 11 } ] }, obstacles: { height: 300, physics: { mass: 0, friction: 0.5, restitution: 0.3 }, material: { color: 0x808080, roughness: 0.7, metalness: 0.2 } }, controls: { startWaveOnInit: true, // Control whether wave starts automatically on init createEnemyOnStart: true, preloadEnemiesOnStart: true, // Control whether to preload enemies on start showNavMesh: false, showEnemyPath: false, enablePlayerInvulnerability: false, enableSunMovement: false, enableGunRecoil: true, enableGunReload: true, showEnemyDebugText: false, showPlayerDebugText: false, showWaveManagerDebugText: false, enableEnemyRespawn: true, enableEnemyShooting: true, showGameOverOnStart: false, enablePlayerRayVisibility: false, enableEnemyRayVisibility: true, mouseSensitivity: { x: 0.005, y: 0.005 }, }, renderer: { shadowMap: { enabled: true, type: THREE.PCFSoftShadowMap }, colorSpace: { output: THREE.SRGBColorSpace, toneMapping: THREE.ACESFilmicToneMapping, toneMappingExposure: 1.2 }, antialias: true, pixelRatio: window.devicePixelRatio }, world: { defaults: { skyColor: 0x23233a, // Slightly lighter blue-grey sky color groundColor: 0x202020 // Darker ground color }, }, enemyStates: { IDLE: 'IDLE', CHASING: 'CHASING', ATTACKING: 'ATTACKING' }, physics: { gravity: { x: 0, y: -110, z: 0 }, defaultContactMaterial: { friction: 0.01, restitution: 0.6 }, solver: { iterations: 10, tolerance: 0.001 }, collisionGroups: { PLAYER: 1, // 0001 in binary OBSTACLE: 2, // 0010 in binary GROUND: 4, // 0100 in binary ENEMY: 8 // 1000 in binary } }, camera: { fov: 75, near: 0.1, far: 1000, initialPosition: { x: 0, y: 50, z: 100 } }, // Player settings moved to Player class lights: { sunlight: { color: 0xffffff, // Darker grey light color intensity: 3, // Reduced intensity position: { x: 10, y: 100, z: 10 // Changed from -50 to 50 to move light to the north }, castShadow: true, shadow: { mapSize: { width: 2048, height: 2048 }, camera: { near: 10, far: 1000, left: -100, right: 100, top: 100, bottom: -100 }, bias: -0.0001 } } } }; class Renderer { constructor() { this.postProcessing = null; this.renderer = new THREE.WebGLRenderer({ antialias: APP_SETTINGS.renderer.antialias, canvas: canvas, powerPreference: "high-performance" }); this.init(); } init() { this.renderer.setPixelRatio(APP_SETTINGS.renderer.pixelRatio); this.renderer.setSize(canvas.offsetWidth, canvas.offsetHeight); this.renderer.shadowMap.enabled = APP_SETTINGS.renderer.shadowMap.enabled; this.renderer.shadowMap.type = APP_SETTINGS.renderer.shadowMap.type; this.renderer.outputColorSpace = APP_SETTINGS.renderer.colorSpace.output; this.renderer.toneMapping = APP_SETTINGS.renderer.colorSpace.toneMapping; this.renderer.toneMappingExposure = APP_SETTINGS.renderer.colorSpace.toneMappingExposure; console.log('Renderer initialized with APP_SETTINGS parameters'); } initPostProcessing() { this.postProcessing = new PostProcessing(this.renderer, WorldScene, MainCamera); window.PostProcessing = this.postProcessing; } render() { if (this.postProcessing) { this.postProcessing.render(); } else { this.renderer.render(WorldScene, MainCamera); } } setSize(width, height) { this.renderer.setSize(width, height); if (this.postProcessing) { this.postProcessing.setSize(width, height); } } } class PostProcessing { constructor() { this.composer = null; this.bloomPass = null; this.smaaPass = null; this.initComposer(); } initComposer() { this.composer = new EffectComposer(GameRenderer.renderer); const renderPass = new RenderPass(WorldScene, MainCamera); this.composer.addPass(renderPass); this.bloomPass = new UnrealBloomPass( new THREE.Vector2(innerWidth, innerHeight), 0.2, // bloom strength 0.4, // radius 0.9 // threshold ); this.composer.addPass(this.bloomPass); this.smaaPass = new SMAAPass( innerWidth * GameRenderer.renderer.getPixelRatio(), innerHeight * GameRenderer.renderer.getPixelRatio() ); this.composer.addPass(this.smaaPass); } setSize(width, height) { this.composer.setSize(width, height); this.bloomPass.resolution.set(width, height); this.smaaPass.setSize(width, height); } render() { this.composer.render(); } } class WorldTime { constructor() { this.currentTime = 0; // Time in seconds this.timeScale = 1; // 1 second real time = 1 second game time this.tweening = false; this.tweenStartTime = 0; this.tweenEndTime = 0; this.tweenDuration = 0; } update(deltaTime) { if (this.tweening) { this.updateTween(deltaTime); } else { this.currentTime += deltaTime * this.timeScale; } } setTimeScale(scale) { this.timeScale = scale; } getHours() { return Math.floor(this.currentTime / 3600) % 24; } getMinutes() { return Math.floor((this.currentTime % 3600) / 60); } getSeconds() { return Math.floor(this.currentTime % 60); } getTimeString() { const hours = this.getHours().toString().padStart(2, '0'); const minutes = this.getMinutes().toString().padStart(2, '0'); const seconds = this.getSeconds().toString().padStart(2, '0'); return `${hours}:${minutes}:${seconds}`; } setTime(hours) { const targetTime = hours * 3600; // Convert hours to seconds this.tweenStartTime = this.currentTime; this.tweenEndTime = targetTime; this.tweenDuration = 2; // Duration of the tween in seconds this.tweening = true; } updateTween(deltaTime) { const elapsedTime = Math.min(deltaTime, this.tweenDuration); const progress = elapsedTime / this.tweenDuration; this.currentTime = this.tweenStartTime + (this.tweenEndTime - this.tweenStartTime) * progress; this.tweenDuration -= elapsedTime; if (this.tweenDuration <= 0) { this.currentTime = this.tweenEndTime; this.tweening = false; } } } class World { constructor() { window.WorldScene = new THREE.Scene(); this.skybox = new SkyBox({ THREE: THREE, GLTFLoader: GLTFLoader, LoadingManager: window.LoadingManager, BasicSkyShader: BasicSkyShader, scene: window.WorldScene, settings: APP_SETTINGS, getLights: (name) => Lights.getLight(name) }); this.lights = {}; this.physicsWorld = new CANNON.World(); this.playerPhysMaterial = new CANNON.Material('player'); this.groundPhysMaterial = new CANNON.Material('ground'); // Create contact material between player and ground const playerGroundContact = new CANNON.ContactMaterial( this.playerPhysMaterial, this.groundPhysMaterial, { friction: 0, restitution: 0, contactEquationStiffness: 1e8, contactEquationRelaxation: 3 } ); this.physicsWorld.addContactMaterial(playerGroundContact); this.setupPhysicsWorld(); this.initCamera(); this.initRenderer(); this.initLights(); this.tilemap = null; this.Time = new WorldTime(); } setupPhysicsWorld() { this.physicsWorld.gravity.set( APP_SETTINGS.physics.gravity.x, APP_SETTINGS.physics.gravity.y, APP_SETTINGS.physics.gravity.z ); this.physicsWorld.defaultContactMaterial.friction = APP_SETTINGS.physics.defaultContactMaterial.friction; this.physicsWorld.defaultContactMaterial.restitution = APP_SETTINGS.physics.defaultContactMaterial.restitution; this.physicsWorld.solver.iterations = APP_SETTINGS.physics.solver.iterations; this.physicsWorld.solver.tolerance = APP_SETTINGS.physics.solver.tolerance; this.groundPhysMaterial = new CANNON.Material('ground'); } initLights() { const defaultSkyColor = new THREE.Color(APP_SETTINGS.world.defaults.skyColor); const defaultGroundColor = new THREE.Color(APP_SETTINGS.world.defaults.groundColor); const sunlightSettings = APP_SETTINGS.lights.sunlight; Lights.createLight('sunLight', 'directional', { color: sunlightSettings.color, intensity: sunlightSettings.intensity, position: sunlightSettings.position, castShadow: sunlightSettings.castShadow, shadow: sunlightSettings.shadow }); Lights.createLight('hemiLight', 'hemisphere', { skyColor: defaultSkyColor, groundColor: defaultGroundColor, intensity: 0.6 }); console.log('Lights initialized with default colors:', defaultSkyColor, defaultGroundColor); } getLight(name) { return Lights.getLight(name); } calculateSunRotation(time) { const rotationSpeed = 0.1; // Adjust this value to change the orbit speed const angle = time * rotationSpeed; const radius = 100; // Adjust this value to change the orbit radius const x = Math.cos(angle) * radius; const z = Math.sin(angle) * radius; const baseHeight = 80; // Increased from 50 to 80 const verticalAmplitude = 30; // Increased from 20 to 30 const y = baseHeight + Math.sin(angle * 0.5) * verticalAmplitude; return new THREE.Vector3(x, y, z); } updateSunlight(playerPosition) { Lights.updateLight('sunLight', (sunLight) => { if (APP_SETTINGS.controls.enableSunMovement) { const offset = this.calculateSunRotation(this.Time.currentTime); sunLight.position.copy(playerPosition).add(offset); } if (!sunLight.target) { sunLight.target = new THREE.Object3D(); WorldScene.add(sunLight.target); } sunLight.target.position.copy(playerPosition); }); if (this.skybox) { this.skybox.updateSunPosition(); } } initCamera() { window.MainCamera = new THREE.PerspectiveCamera( APP_SETTINGS.camera.fov, canvas.offsetWidth / canvas.offsetHeight, APP_SETTINGS.camera.near, APP_SETTINGS.camera.far ); MainCamera.position.set( APP_SETTINGS.camera.initialPosition.x, APP_SETTINGS.camera.initialPosition.y, APP_SETTINGS.camera.initialPosition.z ); MainCamera.lookAt(0, 0, 0); console.log('Camera initialized with APP_SETTINGS parameters'); } initRenderer() { window.GameRenderer = new Renderer(MainCamera); GameRenderer.initPostProcessing(WorldScene); } createTilemap() { if (this.tilemap) { return this.tilemap; } try { const tileMapGenerator = new TileMapGenerator({ THREE: THREE, CANNON: CANNON, Materials: window.Materials, settings: APP_SETTINGS, scene: window.WorldScene, physicsWorld: this.physicsWorld, Tile: Tile, Wall: Wall, Obstacle: Obstacle, NavMesh: NavMesh }); this.tilemap = tileMapGenerator.generateMap(); if (!this.tilemap) { throw new Error('TileMapGenerator failed to generate map'); } return this.tilemap; } catch (error) { console.error('Failed to create tilemap:', error); throw error; } } update(deltaTime) { this.Time.update(deltaTime); this.physicsWorld.step(deltaTime); this.updateSunlight(new THREE.Vector3(0, 0, 0)); this.skybox.update(deltaTime); GameRenderer.render(); } } class Player { constructor(camera) { this.holderType = 'player'; this.getHolderType = () => this.holderType; this.debugText = new DebugText({ left: '20px', top: '20%' }); this.maxHealth = 100; this.currentHealth = this.maxHealth; this.isDead = false; this.settings = { moveSpeed: 36, jumpSpeed: 45, offset: { y: 16 }, sensitivity: { x: 0.002, y: 0.002 }, dimensions: { width: 1, height: 15, depth: 1 }, position: { x: 0, y: 0, z: 120 }, hitbox: { dimensions: { width: 3, height: 16, depth: 3 }, offset: { x: 0, y: -1, z: 0 } } }; // Define initial state based on settings this.initialState = { health: this.maxHealth, position: new THREE.Vector3( this.settings.position.x, this.settings.position.y, this.settings.position.z ), moveSpeed: this.settings.moveSpeed, jumpSpeed: this.settings.jumpSpeed, dimensions: { ...this.settings.dimensions }, offset: { ...this.settings.offset }, hitbox: { dimensions: { ...this.settings.hitbox.dimensions }, offset: { ...this.settings.hitbox.offset } } }; this.isGrounded = false; // State machine properties this.states = { IDLE: 'IDLE', MOVING: 'MOVING', JUMPING: 'JUMPING' }; this.currentState = this.states.IDLE; this.previousState = null; this.moveSpeed = this.settings.moveSpeed; this.velocity = new THREE.Vector3(); this.moveDirection = new CANNON.Vec3(); this.camera = camera; this.position = new THREE.Vector3( this.settings.position.x, this.settings.position.y + this.settings.offset.y, this.settings.position.z ); // Define player-specific mount points this.mountSettings = { position: new THREE.Vector3(0.21, -0.35, -0.48), rotation: new THREE.Vector3(0, Math.PI - Math.PI / 2, 0) }; console.log('Player: Creating gun mount with settings:', this.mountSettings); this.gunMount = new GunMount({ THREE: THREE, mountPoint: this.camera, defaultPosition: this.mountSettings.position, defaultRotation: this.mountSettings.rotation }); console.log('Player: Gun mount created:', this.gunMount); this.gunController = new GunController({ THREE: THREE, Ray: Ray, APP_SETTINGS: APP_SETTINGS, rayDistance: 1000 }); this.gunController.setMount(this.gunMount); this.gunController.setHolder(this, this.holderType, 'player'); this.getAmmoState = () => { const currentGun = window.GunManager?.getGunForHolder('player'); if (currentGun) { return { current: currentGun.getCurrentAmmo(), max: currentGun.getMaxAmmo() }; } return { current: 0, max: 0 }; }; this.keys = { forward: false, backward: false, left: false, right: false, jumping: false }; this.createPhysicsBody( new CANNON.Vec3( this.settings.dimensions.width, this.settings.dimensions.height, this.settings.dimensions.depth ), new CANNON.Vec3( this.settings.position.x, this.settings.position.y + this.settings.offset.y, this.settings.position.z ) ); // Create hitbox this.createHitbox(); this.initKeyBindings(); } canJump() { return this.isGrounded && !this.keys.jumping; } jump() { if (this.canJump()) { this.physicsBody.velocity.y = this.settings.jumpSpeed; this.keys.jumping = true; this.setState(this.states.JUMPING); } } createPhysicsBody(dimensions, position) { const shape = new CANNON.Box(dimensions); this.physicsBody = new CANNON.Body({ mass: 70, shape: shape, material: window.GameWorld.playerPhysMaterial, position: position, fixedRotation: true // Prevent player from tipping over }); // Set collision groups this.physicsBody.collisionFilterGroup = APP_SETTINGS.physics.collisionGroups.PLAYER; this.physicsBody.collisionFilterMask = APP_SETTINGS.physics.collisionGroups.GROUND | APP_SETTINGS.physics.collisionGroups.OBSTACLE; // Add to physics world window.GameWorld.physicsWorld.addBody(this.physicsBody); } getPosition() { return this.position.clone(); } getWorldPosition() { return this.camera.getWorldPosition(new THREE.Vector3()); } getWorldDirection() { const direction = new THREE.Vector3(); this.camera.getWorldDirection(direction); return direction; } getHitboxMesh() { return this.hitboxMesh; } switchToGun(gunType) { if (this.gunController && window.GunManager) { this.gunController.switchGun(gunType); } } initKeyBindings() { document.addEventListener('keydown', (event) => { switch (event.code) { case 'KeyR': if (this.isDead || window.GameOverScreen?.isVisible()) { window.Game.resetGameState(); return; } // Existing reload logic for guns when alive if (this.gunController) { this.gunController.reload(); } break; case 'Space': if (this.canJump()) { this.jump(); } break; case 'Digit1': if (APP_SETTINGS.loadouts.player.primary) { this.switchToGun(APP_SETTINGS.loadouts.player.primary); } break; case 'Digit2': if (APP_SETTINGS.loadouts.player.secondary) { this.switchToGun(APP_SETTINGS.loadouts.player.secondary); } break; 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 'KeyR': // Delegate reload action to gun controller if (this.gunController) { this.gunController.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; } }); } // State machine methods enterState(newState) { switch (newState) { case this.states.IDLE: this.moveDirection.set(0, 0, 0); break; case this.states.MOVING: break; case this.states.JUMPING: break; } } exitState(currentState) { switch (currentState) { case this.states.IDLE: break; case this.states.MOVING: this.moveDirection.set(0, 0, 0); break; case this.states.JUMPING: // Heavily dampen vertical velocity when landing this.physicsBody.velocity.y *= 0.1; // Reduce y velocity by 90% // Preserve horizontal velocity when transitioning from jumping this.moveDirection.x = this.physicsBody.velocity.x; this.moveDirection.z = this.physicsBody.velocity.z; break; } } setState(newState) { if (newState === this.currentState) return; // Exit current state this.exitState(this.currentState); // Store previous state before changing this.previousState = this.currentState; this.currentState = newState; // Enter new state this.enterState(newState); } executeStateAction(state, deltaTime) { switch (state) { case this.states.IDLE: // Handle idle behavior break; case this.states.MOVING: case this.states.JUMPING: // Handle movement behavior (both ground and air) const moveDirection = this.handleMovementInput(); this.updatePhysics(moveDirection); break; } } update(deltaTime) { // If player is dead, only update debug text and return if (this.isDead) { this.updateDebugText(); return; } const isMouseDown = window.Input.isMouseDown; const wasGrounded = this.isGrounded; this.checkGrounded(); // Update debug text with player information this.updateDebugText(); // Handle state transitions const isMoving = this.keys.forward || this.keys.backward || this.keys.left || this.keys.right; switch (this.currentState) { case this.states.IDLE: if (isMoving) { this.setState(this.states.MOVING); } else if (!this.isGrounded) { this.setState(this.states.JUMPING); } break; case this.states.MOVING: if (!isMoving) { this.setState(this.states.IDLE); } else if (!this.isGrounded) { this.setState(this.states.JUMPING); } break; case this.states.JUMPING: if (!wasGrounded && this.isGrounded) { this.keys.jumping = false; this.setState(this.states.IDLE); } break; } // Execute current state only if not dead this.executeStateAction(this.currentState, deltaTime); // Update gun controller and shooting only if not dead if (this.gunController) { // Only allow shooting if player is alive if (isMouseDown && this.gunController.canShoot() && !this.isDead) { this.gunController.shoot(); } this.gunMount.update(deltaTime); this.gunController.update(); } // Update hitbox position this.updateHitboxPosition(); const moveDirection = this.handleMovementInput(); this.updatePhysics(moveDirection); } handleMovementInput() { if (this.isDead) return new CANNON.Vec3(0, 0, 0); const forward = window.CameraControl.getForwardVector(); const right = window.CameraControl.getRightVector(); forward.y = 0; right.y = 0; forward.normalize(); right.normalize(); // Reset move direction this.moveDirection.set(0, 0, 0); // Accumulate movement input if (this.keys.forward) this.moveDirection.vadd(new CANNON.Vec3(forward.x, 0, forward.z), this.moveDirection); if (this.keys.backward) this.moveDirection.vsub(new CANNON.Vec3(forward.x, 0, forward.z), this.moveDirection); if (this.keys.right) this.moveDirection.vadd(new CANNON.Vec3(right.x, 0, right.z), this.moveDirection); if (this.keys.left) this.moveDirection.vsub(new CANNON.Vec3(right.x, 0, right.z), this.moveDirection); // Normalize the movement direction if there is any movement if (this.moveDirection.length() > 0) { this.moveDirection.normalize(); } return this.moveDirection; } setVelocity(x, y, z) { this.physicsBody.velocity.x = x; this.physicsBody.velocity.y = y; this.physicsBody.velocity.z = z; } setPosition(x, y, z) { // Update internal position this.position.set(x, y, z); // Update physics body without triggering callbacks if (this.physicsBody) { this.physicsBody.position.set(x, y, z); } } createHitbox() { // Create a hitbox with specified dimensions const hitboxGeometry = new THREE.BoxGeometry( this.settings.hitbox.dimensions.width * 2, this.settings.hitbox.dimensions.height, this.settings.hitbox.dimensions.depth * 2 ); const hitboxMaterial = new THREE.MeshBasicMaterial({ transparent: true, opacity: 0, wireframe: false, depthTest: false }); this.hitboxMesh = new THREE.Mesh(hitboxGeometry, hitboxMaterial); this.hitboxMesh.visible = false; this.hitboxMesh.userData.type = 'player'; // Tag for raycasting this.hitboxMesh.raycast = THREE.Mesh.prototype.raycast; // Create wireframe for visualization const wireframeMaterial = new THREE.MeshBasicMaterial({ color: 0xff0000, wireframe: true, transparent: true, opacity: 0.5, depthTest: false }); this.hitboxWireframe = new THREE.Mesh(hitboxGeometry, wireframeMaterial); this.hitboxWireframe.visible = false; // Initially hidden // Add both meshes to the scene WorldScene.add(this.hitboxMesh); WorldScene.add(this.hitboxWireframe); } updateHitboxPosition() { if (!this.hitboxMesh || !this.hitboxWireframe) return; const position = this.getPosition(); const hitboxPosition = new THREE.Vector3( position.x + this.settings.hitbox.offset.x, position.y + this.settings.hitbox.offset.y, position.z + this.settings.hitbox.offset.z ); this.hitboxMesh.position.copy(hitboxPosition); this.hitboxWireframe.position.copy(hitboxPosition); } toggleHitboxVisibility() { if (this.hitboxWireframe) { this.hitboxWireframe.visible = !this.hitboxWireframe.visible; } } handleHit(damage) { if (this.isDead) return; // Prevent damage if already dead this.takeDamage(damage); } takeDamage(damage) { if (this.isDead) return; // Skip damage if invulnerability is enabled if (APP_SETTINGS.controls.enablePlayerInvulnerability) { console.log('Player Invulnerable: Damage prevented'); return; } // Play hit sound if (window.AudioManager) { window.AudioManager.play('hit_player'); } this.currentHealth = Math.max(0, this.currentHealth - damage); if (this.currentHealth <= 0) { this.die(); } } die() { if (this.isDead) return; this.isDead = true; this.currentHealth = 0; // Stop all movement this.keys.forward = false; this.keys.backward = false; this.keys.left = false; this.keys.right = false; // Stop any ongoing actions if (this.gunController) { const currentGun = this.gunController.getGun(); if (currentGun) { currentGun.hide(); } } // Show game over screen and hide HUD if (window.GameOverScreen) { window.GameOverScreen.show(); // Play intro rise sound on game over if (window.AudioManager) { window.AudioManager.play('intro_rise'); } } if (window.HUD) { window.HUD.hide(); } } reset() { // Reset health this.isDead = false; this.currentHealth = this.maxHealth; // Reset position this.setPosition( this.initialState.position.x, this.initialState.position.y + this.settings.offset.y, this.initialState.position.z ); // Reset physics body velocity if (this.physicsBody) { this.physicsBody.velocity.set(0, 0, 0); this.physicsBody.angularVelocity.set(0, 0, 0); } // Reset movement state this.keys.forward = false; this.keys.backward = false; this.keys.left = false; this.keys.right = false; this.keys.jumping = false; // Reset state machine this.setState(this.states.IDLE); // Show gun if hidden if (this.gunController) { const currentGun = this.gunController.getGun(); if (currentGun) { currentGun.show(); } } } updateDebugText() { if (!this.debugText) return; this.debugText.container.style.display = APP_SETTINGS.controls.showPlayerDebugText ? 'block' : 'none'; this.debugText.setText('State', this.currentState); this.debugText.setText('Health', `${this.currentHealth}/${this.maxHealth}`); this.debugText.setText('Status', this.isDead ? 'DEAD' : 'ALIVE'); } getDesiredCameraPosition() { return new THREE.Vector3( this.position.x, this.position.y, this.position.z ); } updatePhysics(moveDirection) { if (!this.physicsBody) return; // Always set velocity based on moveDirection, zero if no input const velocityX = moveDirection.length() > 0 ? moveDirection.x * this.moveSpeed : 0; const velocityZ = moveDirection.length() > 0 ? moveDirection.z * this.moveSpeed : 0; this.setVelocity( velocityX, this.physicsBody.velocity.y, velocityZ ); // Update position after physics calculation this.updatePhysicsPosition(); } updatePhysicsPosition() { if (this.physicsBody) { // Calculate minimum allowed height (initial position + offset) const minHeight = this.settings.position.y + this.settings.offset.y; // Ensure y position never goes below minimum height const yPosition = Math.max(this.physicsBody.position.y, minHeight); // If player is below minimum height, also zero out downward velocity if (this.physicsBody.position.y < minHeight) { this.physicsBody.velocity.y = Math.max(0, this.physicsBody.velocity.y); } // Update position while maintaining minimum height this.setPosition( this.physicsBody.position.x, yPosition, this.physicsBody.position.z ); } } checkGrounded() { if (!window.GameWorld?.tilemap) { return false; } this.lastRayDistance = Infinity; // Initialize ray if not already created if (!this.groundRay) { this.groundRay = new Ray({ THREE: THREE, far: 16.5 // Increased to match new offset }); } // Start the ray from the actual physics body position const rayStart = new THREE.Vector3( this.physicsBody.position.x, this.physicsBody.position.y, this.physicsBody.position.z ); this.lastRayStartY = rayStart.y; const direction = new THREE.Vector3(0, -1, 0); // Update ray position and direction this.groundRay.update(rayStart, direction); // Get all collidable objects from the tilemap const tiles = window.GameWorld.tilemap.getTiles(); const obstacles = window.GameWorld.tilemap.getObstacles(); const walls = window.GameWorld.tilemap.getWalls(); this.isGrounded = false; // Function to check intersection with a mesh const checkMeshIntersection = (mesh) => { if (!mesh) return false; const intersection = this.groundRay.checkIntersection(mesh); if (intersection && intersection.distance < this.lastRayDistance) { this.lastRayDistance = intersection.distance; return true; } return false; }; // Check intersection with tiles for (const tile of tiles) { if (tile?.mesh && checkMeshIntersection(tile.mesh)) { this.isGrounded = true; } } // Check intersection with obstacles for (const obstacle of obstacles) { if (obstacle?.mesh && checkMeshIntersection(obstacle.mesh)) { this.isGrounded = true; } } // Check intersection with walls for (const wall of walls) { if (wall?.mesh && checkMeshIntersection(wall.mesh)) { this.isGrounded = true; } } return this.isGrounded; } } class DebugText { constructor(options = {}) { this.container = document.createElement('div'); this.container.style.position = 'fixed'; this.container.style.left = options.left || '20px'; this.container.style.top = options.top || '50%'; this.container.style.transform = 'translateY(-50%)'; this.container.style.backgroundColor = 'rgba(0, 0, 0, 0.5)'; this.container.style.padding = '10px'; this.container.style.borderRadius = '5px'; this.container.style.color = 'white'; this.container.style.fontFamily = 'monospace'; this.container.style.fontSize = '14px'; this.container.style.zIndex = '1000'; this.container.style.pointerEvents = 'none'; this.container.style.lineHeight = '1.5'; this.container.style.minWidth = '200px'; document.body.appendChild(this.container); this.lines = new Map(); } setText(key, value) { this.lines.set(key, value); this.updateDisplay(); } updateDisplay() { let text = ''; this.lines.forEach((value, key) => { text += `${key}: ${value}\n`; }); this.container.innerHTML = text.replace(/\n/g, '
'); } clear() { this.lines.clear(); this.updateDisplay(); } remove() { if (this.container && this.container.parentNode) { this.container.parentNode.removeChild(this.container); } } } class HealthBar { constructor({ uiContainer }) { this.element = document.createElement('div'); this.element.style.position = 'absolute'; this.element.style.top = '20px'; this.element.style.left = '50%'; this.element.style.transform = 'translateX(-50%)'; this.element.style.width = '300px'; this.element.style.height = '15px'; this.element.style.backgroundColor = 'rgba(0, 0, 0, 0.5)'; this.element.style.border = '1px solid rgba(255, 255, 255, 0.3)'; this.element.style.borderRadius = '3px'; this.element.style.overflow = 'hidden'; // Create the health fill bar this.fillBar = document.createElement('div'); this.fillBar.style.width = '100%'; this.fillBar.style.height = '100%'; this.fillBar.style.backgroundColor = '#ff3333'; this.fillBar.style.transition = 'all 0.3s ease-in-out'; this.fillBar.style.boxShadow = 'inset 0 0 5px rgba(0, 0, 0, 0.5)'; // Create the health text overlay this.healthText = document.createElement('div'); this.healthText.style.position = 'absolute'; this.healthText.style.width = '100%'; this.healthText.style.height = '100%'; this.healthText.style.display = 'flex'; this.healthText.style.justifyContent = 'center'; this.healthText.style.alignItems = 'center'; this.healthText.style.color = '#ffffff'; this.healthText.style.fontFamily = 'Arial, sans-serif'; this.healthText.style.fontSize = '12px'; this.healthText.style.fontWeight = 'bold'; this.healthText.style.textShadow = '1px 1px 2px #000000'; // Add elements to the container this.element.appendChild(this.fillBar); this.element.appendChild(this.healthText); uiContainer.appendChild(this.element); } updateHealth(current, max) { const percentage = (current / max) * 100; this.fillBar.style.width = `${percentage}%`; // Update color based on health percentage if (percentage > 60) { this.fillBar.style.backgroundColor = '#2ecc71'; // Cleaner green } else if (percentage > 30) { this.fillBar.style.backgroundColor = '#f1c40f'; // Cleaner yellow } else { this.fillBar.style.backgroundColor = '#e74c3c'; // Cleaner red } // Update text this.healthText.textContent = `${current}/${max}`; } } class Enemy { static nextId = 1; constructor(scene, settings) { this.lastReachedPoint = null; // Add this property to track last reached point this.id = Enemy.nextId++; this.lastAttackTime = 0; this.deathTime = 0; // Track when the enemy died this.respawnSettings = { delay: settings.respawnDelay || 1000, // Default 1000ms respawn delay enabled: settings.respawnEnabled !== undefined ? settings.respawnEnabled : true }; this.holderType = 'enemy'; this.getHolderType = () => this.holderType; this.getHolderId = () => `enemy_${this.id}`; this.canSeePlayer = false; this.canSeePlayerStartTime = 0; this.targetingDelay = 1000; // 1 second delay this.hasTargetLock = false; // Initialize pathfinder if (window.GameWorld?.tilemap) { this.pathfinder = new AStar({ THREE: THREE, tileMap: window.GameWorld.tilemap, settings: APP_SETTINGS, pointColor: 0x00ff00, lineColor: 0xffff00 }); } // Attack state tracking this.attackStartTime = 0; this.attackTimeElapsed = 0; // Pathfinding properties this.pathfinder = null; this.currentPath = null; this.currentPathIndex = 0; this.pathUpdateInterval = 1000; this.lastPathUpdate = 0; this.minWaypointDistance = 1.0; // State machine properties this.currentState = APP_SETTINGS.enemyStates.CHASING; this.waitStartTime = 0; this.waitDuration = settings.waitDuration; // Initialize multiple vision rays this.visionRay = new Ray({ THREE: THREE, far: 1000, visible: APP_SETTINGS.controls.enableEnemyRayVisibility }); this.lastVisionCheck = 0; this.visionCheckInterval = 100; // Check every 100ms if (!settings) { throw new Error('Enemy: settings are required'); } // Store complete settings first this.settings = { ...settings }; this.scene = scene; this.deathEffect = null; this.isRespawning = false; this.respawnTime = 0; // Validate critical settings if (!this.settings.dimensions) { throw new Error('Enemy: dimensions are required in settings'); } if (!this.settings.position) { throw new Error('Enemy: position is required in settings'); } this.debugText = new DebugText({ left: '20px', top: '50%' }); if (!APP_SETTINGS.controls.showEnemyDebugText) { this.debugText.container.style.display = 'none'; } this.maxHealth = 100; this.currentHealth = this.maxHealth; this.isDead = false; this.scene = scene; this.gunController = null; this.gunMount = null; // Movement and rotation properties this.rotationSpeed = 7.0; this.targetQuaternion = new THREE.Quaternion(); this.currentQuaternion = new THREE.Quaternion(); this.bodyDimensions = new CANNON.Vec3( this.settings.body.dimensions.width, this.settings.body.dimensions.height, this.settings.body.dimensions.depth ); this.physicsBody = this.createPhysicsBody( this.bodyDimensions, new CANNON.Vec3( this.settings.position.x + this.settings.body.offset.x, this.settings.position.y + this.settings.body.offset.y, this.settings.position.z + this.settings.body.offset.z ) ); this.moveSpeed = this.settings.chaseSpeed; this.model = null; this.isLoaded = false; this.animationController = null; this.currentState = APP_SETTINGS.enemyStates.CHASING; this.waitStartTime = 0; this.waitDuration = this.settings.waitDuration; } initializeWithPreloadedAssets() { if (!this.settings.preloadedAssets) { console.error('Enemy: Preloaded assets are missing'); throw new Error('Preloaded assets are required'); } const { model, animationController } = this.settings.preloadedAssets; this.model = model; this.animationController = animationController; if (this.model) { // Apply material modifications including emissive glow this.model.traverse((child) => { if (child.isMesh && child.material) { if (Array.isArray(child.material)) { child.material.forEach(mat => { mat.color.setRGB(0.4, 0.5, 0.3); // Gray-green zombie tint mat.emissive = new THREE.Color(0x114411); // Subtle green glow mat.emissiveIntensity = 0.15; // Low intensity for subtle effect }); } else { child.material.color.setRGB(0.4, 0.5, 0.3); // Gray-green zombie tint child.material.emissive = new THREE.Color(0x114411); // Subtle green glow child.material.emissiveIntensity = 0.15; // Low intensity for subtle effect } } }); this.createHitbox(); // Enemy model initialization complete this.setPosition(new THREE.Vector3( this.physicsBody.position.x, this.physicsBody.position.y, this.physicsBody.position.z )); this.model.visible = true; // Explicitly set visibility this.scene.add(this.model); this.isLoaded = true; // Start default walk animation if (this.animationController) { this.animationController.transitionToAnimation('walk'); } } } createHitbox() { // Create a hitbox with specified dimensions and offset const hitboxGeometry = new THREE.BoxGeometry( this.settings.hitbox.dimensions.width, this.settings.hitbox.dimensions.height, this.settings.hitbox.dimensions.depth ); // Create transparent material with wireframe const hitboxMaterial = new THREE.MeshBasicMaterial({ transparent: true, opacity: 0, wireframe: false, depthTest: false }); this.hitboxMesh = new THREE.Mesh(hitboxGeometry, hitboxMaterial); this.hitboxMesh.visible = false; // Initially invisible this.hitboxMesh.userData.type = 'enemy'; // Tag for raycasting this.hitboxMesh.raycast = THREE.Mesh.prototype.raycast; // Make it raycastable // Create wireframe for debugging const wireframeMaterial = new THREE.MeshBasicMaterial({ color: 0xff0000, wireframe: true, transparent: true, opacity: 0.5, depthTest: false }); this.hitboxWireframe = new THREE.Mesh(hitboxGeometry, wireframeMaterial); this.hitboxWireframe.visible = false; // Initially hidden // Add both meshes to the scene this.scene.add(this.hitboxMesh); this.scene.add(this.hitboxWireframe); } toggleHitboxVisibility() { if (this.hitboxWireframe) { this.hitboxWireframe.visible = !this.hitboxWireframe.visible; } } createPhysicsBody(dimensions, position) { const shape = new CANNON.Box(dimensions); const enemyMaterial = new CANNON.Material('enemyMaterial'); const body = new CANNON.Body({ mass: 70, shape: shape, material: enemyMaterial, position: position, linearDamping: 0.4, angularDamping: 0.99, fixedRotation: true, allowSleep: false }); body.collisionFilterGroup = APP_SETTINGS.physics.collisionGroups.ENEMY; body.collisionFilterMask = APP_SETTINGS.physics.collisionGroups.OBSTACLE | APP_SETTINGS.physics.collisionGroups.GROUND; window.GameWorld.physicsWorld.addBody(body); return body; } getHorizontalDistanceToPoint(targetPoint) { const currentPos = this.getPosition(); // Only consider x and z coordinates for distance calculation return Math.sqrt( Math.pow(currentPos.x - targetPoint.x, 2) + Math.pow(currentPos.z - targetPoint.z, 2) ); } getPosition() { return new THREE.Vector3( this.physicsBody.position.x, this.physicsBody.position.y, this.physicsBody.position.z ); } getWorldPosition() { if (!this.model) { return this.getPosition(); } const worldPos = new THREE.Vector3(); this.model.getWorldPosition(worldPos); return worldPos; } getWorldDirection() { if (!this.model) { return new THREE.Vector3(0, 0, 1); } const direction = new THREE.Vector3(0, 0, 1); this.model.getWorldDirection(direction); return direction; } getHitboxMesh() { return this.hitboxMesh; } getRaycastOffset() { // Return 75% of the enemy's height for a more realistic shooting position return this.settings.dimensions.height * 0.85; } setPosition(newPosition) { this.physicsBody.position.set(newPosition.x, newPosition.y, newPosition.z); } enterState(state) { const currentTime = Date.now(); switch (state) { case APP_SETTINGS.enemyStates.IDLE: this.moveSpeed = 0; if (this.animationController) { this.animationController.transitionToAnimation('idle'); } break; case APP_SETTINGS.enemyStates.CHASING: this.moveSpeed = this.settings.chaseSpeed; if (this.animationController) { this.animationController.transitionToAnimation('walk'); } break; case APP_SETTINGS.enemyStates.ATTACKING: this.attackStartTime = currentTime; this.attackTimeElapsed = 0; this.hasDealtDamage = false; // Reset damage flag for new attack this.moveSpeed = 0; console.log(`[Enemy ${this.id}] Starting attack animation at ${currentTime}`); console.log(`[Enemy ${this.id}] Attack settings:`, { windupDuration: this.settings.attackWindupDuration, fullDuration: this.settings.attackDuration }); // Start attack animation if (this.animationController) { this.animationController.transitionToAnimation('attack'); } break; } } executeStateAction(state, deltaTime, playerPosition) { switch (state) { case APP_SETTINGS.enemyStates.IDLE: // During IDLE state, only look at the player this.moveInDirection(playerPosition, deltaTime, true); break; case APP_SETTINGS.enemyStates.CHASING: this.executeChaseAction(deltaTime, playerPosition); break; case APP_SETTINGS.enemyStates.ATTACKING: this.executeAttackAction(deltaTime, playerPosition); break; } } executeAttackAction(deltaTime, playerPosition) { const currentTime = Date.now(); // Calculate elapsed time since attack started const elapsedTime = currentTime - this.attackStartTime; // Look at player during attack this.moveInDirection(playerPosition, deltaTime); // Log attack phases if (elapsedTime < this.settings.attackWindupDuration) { if (!this._loggedWindup) { console.log(`[Enemy ${this.id}] Attack windup phase: ${elapsedTime}ms / ${this.settings.attackWindupDuration}ms`); this._loggedWindup = true; } } else if (!this._loggedActive && elapsedTime >= this.settings.attackWindupDuration) { console.log(`[Enemy ${this.id}] Attack active phase started at: ${elapsedTime}ms`); this._loggedActive = true; } // Windup phase if (elapsedTime < this.settings.attackWindupDuration) { return; // Still in windup, no damage yet } // Active attack phase if (elapsedTime >= this.settings.attackWindupDuration && elapsedTime < this.settings.attackDuration && !this.hasDealtDamage) { // Check if player is in range const distanceToPlayer = this.getHorizontalDistanceToPoint(playerPosition); if (distanceToPlayer <= this.settings.attackRange) { // Deal damage to player if (window.Player && !window.Player.isDead) { window.Player.handleHit(this.settings.attackDamage); this.hasDealtDamage = true; // Prevent multiple hits from same attack } } } } exitState(state) { switch (state) { case APP_SETTINGS.enemyStates.CHASING: // Reset chase-related properties this.currentPath = null; this.currentPathIndex = 0; break; case APP_SETTINGS.enemyStates.ATTACKING: // Reset attack-related properties this.attackStartTime = 0; this.attackTimeElapsed = 0; break; } } moveInDirection(targetPosition, deltaTime, lookAtTarget = true) { const currentPos = this.getPosition(); if (this.lastReachedPoint && targetPosition.distanceTo(this.lastReachedPoint) < 0.1) { return; // Skip moving to the last reached point } const direction = new THREE.Vector3() .subVectors(targetPosition, currentPos) .setY(0) .normalize(); const newVelocity = new CANNON.Vec3( direction.x * this.moveSpeed, this.physicsBody.velocity.y, direction.z * this.moveSpeed ); this.physicsBody.velocity.copy(newVelocity); if (lookAtTarget && this.model) { this.updateTargetRotation(targetPosition); } } executeChaseAction(deltaTime, playerPosition) { // If enemy has target lock, move directly towards player if (this.hasTargetLock) { this.currentPath = null; // Clear the current path this.currentPathIndex = 0; this.lastReachedPoint = null; this.moveInDirection(playerPosition, deltaTime); return; } // If enemy cannot see player, use pathfinding const currentTime = Date.now(); if (currentTime - this.lastPathUpdate >= this.pathUpdateInterval) { this.updatePath(playerPosition); this.lastPathUpdate = currentTime; this.currentPathIndex = 0; } // Follow the calculated path if (this.currentPath && this.currentPathIndex < this.currentPath.length) { const targetPoint = this.currentPath[this.currentPathIndex]; const distance = this.getHorizontalDistanceToPoint(targetPoint); if (distance < this.minWaypointDistance) { this.lastReachedPoint = targetPoint.clone(); this.currentPathIndex++; } else { // Skip point if it's the last reached point if (this.lastReachedPoint && targetPoint.distanceTo(this.lastReachedPoint) < 0.1) { this.currentPathIndex++; } else { this.moveInDirection(targetPoint, deltaTime); } } } } executeWaitAction(deltaTime, playerPosition) { const previousMoveSpeed = this.moveSpeed; this.moveSpeed = 0; this.moveInDirection(playerPosition, true); this.moveSpeed = previousMoveSpeed; } calculateDirectionToPlayer(playerPosition) { const currentPosition = this.getPosition(); return new THREE.Vector3( playerPosition.x - currentPosition.x, 0, playerPosition.z - currentPosition.z ); } updatePath(playerPosition) { if (!this.pathfinder || !window.GameWorld?.tilemap) { this.lastReachedPoint = null; // Reset last reached point when updating path // Try to initialize pathfinder if it doesn't exist if (window.GameWorld?.tilemap && !this.pathfinder) { this.pathfinder = new AStar({ THREE: THREE, tileMap: window.GameWorld.tilemap, settings: APP_SETTINGS, pointColor: 0x00ff00, lineColor: 0xffff00 }); } else { return; } } const startPosition = this.getPosition(); const targetPosition = playerPosition instanceof THREE.Vector3 ? playerPosition.clone() : new THREE.Vector3(playerPosition.x, playerPosition.y, playerPosition.z); const path = this.pathfinder.findPath(startPosition, targetPosition); if (path) { this.currentPath = path; // Visualize the path if debug mode is enabled if (APP_SETTINGS.controls.showEnemyPath) { this.pathfinder.visualizePath(path); } } } updateModelTransform() { if (!this.model) return; const physicsPos = this.getPosition(); this.model.position.copy(physicsPos); this.model.position.y = Math.max(physicsPos.y, 0.1); this.model.quaternion.slerp(this.targetQuaternion, this.rotationSpeed * this.deltaTime); } updateHitboxPosition() { if (!this.hitboxMesh || !this.hitboxWireframe || !this.model) return; const modelPosition = this.getPosition(); const fixedHeight = this.settings.spawn?.height || 2; // Use spawn height from enemy settings const hitboxOffset = this.settings.hitbox?.offset || { x: -1, y: 15, z: 1 }; const newPosition = new THREE.Vector3( modelPosition.x + hitboxOffset.x, fixedHeight + hitboxOffset.y, // Use fixed height instead of modelPosition.y modelPosition.z + hitboxOffset.z ); this.hitboxMesh.position.copy(newPosition); this.hitboxWireframe.position.copy(newPosition); } updateTargetRotation(targetPosition) { if (!this.model) return; const direction = new THREE.Vector3() .subVectors(targetPosition, this.model.position) .setY(0) .normalize(); const lookAtMatrix = new THREE.Matrix4(); lookAtMatrix.lookAt(new THREE.Vector3(), direction, new THREE.Vector3(0, 1, 0)); this.targetQuaternion.setFromRotationMatrix(lookAtMatrix); const rotationFix = new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(0, 1, 0), Math.PI); this.targetQuaternion.multiply(rotationFix); } updateDebugText() { if (!this.debugText) return; this.debugText.container.style.display = APP_SETTINGS.controls.showEnemyDebugText ? 'block' : 'none'; this.debugText.setText('State', this.currentState); this.debugText.setText('Health', `${this.currentHealth}/${this.maxHealth}`); this.debugText.setText('Can See Player', this.canSeePlayer ? 'YES' : 'NO'); // Add path information if (this.currentPath) { this.debugText.setText('Path Nodes', this.currentPath.length); this.debugText.setText('Current Node', `${this.currentPathIndex}/${this.currentPath.length}`); // Calculate distance to next waypoint if there is one if (this.currentPathIndex < this.currentPath.length) { const nextPoint = this.currentPath[this.currentPathIndex]; const dist = this.getHorizontalDistanceToPoint(nextPoint); this.debugText.setText('Dist to Next', dist.toFixed(2)); } } else { this.debugText.setText('Path Nodes', 'No Path'); this.debugText.setText('Current Node', 'N/A'); this.debugText.setText('Dist to Next', 'N/A'); } } update(deltaTime, playerPosition) { this.deltaTime = deltaTime; this.checkVision(playerPosition); this.updateDebugText(); this.updateHitboxPosition(); if (this.deathEffect && this.deathEffect.active) { this.deathEffect.update(); } if (!this.model || !playerPosition || this.isDead) { return; } if (this.gunMount) { // Update gun mount position and rotation const modelPosition = this.getPosition(); const modelDirection = this.getWorldDirection(); this.gunMount.update(modelPosition, modelDirection); } if (this.animationController) { this.animationController.update(deltaTime); } this.updateModelTransform(); const distanceToPlayer = this.getHorizontalDistanceToPoint(playerPosition); let newState = this.currentState; const currentTime = Date.now(); switch (this.currentState) { case APP_SETTINGS.enemyStates.IDLE: // Check if wait duration has passed if (currentTime - this.waitStartTime >= this.waitDuration) { if (distanceToPlayer <= this.settings.startAttackingDistance) { newState = APP_SETTINGS.enemyStates.ATTACKING; } else { newState = APP_SETTINGS.enemyStates.CHASING; } } break; case APP_SETTINGS.enemyStates.CHASING: if (distanceToPlayer <= this.settings.startAttackingDistance && currentTime - this.waitStartTime >= this.waitDuration) { newState = APP_SETTINGS.enemyStates.ATTACKING; } break; case APP_SETTINGS.enemyStates.ATTACKING: const attackTimeElapsed = Date.now() - this.attackStartTime; // Check if attack sequence is complete if (attackTimeElapsed >= this.settings.attackDuration) { console.log(`[Enemy ${this.id}] Attack animation completed after: ${attackTimeElapsed}ms`); this._loggedWindup = false; this._loggedActive = false; this.waitStartTime = Date.now(); // Set wait start time when attack completes newState = APP_SETTINGS.enemyStates.IDLE; } break; } if (newState !== this.currentState) { this.exitState(this.currentState); this.currentState = newState; this.enterState(this.currentState); } this.executeStateAction(this.currentState, deltaTime, playerPosition); } handleHit(damage) { if (this.isDead || !this.model || !this.model.visible) return; this.currentHealth = Math.max(0, this.currentHealth - damage); // Play bullet hit sound if (window.AudioManager) { window.AudioManager.play('hit_bullet'); } if (this.currentHealth <= 0) { // Play death sound before dying if (window.AudioManager) { window.AudioManager.play('zombie_death'); } this.die(); } } die() { if (this.isDead) return; // Start death sequence with animations and effects this.startDeathSequence(); this.deathTime = Date.now(); // Record time of death // Notify WaveManager of enemy death - removed automatic respawn if (window.WaveManager) { window.WaveManager.onEnemyDeath(this); } } canRespawn() { if (!this.isDead || !this.respawnSettings.enabled) { return false; } const timeSinceDeath = Date.now() - this.deathTime; return timeSinceDeath >= this.respawnSettings.delay; } startDeathSequence() { // Immediately hide the model if (this.model) { this.model.visible = false; } this.isDead = true; this.updateDebugText(); if (this.model) { this.deathEffect = new ParticleDeathEffect({ THREE: THREE, scene: this.scene, model: this.model, duration: 1000 // Optional, defaults to 1000ms }); this.deathEffect.start(); } // No gun to hide if (this.physicsBody) { this.physicsBody.sleep(); } } respawn() { if (!this.isDead) return; this.currentHealth = this.maxHealth; this.isDead = false; const spawnPositions = APP_SETTINGS.tilemap.enemySpawns; const randomIndex = Math.floor(Math.random() * spawnPositions.length); const spawnPoint = spawnPositions[randomIndex]; const worldXZ = window.GameWorld.tilemap.gridToWorldPosition(spawnPoint.x, spawnPoint.z); const newPosition = new THREE.Vector3( worldXZ.x, APP_SETTINGS.enemySpawns.spawnHeight, worldXZ.z ); this.setPosition(newPosition); if (this.model) { this.model.position.copy(newPosition); this.model.visible = true; } if (this.physicsBody) { this.physicsBody.wakeUp(); } // No gun to show this.updateDebugText(); console.log('Enemy respawned'); } checkVision(playerPosition) { const currentTime = Date.now(); if (currentTime - this.lastVisionCheck < this.visionCheckInterval) { return; } this.lastVisionCheck = currentTime; if (!playerPosition || !window.GameWorld?.tilemap) { this.canSeePlayer = false; this.hasTargetLock = false; this.canSeePlayerStartTime = 0; return; } const enemyPosition = this.getPosition(); enemyPosition.y += this.getRaycastOffset(); const baseDirection = new THREE.Vector3() .subVectors(playerPosition, enemyPosition) .normalize(); // Create spread angles for multiple rays const spreadAngles = [-0.05, 0, 0.05]; // Small spread angles in radians const allRaysHit = spreadAngles.every(angle => { // Create rotated direction vector const rotatedDirection = baseDirection.clone(); rotatedDirection.applyAxisAngle(new THREE.Vector3(0, 1, 0), angle); this.visionRay.update(enemyPosition, rotatedDirection); // Get obstacles and walls from tilemap const obstacles = window.GameWorld.tilemap.getObstacles(); const walls = window.GameWorld.tilemap.getWalls(); // Check all obstacles for (const obstacle of obstacles) { if (obstacle?.mesh) { const intersection = this.visionRay.checkIntersection(obstacle.mesh); if (intersection) { const distanceToObstacle = intersection.distance; const distanceToPlayer = enemyPosition.distanceTo(playerPosition); if (distanceToObstacle < distanceToPlayer) { return false; // Ray hit an obstacle before player } } } } // Check all walls for (const wall of walls) { if (wall?.mesh) { const intersection = this.visionRay.checkIntersection(wall.mesh); if (intersection) { const distanceToWall = intersection.distance; const distanceToPlayer = enemyPosition.distanceTo(playerPosition); if (distanceToWall < distanceToPlayer) { return false; // Ray hit a wall before player } } } } return true; // This ray has clear line of sight }); // Update vision state if (allRaysHit) { if (!this.canSeePlayer) { this.canSeePlayerStartTime = currentTime; } this.canSeePlayer = true; // Check if we've been seeing the player long enough for target lock if (currentTime - this.canSeePlayerStartTime >= this.targetingDelay) { this.hasTargetLock = true; } } else { this.canSeePlayer = false; this.hasTargetLock = false; this.canSeePlayerStartTime = 0; } } } class App { constructor() { this.createRenderDivs(); this.clock = new THREE.Clock(); this.initialLoadingComplete = false; this.gameOverScreen = null; this.spriteSheet = null; this.deltaTime = 0; this.init(); } 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); }); } async loadScripts() { try { for (const script of SCRIPT_ASSETS) { await this.loadScript(script.url); console.log(`Script loaded: ${script.name}`); } } catch (error) { console.error('Error loading scripts:', error); } } async init() { try { // First, load only essential scripts and audio manager await this.loadScripts(); window.LoadingManager = new THREE.LoadingManager(); this.setupLoadingManager(); window.Materials = MaterialManager(); window.Meshes = MeshManager(); window.Lights = LightingManager(); window.ModelLoader = new ModelLoader({ THREE: THREE, GLTFLoader: GLTFLoader, FBXLoader: FBXLoader, OBJLoader: OBJLoader, LoadingManager: window.LoadingManager }); window.GameWorld = new World(); window.AudioManager = new AudioManager({ THREE: THREE, camera: MainCamera, LoadingManager: window.LoadingManager, soundAssets: SOUND_ASSETS }); // Load audio assets and play intro sounds immediately await window.AudioManager.loadSoundAssets(); this.playIntroSounds(); // Continue with rest of initialization window.ImageLoader = new ImageLoader({ LoadingManager: window.LoadingManager, IMAGE_ASSETS: IMAGE_ASSETS }); // Create game over screen window.GameOverScreen = new GameOverScreen({ container: window.uiDiv, settings: { backgroundColor: 'rgba(0, 0, 0, 0.8)', textColor: '#ffffff', fontSize: '48px', fontFamily: 'Arial, sans-serif', message: 'GAME OVER', subMessage: 'Press R to Play Again!', waveCounterMessage: 'You Survived', waveNumberFontSize: '32px', highScoreFontSize: '28px' } }); // Show game over screen if enabled in settings if (APP_SETTINGS.controls.showGameOverOnStart) { window.GameOverScreen.show(); } window.GunConfigs = new GunConfigs({ THREE: THREE, MODEL_ASSETS: MODEL_ASSETS, SOUND_ASSETS: SOUND_ASSETS }); } catch (error) { console.error('Error during initialization:', error); return; } window.Input = new InputHandler({ THREE: THREE, canvas: canvas, settings: APP_SETTINGS }); window.CameraControl = new CameraController({ THREE: THREE, camera: MainCamera, settings: APP_SETTINGS }); window.GunManager = new GunManager({ THREE: THREE, CANNON: CANNON, scene: WorldScene, camera: MainCamera, settings: APP_SETTINGS, Gun: Gun, Ray: Ray, VisibileRay: VisibileRay, gunConfigs: window.GunConfigs.configs }); await window.GunManager.initialize(); window.EnemyManager = new EnemyManager({ THREE: THREE, FBXLoader: FBXLoader, LoadingManager: window.LoadingManager, scene: window.WorldScene, settings: APP_SETTINGS, Enemy: Enemy, EnemyLoader: EnemyLoader, EnemyAnimationController: EnemyAnimationController, MODEL_ASSETS: MODEL_ASSETS }); window.Player = new Player(MainCamera); window.WaveManager = new WaveManager({ enemyManager: window.EnemyManager, settings: APP_SETTINGS, DebugText: DebugText }); window.GunManager.assignHolder('player', window.Player, 'player'); GameWorld.createTilemap(); try { await window.ImageLoader.loadAllImages(); window.HUD = new HUD({ uiContainer: window.uiDiv, AmmoDisplay: AmmoDisplay, Crosshair: Crosshair, GunLoadoutPanel: GunLoadoutPanel, GunHUDContainer: GunHUDContainer, HealthBar: HealthBar, WaveTracker: WaveTracker, Player: window.Player, settings: APP_SETTINGS }); window.HUD.init(); window.HUD.hide(); // Initially hide the HUD } catch (error) { console.error('Failed to load images or initialize HUD:', error); } try { if (APP_SETTINGS.controls.preloadEnemiesOnStart) { await window.EnemyManager.preloadEnemyAssets(); } await window.GunManager.initializeHolders(); // Start first wave only if enabled in settings if (APP_SETTINGS.controls.startWaveOnInit) { window.WaveManager.startWave(); } // Set loading complete after everything is initialized this.initialLoadingComplete = true; loadingScreen.style.display = 'none'; if (window.HUD) { window.HUD.show(); } } catch (error) { console.error('Failed to initialize gun system:', error); } this.addEventListeners(); } playIntroSounds() { if (window.AudioManager) { // Play the rising sound effect first window.AudioManager.play('intro_rise'); // Play the voice intro after a short delay setTimeout(() => { window.AudioManager.play('intro_voice'); }, 500); // 500ms delay } } setupLoadingManager() { LoadingManager.onLoad = () => { console.log("Base assets loaded"); }; LoadingManager.onError = (url) => { console.error('Error loading:', url); }; } addEventListeners() { addEventListener('resize', this.onWindowResize.bind(this)); const resizeObserver = new ResizeObserver(this.onWindowResize.bind(this)); resizeObserver.observe(parentDiv); } onWindowResize() { const width = parentDiv.clientWidth; const height = parentDiv.clientHeight; if (GameWorld) { MainCamera.aspect = width / height; MainCamera.updateProjectionMatrix(); GameRenderer.setSize(width, height); } } animate() { requestAnimationFrame(this.animate.bind(this)); this.deltaTime = Math.min(this.clock.getDelta(), 0.1); if (this.initialLoadingComplete) { if (window.GameWorld) { window.GameWorld.update(this.deltaTime); } if (window.CameraControl) { window.CameraControl.update(); } if (window.Player) { window.Player.update(this.deltaTime); } if (window.Input) { window.Input.update(); } if (window.GunManager) { window.GunManager.update(this.deltaTime); } // Update HUD if (window.HUD) { window.HUD.update(); if (window.HUD.components.weaponDisplay) { window.HUD.components.weaponDisplay.update(); } } // Update wave manager and enemies if (window.WaveManager) { window.WaveManager.update(); } if (window.EnemyManager && window.Player) { const playerPosition = window.Player.getPosition(); window.EnemyManager.update(this.deltaTime, playerPosition); } if (this.worldClock) { this.worldClock.update(GameWorld.Time); } else { //console.warn('WorldClock not initialized'); } } } start() { this.animate(); } createRenderDivs() { // Can create global variables by assigning them to window.variableName. window.parentDiv = document.getElementById('renderDiv'); window.canvas = document.getElementById('threeRenderCanvas'); window.loadingScreen = document.createElement('div'); if (!canvas) { canvas = document.createElement('canvas'); canvas.id = 'threeRenderCanvas'; parentDiv.appendChild(canvas); } // Create loading screen loadingScreen.style.position = 'absolute'; loadingScreen.style.top = '0'; loadingScreen.style.left = '0'; loadingScreen.style.width = '100%'; loadingScreen.style.height = '100%'; loadingScreen.style.backgroundColor = 'rgba(0, 0, 0, 0.8)'; loadingScreen.style.color = 'white'; loadingScreen.style.display = 'flex'; loadingScreen.style.justifyContent = 'center'; loadingScreen.style.alignItems = 'center'; loadingScreen.style.fontSize = '24px'; // Create a container for loading text and subtitles const loadingContent = document.createElement('div'); loadingContent.style.display = 'flex'; loadingContent.style.flexDirection = 'column'; loadingContent.style.alignItems = 'center'; loadingContent.style.gap = '20px'; // Loading text const loadingText = document.createElement('div'); loadingText.textContent = 'Loading...'; // Subtitle text const subtitleText = document.createElement('div'); subtitleText.style.fontStyle = 'italic'; subtitleText.style.fontSize = '18px'; subtitleText.style.maxWidth = '600px'; subtitleText.style.textAlign = 'center'; subtitleText.style.lineHeight = '1.5'; subtitleText.textContent = "Zentech Corp's greed unleashed the virus, turning humanity into monsters. They hunted us to extinction. You're the last free man. Survive, or it's truly over."; // Dev tip text const devTipText = document.createElement('div'); devTipText.style.fontSize = '16px'; devTipText.style.color = '#888'; devTipText.style.marginTop = '10px'; devTipText.textContent = '(Click screen for cool AI voiceover!)'; // Append all elements to the loading content loadingContent.appendChild(loadingText); loadingContent.appendChild(subtitleText); loadingContent.appendChild(devTipText); loadingScreen.appendChild(loadingContent); parentDiv.appendChild(loadingScreen); window.uiDiv = document.createElement('div'); uiDiv.id = 'uiDiv'; uiDiv.style.position = 'absolute'; uiDiv.style.top = '0'; uiDiv.style.left = '0'; uiDiv.style.width = '100%'; uiDiv.style.height = '100%'; uiDiv.style.pointerEvents = 'none'; // Set to 'none' to allow events to pass through uiDiv.style.userSelect = 'none'; // Disable text selection uiDiv.style.webkitUserSelect = 'none'; // For Safari uiDiv.style.msUserSelect = 'none'; // For IE/Edge // Apply the same styles to parentDiv parentDiv.style.userSelect = 'none'; parentDiv.style.webkitUserSelect = 'none'; parentDiv.style.msUserSelect = 'none'; parentDiv.appendChild(uiDiv); } resetGameState() { // Reset player if (window.Player) { window.Player.reset(); } // Reset wave manager if (window.WaveManager) { window.WaveManager.reset(); // Start first wave after reset window.WaveManager.startWave(); } // Hide game over screen if (window.GameOverScreen) { window.GameOverScreen.hide(); } // Show HUD if (window.HUD) { window.HUD.show(); } } } window.Game = new App(); Game.start();