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_gunConfigs", url: "https://play.rosebud.ai/assets/script_gunConfigs.js?UlBV", }, { name: "script_hud", url: "https://play.rosebud.ai/assets/script_hud.js?1FxX", }, { name: "script_gunManager", url: "https://play.rosebud.ai/assets/script_gunManager.js?Mgsu", }, { name: "script_gunController", url: "https://play.rosebud.ai/assets/script_gunController.js?9cOw", }, { 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_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?BJOC" }, { name: "script_inputHandler", url: "https://play.rosebud.ai/assets/script_inputHandler.js?GbXi" }]; 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_PistolIdle.fbx?2wMS', walk: 'https://play.rosebud.ai/assets/anim_xbot_WalkInPlace.fbx?P0Lu', pistolIdle: 'https://play.rosebud.ai/assets/anim_xbot_PistolIdle.fbx?EAlP', pistolWalk: 'https://play.rosebud.ai/assets/anim_xbot_PistolWalk.fbx?TbSV' } }, }; const SOUND_ASSETS = { effects: { hit_bullet: { url: 'https://play.rosebud.ai/assets/snd_bullet_hit.wav?5GSg', volume: 0.45, key: 'hit_bullet' }, 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: { basic_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: 0 // Height above ground for enemy spawn }, tilemap: { width: 10, height: 15, tileSize: 20, enemySpawns: [{ x: 3, z: 7 }, { x: 6, z: 7 }, { x: 3, z: 9, }, { x: 6, z: 9 }], obstacles: [ // Middle barrier center map { x: 4, z: 7, }, { x: 5, z: 7, }, // Extends from east wall { x: 9, z: 5 }, { x: 8, z: 5 }, { x: 7, z: 5 }, // Extends west wall { x: 2, z: 5 }, { x: 1, z: 5 }, { x: 0, z: 5 }, // Extends from east wall { x: 9, z: 9 }, { x: 8, z: 9 }, { x: 7, z: 9 }, // Extends west wall { x: 2, z: 9 }, { x: 1, z: 9 }, { x: 0, z: 9 }, ] }, obstacles: { height: 50, physics: { mass: 0, // Static obstacles friction: 0.5, restitution: 0.3 }, material: { color: 0x808080, roughness: 0.7, metalness: 0.2 } }, controls: { createEnemyOnStart: true, enemiesToSpawn: 1, showNavMesh: false, showEnemyPath: false, enablePlayerInvulnerability: false, enableSunMovement: false, enableGunRecoil: true, enableGunReload: true, enableEnemyChasing: false, showEnemyDebugText: true, showPlayerDebugText: true, enableEnemyRespawn: true, enableEnemyShooting: true, 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: 0x87CEEB, groundColor: 0xFFFFFF }, }, enemyStates: { WAITING: 'WAITING' }, 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, intensity: 3, position: { x: -50, y: 40, z: 50 // 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 GunController { constructor(params) { // Validate required parameters if (!params) { throw new Error('GunController: params object is required'); } // Required dependencies const required = ['THREE', 'Ray', 'APP_SETTINGS']; for (const prop of required) { if (!params[prop]) { throw new Error(`GunController: ${prop} is required`); } } // Store dependencies this.THREE = params.THREE; this.Ray = params.Ray; this.settings = params.APP_SETTINGS; // Initialize properties this.mount = null; this.holder = null; this.currentGun = null; this.ray = new this.Ray({ THREE: this.THREE, far: params.rayDistance || 1000 }); this.lastShotTime = 0; this.lastActionTime = 0; this.isReloading = false; this.queuedWeaponSwitch = null; this.states = { IDLE: 'IDLE', SHOOTING: 'SHOOTING', RELOADING: 'RELOADING', SWITCHING: 'SWITCHING' }; this.currentState = this.states.IDLE; this.currentTime = 0; this.lastShotTime = 0; this.reloadStartTime = 0; this.reloadTime = 1000; this.cooldownTime = 250; this.wasMouseDown = false; } canShoot() { if (!this.currentGun) { return false; } const currentTime = Date.now(); const timeSinceLastShot = currentTime - this.lastShotTime; return ( this.currentState === this.states.IDLE && this.currentGun.currentAmmo > 0 && timeSinceLastShot >= this.cooldownTime && !this.isReloading ); } canSwitch() { const GunManager = window.GunManager; if (!this.holder || !GunManager || !this.holderName) { return false; } const holderData = GunManager.getHolderData(this.holderName); return ( this.currentState === this.states.IDLE && holderData && holderData.inventory.size > 1 ); } switchGun(newGunType) { if (this.currentState === this.states.SHOOTING || this.currentState === this.states.RELOADING) { this.queuedWeaponSwitch = newGunType; return true; } if (!this.canSwitch()) { return false; } this.currentState = this.states.SWITCHING; this.enterState(this.states.SWITCHING, newGunType); return true; } canReload() { return ( !this.isReloading && this.currentGun && this.currentGun.currentAmmo < this.currentGun.maxAmmo && this.currentState !== this.states.RELOADING ); } isShootingComplete() { return Date.now() - this.lastShotTime >= this.cooldownTime; } isReloadComplete() { return Date.now() - this.reloadStartTime >= this.reloadTime; } enterState(state, gunType = null) { switch (state) { case this.states.SHOOTING: if (!this.currentGun) return; this.lastShotTime = Date.now(); this.currentGun.currentAmmo--; this.isReloading = false; if (this.holderType === 'player') { this.currentGun.playSound('shoot'); this.currentGun.startAnimation('recoil'); } this.performRaycast(); break; case this.states.RELOADING: if (!this.currentGun) return; this.reloadStartTime = Date.now(); if (this.holderType === 'player') { this.currentGun.playSound('reload'); this.currentGun.startAnimation('reload'); } break; case this.states.SWITCHING: if (!gunType) { this.exitState(this.states.SWITCHING); return; } if (window.GunManager.setCurrentGun(this.holderName, gunType)) { this.exitState(this.states.SWITCHING); } break; } } exitState(state) { if (!this.currentGun) return; switch (state) { case this.states.RELOADING: this.isReloading = false; this.currentGun.currentAmmo = this.currentGun.maxAmmo; this.currentGun.stopAnimation('reload'); break; case this.states.SHOOTING: this.currentGun.stopAnimation('recoil'); break; case this.states.SWITCHING: this.currentState = this.states.IDLE; break; } } shoot() { if (!this.currentGun || !this.canShoot()) return false; // Trigger shooting state this.currentState = this.states.SHOOTING; this.enterState(this.states.SHOOTING); this.lastActionTime = Date.now(); return true; } reload() { if (!this.currentGun || !this.canReload()) return false; // Trigger reload state this.currentState = this.states.RELOADING; this.enterState(this.states.RELOADING); this.lastActionTime = Date.now(); this.isReloading = true; // Set isReloading to true when reload starts return true; } executeStateAction() { if (!this.currentGun) return; switch (this.currentState) { case this.states.SHOOTING: this.currentGun.updateAnimation('recoil'); break; case this.states.RELOADING: if (this.currentGun) { this.currentGun.updateAnimation('reload'); } break; } } setMount(mount) { console.log('GunController.setMount called with mount:', mount); if (!mount) { console.warn('GunController.setMount: Mount is undefined or null'); return false; } this.mount = mount; console.log('GunController.setMount: Mount successfully set:', this.mount); return true; } getMount() { return this.mount; } setHolder(holder, holderType, holderName) { if (!holder || !holderName) return false; this.holder = holder; this.holderType = holderType; this.holderName = holderName; return true; } getHolder() { return this.holder; } setGun(gun) { if (!gun || !this.holderName) return false; // Request gun settings through GunManager const GunManager = window.GunManager; if (!GunManager) { console.error('GunController: GunManager not available'); return false; } this.currentGun = gun; this.currentGun.holderType = this.holderType; this.currentGun.holderName = this.holderName; if (this.mount) { this.mount.gunSettings = gun.settings; } const gunType = Object.keys(this.settings.guns).find(type => this.settings.guns[type].model === gun.settings.model ); if (gunType) { const gunSettings = this.settings.guns[gunType]; this.reloadTime = gunSettings.timing.reload; this.cooldownTime = gunSettings.timing.cooldown; } if (this.mount) { gun.mount = this.mount; } return true; } getGun() { return this.currentGun; } assignMount(gun) { return this.setGun(gun); } update() { if (!this.currentGun) { console.debug('GunController.update: No current gun assigned'); return; } if (!this.mount) { console.warn('GunController.update: No mount assigned'); return; } this.currentTime = Date.now(); let newState = this.currentState; switch (this.currentState) { case this.states.SHOOTING: if (this.isShootingComplete()) { newState = this.states.IDLE; } break; case this.states.RELOADING: if (this.isReloadComplete()) { this.currentGun.currentAmmo = this.currentGun.maxAmmo; if (this.queuedWeaponSwitch) { newState = this.states.SWITCHING; } else { newState = this.states.IDLE; } } break; case this.states.IDLE: if (this.currentGun.currentAmmo <= 0 && this.canReload()) { newState = this.states.RELOADING; } break; } if (newState !== this.currentState) { this.exitState(this.currentState); this.currentState = newState; if (this.currentState === this.states.SWITCHING && this.queuedWeaponSwitch) { this.enterState(this.currentState, this.queuedWeaponSwitch); this.queuedWeaponSwitch = null; } else { this.enterState(this.currentState); } } this.executeStateAction(); } getRaycastPosition() { if (this.holderType === 'enemy' && this.holder.getRaycastOffset) { const basePosition = this.holder.getPosition(); const offset = this.holder.getRaycastOffset(); return new this.THREE.Vector3( basePosition.x, basePosition.y + offset, basePosition.z ); } // Default behavior for player or if no specific offset is provided return this.mount.mountPoint.getWorldPosition(new this.THREE.Vector3()); } getRayDirection() { // If the holder is an enemy and player exists, calculate direction to player's hitbox if (this.holderType === 'enemy' && window.Player) { const enemyPosition = this.getRaycastPosition(); const playerHitbox = window.Player.getHitboxMesh(); if (playerHitbox) { const targetPosition = playerHitbox.position.clone(); // Calculate direction from enemy to player hitbox const direction = new this.THREE.Vector3() .subVectors(targetPosition, enemyPosition) .normalize(); return direction; } } // Default behavior for player or if no player hitbox exists return this.mount.mountPoint.getWorldDirection(new this.THREE.Vector3()); } checkIntersectionWithMesh(mesh, minDistance) { if (!mesh) return null; const intersection = this.ray.checkIntersection(mesh); if (intersection && intersection.distance < minDistance) { return { ...intersection, distance: intersection.distance, type: mesh.userData.type || mesh.constructor.name.toLowerCase(), target: mesh.userData.owner }; } return null; } handleHit(target, damage) { if (target?.handleHit && this.currentGun) { target.handleHit(damage); this.currentGun.playSound('hit'); } } performRaycast() { if (!this.mount || !this.holder) return null; const position = this.getRaycastPosition(); const direction = this.getRayDirection(); this.ray.update(position, direction); // Create visible ray effect based on holder type and settings if (this.currentGun) { const shouldShowRay = (this.holderType === 'player' && this.settings.controls.enablePlayerRayVisibility) || (this.holderType === 'enemy' && this.settings.controls.enableEnemyRayVisibility); if (shouldShowRay) { this.currentGun.createVisibleRay(position, direction); } } let closestIntersection = null; let minDistance = Infinity; // Get all collidable objects const collidables = []; // Add obstacles and walls from tilemap if (GameWorld.tilemap) { collidables.push( ...GameWorld.tilemap.getObstacles().map(o => o.mesh), ...GameWorld.tilemap.getWalls().map(w => w.mesh) ); } // Add all enemy hitboxes if (window.EnemyManager) { const enemies = window.EnemyManager.getAllEnemies(); for (const enemy of enemies) { if (enemy?.getHitboxMesh()) { const enemyHitbox = enemy.getHitboxMesh(); enemyHitbox.userData.owner = enemy; collidables.push(enemyHitbox); } } } // Add player hitbox if (window.Player?.getHitboxMesh()) { const playerHitbox = window.Player.getHitboxMesh(); playerHitbox.userData.owner = window.Player; collidables.push(playerHitbox); } // Check all collidables for (const mesh of collidables) { if (!mesh) continue; const intersection = this.checkIntersectionWithMesh(mesh, minDistance); if (intersection) { minDistance = intersection.distance; closestIntersection = intersection; } } // Handle hit if we found an intersection with a target if (closestIntersection?.target && closestIntersection.target !== this.holder) { this.handleHit(closestIntersection.target, this.currentGun.settings.damage); } return closestIntersection; } } class Gun { static nextId = 1; constructor(scene, camera, model, settings) { this.id = Gun.nextId++; this.scene = scene; this.camera = camera; this.model = model; this.mount = null; this.visibleRay = null; this.deltaTime = 0; this.settings = settings; // Initialize animation system from settings this.animations = { recoil: { active: false, progress: 0, startTime: 0, currentOffset: new THREE.Vector3(), settings: settings.animations?.recoil || {} }, reload: { active: false, progress: 0, startTime: 0, currentOffset: new THREE.Vector3(), currentRotation: new THREE.Vector3(), settings: settings.animations?.reload || {} } }; this.currentAmmo = settings.ammo.current; this.maxAmmo = settings.ammo.max; this.currentPosition = settings.position; this.currentRotation = settings.rotation; if (this.shootSound && settings.sound?.volume) { this.shootSound.setVolume(settings.sound.volume); } this.settings = settings; this.activeRays = []; this.muzzleFlash = null; this.ray = new Ray({ THREE, origin: new THREE.Vector3(), direction: new THREE.Vector3() }); this.holderType = null; this.setupModel(); } setupModel() { if (this.model) { this.scene.add(this.model); } } createVisibleRay(start, direction) { const ray = new VisibileRay({ THREE: THREE, scene: this.scene, duration: 250 }); ray.create(start, direction); this.activeRays.push(ray); } updateVisibleRays() { for (let i = this.activeRays.length - 1; i >= 0; i--) { const ray = this.activeRays[i]; if (ray.active) { ray.update(); } else { ray.dispose(); this.activeRays.splice(i, 1); } } } clearVisibleRays() { while (this.activeRays.length > 0) { const ray = this.activeRays.pop(); ray.dispose(); } } setupForHolder(holderName, gunSettings) { const scale = gunSettings.model.scaleByHolder[holderName] || gunSettings.model.scale; if (this.model) { this.model.scale.setScalar(scale); } } updatePosition(deltaTime) { if (!this.model || !this.mount) return; const mountWorldPosition = this.mount.getWorldPosition(); const mountWorldRotation = this.mount.getWorldRotation(); this.model.position.copy(mountWorldPosition); if (this.muzzleFlash) { this.muzzleFlash.update(this.model.position, this.model.quaternion); } this.updateModelTransform(); } startAnimation(type) { const animation = this.animations[type]; if (!animation || (type === 'reload' && !APP_SETTINGS.controls.enableGunReload) || (type === 'recoil' && !APP_SETTINGS.controls.enableGunRecoil)) { return; } animation.active = true; animation.startTime = Date.now(); animation.progress = 0; animation.currentOffset.set(0, 0, 0); if (animation.currentRotation) { animation.currentRotation.set(0, 0, 0); } } updateAnimation(type) { const animation = this.animations[type]; if (!animation || !animation.active || (type === 'reload' && !APP_SETTINGS.controls.enableGunReload) || (type === 'recoil' && !APP_SETTINGS.controls.enableGunRecoil)) { return; } const currentTime = Date.now(); const elapsed = currentTime - animation.startTime; const duration = animation.settings.duration; if (elapsed >= duration) { this.stopAnimation(type); return; } const rawProgress = elapsed / duration; let easedProgress; if (rawProgress < 0.5) { const adjustedProgress = rawProgress * 2; const power = type === 'reload' && animation.settings.position?.easing?.power ? animation.settings.position.easing.power : animation.settings.easing?.power || 2; easedProgress = Math.pow(adjustedProgress, power); } else { const adjustedProgress = (rawProgress - 0.5) * 2; const recovery = type === 'reload' && animation.settings.position?.easing?.recovery ? animation.settings.position.easing.recovery : animation.settings.easing?.recovery || 0.5; easedProgress = 1 - Math.pow(adjustedProgress, recovery); } if (this.mount) { this.mount.resetOffsets(); if (type === 'reload' && animation.settings.position && animation.settings.rotation) { const posOffset = new THREE.Vector3( animation.settings.position.offset.x, animation.settings.position.offset.y, animation.settings.position.offset.z ); const rotOffset = new THREE.Vector3( animation.settings.rotation.offset.x, animation.settings.rotation.offset.y, animation.settings.rotation.offset.z ); animation.currentOffset.copy(posOffset).multiplyScalar(easedProgress); animation.currentRotation.copy(rotOffset).multiplyScalar(easedProgress); this.mount.addPositionOffset(animation.currentOffset); this.mount.addRotationOffset(animation.currentRotation); } else if (type === 'recoil' && animation.settings.distance) { const recoilDistance = animation.settings.distance * easedProgress; animation.currentOffset.set(0, recoilDistance * 0.2, recoilDistance); this.mount.addPositionOffset(animation.currentOffset); } } } stopAnimation(type) { const animation = this.animations[type]; if (!animation) return; animation.active = false; animation.progress = 0; animation.currentOffset.set(0, 0, 0); if (animation.currentRotation) { animation.currentRotation.set(0, 0, 0); } if (this.mount) { this.mount.resetOffsets(); } } updateModelTransform() { if (!this.model || !this.mount) return; const worldPosition = this.mount.getWorldPosition(); const worldRotation = this.mount.getWorldRotation(); this.model.position.copy(worldPosition); // Create quaternion for world rotation const targetQuaternion = new THREE.Quaternion(); targetQuaternion.setFromEuler(new THREE.Euler( worldRotation.x, worldRotation.y, worldRotation.z, 'XYZ' )); // Apply gun-specific rotation offset if available if (this.settings.model.rotationOffset) { const offsetQuaternion = new THREE.Quaternion(); offsetQuaternion.setFromEuler(new THREE.Euler( this.settings.model.rotationOffset.x, this.settings.model.rotationOffset.y, this.settings.model.rotationOffset.z, 'XYZ' )); targetQuaternion.multiply(offsetQuaternion); } this.model.quaternion.copy(targetQuaternion); } update(deltaTime) { if (!this.checkInputSystem()) { return; } if (this.mount) { this.updateModelTransform(); } this.updatePosition() // Always update visible rays if they exist this.updateVisibleRays(); } checkInputSystem() { if (!window.Input) { console.log('Gun update: Input system not available'); return false; } return true; } playSound(type) { if (this.holderType !== 'player') return; if (!window.AudioManager) return; // Get the sound configuration for this type from gun settings const soundConfig = this.settings.sounds?.[type]; if (!soundConfig) { console.warn(`No sound configuration found for type: ${type}`); return; } // Play the sound using the key from the configuration if (soundConfig.key) { window.AudioManager.play(soundConfig.key); } } resetEffects() { this.recoil.active = false; } getCurrentAmmo() { return this.currentAmmo; } getMaxAmmo() { return this.maxAmmo; } hide() { if (this.model) { this.model.visible = false; } } show() { if (this.model) { this.model.visible = true; } } } 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 EnemyLoader { constructor({ THREE, FBXLoader, LoadingManager }) { this.THREE = THREE; this.FBXLoader = FBXLoader; this.LoadingManager = LoadingManager; } async loadModel(modelSettings) { if (!modelSettings) { throw new Error('Model settings are required'); } const model = await window.ModelLoader.loadModel(modelSettings); if (!model) { throw new Error('Failed to load enemy model'); } model.traverse((child) => { if (child.isMesh) { child.raycast = THREE.Mesh.prototype.raycast; } }); return model; } async loadAnimations(model, animationSettings) { const animationController = new EnemyAnimationController({ THREE: this.THREE, FBXLoader: this.FBXLoader, settings: { model: { animations: animationSettings } }, model: model }); await animationController.loadAllAnimations(); return animationController; } async preloadEnemyAssets(enemySettings) { try { const model = await this.loadModel(enemySettings.model); const animationController = await this.loadAnimations( model, enemySettings.model.animations ); return { model, animationController }; } catch (error) { console.error('Failed to preload enemy assets:', error); throw error; } } } class Enemy { static nextId = 1; static COMBAT_STATES = { IDLE: 'IDLE', LOOKING_FOR_TARGET: 'LOOKING_FOR_TARGET', TARGETING: 'TARGETING', SHOOTING_TARGET: 'SHOOTING_TARGET' }; constructor(scene, settings) { this.id = Enemy.nextId++; this.holderType = 'enemy'; this.getHolderType = () => this.holderType; this.getHolderId = () => `enemy_${this.id}`; this.canSeePlayer = false; this.targetingStartTime = 0; this.targetingDelay = 1000; // 1 second delay this.visionRay = new Ray({ THREE: THREE, far: 1000 }); this.lastVisionCheck = 0; this.visionCheckInterval = 100; // Check every 100ms if (!settings) { throw new Error('Enemy: settings are required'); } // Initialize combat state this.combatState = Enemy.COMBAT_STATES.LOOKING_FOR_TARGET; // 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.dimensions.width, this.settings.dimensions.height, this.settings.dimensions.depth ); this.physicsBody = this.createPhysicsBody( this.bodyDimensions, new CANNON.Vec3( this.settings.position.x, this.settings.position.y, this.settings.position.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) { this.createHitbox(); this.mountSettings = { position: new THREE.Vector3(-0.5, 13.6, 5.5), rotation: new THREE.Vector3(0, Math.PI + Math.PI / 2, 0) }; this.gunMount = new GunMount({ THREE: THREE, mountPoint: this.model, defaultPosition: this.mountSettings.position, defaultRotation: this.mountSettings.rotation }); this.gunController = new GunController({ THREE: THREE, Ray: Ray, APP_SETTINGS: APP_SETTINGS, rayDistance: 1000 }); // Assign enemy as a gun holder window.GunManager.assignHolder(this.getHolderId(), this, 'basic_enemy'); this.gunController.setMount(this.gunMount); this.gunController.setHolder(this, this.holderType, this.getHolderId()); 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; } } createHitbox() { // Create a hitbox with specified dimensions and offset const hitboxGeometry = new THREE.BoxGeometry( this.settings.dimensions.width, this.settings.dimensions.height, this.settings.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; } 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.WAITING: this.waitStartTime = currentTime; this.moveSpeed = 0; this.animationController.transitionToAnimation('idle'); break; } } executeStateAction(state, deltaTime, playerPosition) { switch (state) { case APP_SETTINGS.enemyStates.WAITING: this.executeWaitAction(deltaTime, playerPosition); this.handleCombat(playerPosition); break; } } handleCombat(targetPosition) { if (this.isDead || !this.gunController) return; // Only handle shooting if it's enabled in settings if (!APP_SETTINGS.controls.enableEnemyShooting) return; const currentTime = Date.now(); // Update combat state based on visibility if (this.canSeePlayer) { if (this.combatState === Enemy.COMBAT_STATES.LOOKING_FOR_TARGET) { console.log('Enemy: Target acquired, starting targeting!'); this.combatState = Enemy.COMBAT_STATES.TARGETING; this.targetingStartTime = currentTime; } else if (this.combatState === Enemy.COMBAT_STATES.TARGETING) { if (currentTime - this.targetingStartTime >= this.targetingDelay) { console.log('Enemy: Targeting complete, ready to shoot!'); this.combatState = Enemy.COMBAT_STATES.SHOOTING_TARGET; } } } else { if (this.combatState === Enemy.COMBAT_STATES.SHOOTING_TARGET || this.combatState === Enemy.COMBAT_STATES.TARGETING) { console.log('Enemy: Lost visual on target!'); this.combatState = Enemy.COMBAT_STATES.LOOKING_FOR_TARGET; } } // Handle shooting based on combat state switch (this.combatState) { case Enemy.COMBAT_STATES.SHOOTING_TARGET: if (this.gunController.canShoot()) { console.log('Enemy: Shooting!'); this.gunController.shoot(); } break; case Enemy.COMBAT_STATES.TARGETING: // Update aim but don't shoot during targeting delay break; case Enemy.COMBAT_STATES.LOOKING_FOR_TARGET: // Continue tracking but don't shoot break; } } exitState(state) { switch (state) { case APP_SETTINGS.enemyStates.WAITING: break; } } moveInDirection(targetPosition, deltaTime, lookAtTarget = true) { const currentPos = this.getPosition(); 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); } } 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 ); } 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 = APP_SETTINGS.enemySpawns.spawnHeight || 2; // Use spawn height or default to 2 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('Combat', this.combatState); this.debugText.setText('Health', `${this.currentHealth}/${this.maxHealth}`); this.debugText.setText('Can See Player', this.canSeePlayer ? 'YES' : 'NO'); } 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) { this.gunMount.update(deltaTime); } if (this.gunController) { this.gunController.update(); } if (this.animationController) { this.animationController.update(deltaTime); } this.updateModelTransform(); if (this.currentState !== APP_SETTINGS.enemyStates.WAITING) { this.exitState(this.currentState); this.currentState = APP_SETTINGS.enemyStates.WAITING; this.enterState(APP_SETTINGS.enemyStates.WAITING); } this.executeStateAction(APP_SETTINGS.enemyStates.WAITING, deltaTime, playerPosition); } handleHit(damage) { if (this.isDead || !this.model || !this.model.visible) return; this.currentHealth = Math.max(0, this.currentHealth - damage); if (this.currentHealth <= 0) { this.die(); } } die() { if (this.isDead) return; // Start death sequence with animations and effects this.startDeathSequence(); // Set respawn timer if enabled in settings if (APP_SETTINGS.controls.enableEnemyRespawn) { setTimeout(() => { this.respawn(); }, 1000); // 1 second respawn 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(); } const enemyGun = window.GunManager?.getGunForHolder(this.getHolderId()); if (enemyGun) { enemyGun.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(); } const enemyGun = window.GunManager?.getGunForHolder(this.getHolderId()); if (enemyGun) { enemyGun.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; return; } const enemyPosition = this.getPosition(); enemyPosition.y += this.getRaycastOffset(); // Use the same offset as for shooting const direction = new THREE.Vector3() .subVectors(playerPosition, enemyPosition) .normalize(); this.visionRay.update(enemyPosition, direction); // Get obstacles and walls from tilemap const obstacles = window.GameWorld.tilemap.getObstacles(); const walls = window.GameWorld.tilemap.getWalls(); // Check for intersections with 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) { this.canSeePlayer = false; return; } } } } // Check for intersections with 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) { this.canSeePlayer = false; return; } } } } // If we haven't returned by now, there are no obstacles between enemy and player this.canSeePlayer = true; } } class GunManager { constructor(params) { this.holderTypes = ['player', 'enemy']; if (!params) { throw new Error('GunManager: params object is required'); } this.loadoutTypes = new Set(); const required = ['THREE', 'CANNON', 'scene', 'camera', 'settings', 'Gun']; for (const prop of required) { if (!params[prop]) { throw new Error(`GunManager: ${prop} is required`); } } this.THREE = params.THREE; this.CANNON = params.CANNON; this.Gun = params.Gun; this.scene = params.scene; this.camera = params.camera; this.settings = params.settings; this.settings.guns = params.gunConfigs this.holders = new Map(); this.holderGuns = new Map(); this.isInitialized = false; this.HolderData = class { constructor(holder, loadoutType, holderType) { this.holder = holder; this.loadoutType = loadoutType; this.holderType = holderType; this.currentGun = null; this.inventory = new Map(); // Maps gun type to Gun instance this.primaryGun = null; this.secondaryGun = null; } }; this.loadingState = { inProgress: false, currentGunType: null, error: null }; } async initialize() { if (this.isInitialized) { return; } try { if (!this.settings.guns || Object.keys(this.settings.guns).length === 0) { throw new Error('GunManager: No gun settings found in settings object'); } this.isInitialized = true; } catch (error) { throw error; } } async initializeHolders() { const holders = Array.from(this.holders.entries()); for (const [holderName, holderData] of holders) { await this.preloadHolderGuns(holderName); const loadout = APP_SETTINGS.loadouts[holderData.loadoutType]; if (loadout?.defaultWeapon) { await this.setCurrentGun(holderName, loadout.defaultWeapon); } } } validateGunType(gunType) { if (!this.settings.guns?.[gunType]) { throw new Error(`GunManager: Invalid gun type: ${gunType}`); } if (!window.ModelLoader) { throw new Error('GunManager: ModelLoader not available'); } } async loadGun(gunType) { try { this.validateGunType(gunType); this.loadingState = { inProgress: true, currentGunType: gunType, error: null }; const gunSettings = this.settings.guns[gunType]; const model = await window.ModelLoader.loadModel(gunSettings.model); const gun = new this.Gun(this.scene, this.camera, model, gunSettings); return gun; } catch (error) { this.loadingState.error = error; throw error; } finally { this.loadingState.inProgress = false; } } assignHolder(holderName, holder, loadoutType) { if (!loadoutType) { throw new Error('GunManager: loadoutType is required when assigning a holder'); } if (!this.settings.loadouts[loadoutType]) { throw new Error(`GunManager: Invalid loadout type: ${loadoutType}`); } // Get holder type using the getter method const holderType = holder.getHolderType?.(); if (!holderType) { throw new Error('GunManager: Holder must implement getHolderType() method'); } if (!this.holderTypes.includes(holderType)) { throw new Error(`GunManager: Invalid holder type: ${holderType}`); } this.loadoutTypes.add(loadoutType); if (!this.holders.has(holderName)) { const holderData = new this.HolderData(holder, loadoutType, holderType); this.holders.set(holderName, holderData); } return this.holders.get(holderName); } getHolderData(holderName) { return this.holders.get(holderName); } setCurrentGun(holderName, gunType) { const holderData = this.getHolderData(holderName); if (!holderData) return false; const gun = holderData.inventory.get(gunType); if (!gun) return false; // Hide current gun if exists if (holderData.currentGun) { holderData.currentGun.hide(); } holderData.currentGun = gun; console.log(`[GunManager] Setting current gun for holder ${holderName}:`, { gunType, holderType: holderData.holderType, gunVisible: gun.model?.visible }); gun.show(); console.log(`[GunManager] Setting current gun for holder ${holderName}:`, { gunType, holderType: holderData.holderType, gunVisible: gun.model?.visible }); // Update holder's gun controller if (holderData.holder.gunController) { holderData.holder.gunController.setGun(gun); } console.log(`[GunManager] Setting current gun for holder ${holderName}:`, { gunType, holderType: holderData.holderType, gunVisible: gun.model?.visible }); return true; } getCurrentGun(holderName) { const holderData = this.getHolderData(holderName); return holderData ? holderData.currentGun : null; } getGunFromInventory(holderName, gunType) { const holderData = this.getHolderData(holderName); return holderData ? holderData.inventory.get(gunType) : null; } addGunToInventory(holderName, gunType, gun) { const holderData = this.getHolderData(holderName); if (!holderData) return false; holderData.inventory.set(gunType, gun); return true; } removeGunFromInventory(holderName, gunType) { const holderData = this.getHolderData(holderName); console.log(`[GunManager] Attempting to remove gun ${gunType} from holder ${holderName}`); if (!holderData) return false; const gun = holderData.inventory.get(gunType); if (!gun) return false; if (holderData.currentGun === gun) { holderData.currentGun = null; } return holderData.inventory.delete(gunType); } getInventory(holderName) { const holderData = this.getHolderData(holderName); return holderData ? holderData.inventory : null; } async preloadHolderGuns(holderName) { const holderData = this.getHolderData(holderName); if (!holderData) { throw new Error(`Holder ${holderName} not registered`); } const loadoutType = holderData.loadoutType; if (!this.settings.loadouts[loadoutType]) { throw new Error(`GunManager: No loadout found for type: ${loadoutType}`); } const loadout = this.settings.loadouts[loadoutType]; const gunsToLoad = [loadout.primary, loadout.secondary].filter(Boolean); for (const gunType of gunsToLoad) { try { if (holderData.inventory.has(gunType)) { continue; } const gun = await this.loadGun(gunType); gun.hide(); gun.setupForHolder(holderName, this.settings.guns[gunType]); this.addGunToInventory(holderName, gunType, gun); if (gunType === loadout.primary) { holderData.primaryGun = gun; } else if (gunType === loadout.secondary) { holderData.secondaryGun = gun; } } catch (error) { throw error; } } return holderData.inventory; } async assignGunToHolder(holderName, gunType) { if (!this.isInitialized) { throw new Error('GunManager not initialized'); } const holderData = this.getHolderData(holderName); if (!holderData) { throw new Error(`Holder ${holderName} not found`); } try { const gun = this.getGunFromInventory(holderName, gunType); if (!gun) { throw new Error(`Gun ${gunType} not in inventory for holder ${holderName}`); } if (this.setCurrentGun(holderName, gunType)) { return gun; } else { throw new Error(`Failed to set current gun ${gunType} for holder ${holderName}`); } } catch (error) { throw error; } } getGunForHolder(holderName) { return this.getCurrentGun(holderName); } update(deltaTime) { for (const [holderName, holderData] of this.holders) { if (holderData.currentGun) { holderData.currentGun.update(deltaTime); } } } } class Player { constructor(camera) { this.holderType = 'player'; this.getHolderType = () => this.holderType; this.maxHealth = 500; 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.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 } } }; 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) { this.reset(); return; } // Existing reload logic for guns when alive if (this.gunController) { this.gunController.reload(); } break; case 'KeyV': if (window.CameraControl) { window.CameraControl.toggleCameraMode(); } break; case 'KeyH': this.toggleHitboxVisibility(); 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 ); // Create invisible material for the actual hitbox 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; } 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(); } } } 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 EnemyManager { constructor({ THREE, FBXLoader, LoadingManager, scene, settings }) { this.THREE = THREE; this.FBXLoader = FBXLoader; this.LoadingManager = LoadingManager; this.scene = scene; this.settings = settings; this.enemies = new Map(); // Store enemies with their IDs this.preloadedAssets = new Map(); // Store preloaded assets for each enemy this.enemyLoader = new EnemyLoader({ THREE: THREE, FBXLoader: FBXLoader, LoadingManager: LoadingManager }); } getEnemyConfig() { return { dimensions: { width: 4, height: 18, depth: 4 }, hitbox: { offset: { x: 0, y: 7, z: 0 } }, waitDuration: 2000, respawnCooldown: 3000, model: MODEL_ASSETS.XBOT, moveSpeed: 75, chaseSpeed: 45, rotationSpeed: 20.0, mass: 70, health: { max: 100, current: 100 }, physics: { linearDamping: 0.4, angularDamping: 0.99, fixedRotation: true, allowSleep: false }, mountPoints: { gun: { position: new this.THREE.Vector3(-0.5, 13.6, 5.5), rotation: new this.THREE.Vector3(0, Math.PI + Math.PI / 2, 0) } } }; } async preloadEnemyAssets() { try { const enemiesToSpawn = this.settings.controls.enemiesToSpawn || 1; const enemySettings = this.getEnemyConfig(); // Create a promise for each enemy's assets const preloadPromises = Array(enemiesToSpawn).fill().map(async (_, index) => { const assets = await this.enemyLoader.preloadEnemyAssets(enemySettings); this.preloadedAssets.set(`enemy_${index}`, assets); console.log(`[EnemyManager] Preloaded assets for enemy_${index}`); }); // Wait for all assets to be preloaded await Promise.all(preloadPromises); console.log(`[EnemyManager] Successfully preloaded assets for ${enemiesToSpawn} enemies`); } catch (error) { console.error('[EnemyManager] Failed to preload enemy assets:', error); throw error; } } createEnemies() { if (!window.GameWorld?.tilemap) { console.error('Cannot create enemies: tilemap not initialized'); return []; } const createdEnemies = []; const enemiesToSpawn = this.settings.controls.enemiesToSpawn || 1; for (let i = 0; i < enemiesToSpawn; i++) { try { const enemy = this.createSingleEnemy(); createdEnemies.push(enemy); } catch (error) { console.error(`Failed to create enemy ${i + 1}:`, error); } } return createdEnemies; } createSingleEnemy() { const enemyIndex = this.enemies.size; const enemyAssets = this.preloadedAssets.get(`enemy_${enemyIndex}`); if (!enemyAssets) { throw new Error(`Enemy assets not preloaded for enemy_${enemyIndex}`); } const spawnPositions = this.settings.tilemap.enemySpawns; const randomIndex = Math.floor(Math.random() * spawnPositions.length); const gridPosition = spawnPositions[randomIndex]; const worldXZ = window.GameWorld.tilemap.gridToWorldPosition(gridPosition.x, gridPosition.z); const spawnPosition = { x: worldXZ.x, y: this.settings.enemySpawns.spawnHeight, z: worldXZ.z }; const enemyConfig = this.getEnemyConfig(); const enemy = new Enemy(this.scene, { ...enemyConfig, position: spawnPosition, preloadedAssets: enemyAssets }); enemy.initializeWithPreloadedAssets(); this.enemies.set(enemy.id, enemy); console.log(`[Enemy ${enemy.id}] Created at position:`, enemy.getPosition()); return enemy; } removeEnemy(enemyId) { const enemy = this.enemies.get(enemyId); if (enemy) { if (enemy.model) { this.scene.remove(enemy.model); } if (enemy.physicsBody) { window.GameWorld.physicsWorld.remove(enemy.physicsBody); } this.enemies.delete(enemyId); } } getEnemy(enemyId) { return this.enemies.get(enemyId); } getAllEnemies() { return Array.from(this.enemies.values()); } update(deltaTime, playerPosition) { this.enemies.forEach(enemy => { if (enemy.isLoaded) { enemy.update(deltaTime, playerPosition); } }); } } class App { constructor() { this.createRenderDivs(); this.clock = new THREE.Clock(); this.initialLoadingComplete = false; 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() { await this.loadScripts(); window.LoadingManager = new THREE.LoadingManager(); this.setupLoadingManager(); window.ImageLoader = new ImageLoader({ LoadingManager: window.LoadingManager, IMAGE_ASSETS: IMAGE_ASSETS }); 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 }); window.GunConfigs = new GunConfigs({ THREE: THREE, MODEL_ASSETS: MODEL_ASSETS, SOUND_ASSETS: SOUND_ASSETS }); try { await window.AudioManager.loadSoundAssets(); } catch (error) { console.error('Failed to load audio assets:', 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, 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 }); window.Player = new Player(MainCamera); window.GunManager.assignHolder('player', window.Player, 'basic_player'); GameWorld.createTilemap(); try { await window.ImageLoader.loadAllImages(); window.HUD = new HUD({ uiContainer: window.uiDiv, AmmoDisplay: AmmoDisplay, Crosshair: Crosshair, GunLoadoutPanel: GunLoadoutPanel, GunHUDContainer: GunHUDContainer, 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); } // Preload enemy assets before creating enemies try { await window.EnemyManager.preloadEnemyAssets(); const enemies = window.EnemyManager.createEnemies(); console.log(`[Enemy Manager] Successfully spawned ${enemies.length} enemies (IDs: ${enemies.map(e => e.id).join(', ')})`); await window.GunManager.initializeHolders(); // 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(); } setupLoadingManager() { LoadingManager.onProgress = (url, itemsLoaded, itemsTotal) => { loadingScreen.innerHTML = `Loading...`; }; 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 enemies through the manager 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'; loadingScreen.innerHTML = 'Loading...'; 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); } } window.Game = new App(); Game.start();