import * as THREE from 'three'; import { setupScene } from 'sceneSetup'; import { setupRenderer } from 'rendererSetup'; // Removed duplicate imports import { createGround } from 'ground'; import { createPlayer, PLAYER_HEIGHT, PLAYER_WIDTH } from 'player'; // Import PLAYER_HEIGHT and PLAYER_WIDTH import { createRope } from 'rope'; // Updated import: Include createHasteEffect import { createLightningEffect, updateEffectAnimation, LIGHTNING_EFFECT_SIZE, createImpactEffect, createHasteEffect } from 'effectManager'; import { createHealthBarElement, updateHealthBarPosition, updateHealthBarValue } from 'healthBarManager'; // Import health bar functions import { createProjectile, updateProjectile, PROJECTILE_SIZE } from 'projectile'; // Import projectile functions and size import { loadSound, playSound, resumeAudioContext } from 'soundManager'; // Import sound loader, player, AND resume context function // --- Constants --- const PLAYER_MOVE_SPEED = 12; // Units per second (Reduced from 15) const PLAYER_JUMP_STRENGTH = 25; // Initial upward velocity const GRAVITY = -60; // Units per second squared const CLIMB_SPEED = 10; // Units per second when climbing const MELEE_RANGE = PLAYER_WIDTH * 1.0; // Tighter range (was 1.5) const BASIC_ATTACK_DAMAGE = 15; // Amount of damage for a basic hit const LIGHTNING_DAMAGE = 25; // Damage for the lightning strike const ENERGY_BLAST_DAMAGE = 20; // Damage for the energy blast projectile const LIGHTNING_COOLDOWN = 3.0; // Cooldown duration in seconds const ENERGY_BLAST_COOLDOWN = 1.5; // Cooldown duration for energy blast const HURT_DURATION = 0.4; // How long the hurt state/animation lasts (seconds) const FLASH_DURATION = 0.5; // How long the damage flash lasts (seconds) const LIGHTNING_MOVEMENT_LOCK_DURATION = 0.2; // Duration player movement is stopped (seconds) const DOWN_HOLD_THRESHOLD_MS = 250; // Time in ms to hold down to drop through (was 1000) const FLASH_COLOR = new THREE.Color(0x808080); // Dark Gray const PLAYER_BASE_COLOR = new THREE.Color(0xffffff); // White const OTHER_PLAYER_BASE_COLOR = new THREE.Color(0xff0000); // Red // --- Haste Skill Constants --- const HASTE_DURATION = 3.0; // seconds const HASTE_SPEED_MULTIPLIER = 1.5; // 50% increase const HASTE_JUMP_MULTIPLIER = 1.5; // 50% increase const HASTE_COOLDOWN = 10.0; // seconds (Increased to 10) export class Game { constructor(renderDiv, controlsState, updateSkillButtonUI) { // Accept controlsState and UI callback this.renderDiv = renderDiv; this.controlsState = controlsState; // Store the controls state this.updateSkillButtonUI = updateSkillButtonUI; // Store the UI update callback this.scene = new THREE.Scene(); this.renderer = setupRenderer(renderDiv); this.camera = this.setupCamera(); setupScene(this.scene, this.camera); // --- Load Background Texture --- const textureLoader = new THREE.TextureLoader(); const backgroundTextureUrl = 'https://play.rosebud.ai/assets/background_glacial_mountains_lightened.png?VRIC'; const backgroundTexture = textureLoader.load(backgroundTextureUrl); backgroundTexture.magFilter = THREE.NearestFilter; backgroundTexture.minFilter = THREE.NearestFilter; backgroundTexture.wrapS = THREE.RepeatWrapping; // Allow horizontal repeating backgroundTexture.wrapT = THREE.ClampToEdgeWrapping; // Clamp vertically // --- Add Background Plane --- const frustumHeight = 60; // Match camera's frustum size const backgroundHeight = frustumHeight; // Keep height based on frustum // Define segment width based on texture aspect ratio to avoid stretching one tile const textureAspectRatio = backgroundTexture.image ? backgroundTexture.image.width / backgroundTexture.image.height : 16/9; // Default if image not loaded yet const backgroundSegmentWidth = backgroundHeight * textureAspectRatio; // Width of one non-stretched texture repeat const totalBackgroundWidth = 300; // Same width as the ground platform for consistency const repeatX = totalBackgroundWidth / backgroundSegmentWidth; // Calculate repetitions backgroundTexture.repeat.set(repeatX, 1); // Set the repeat value on the texture const backgroundGeometry = new THREE.PlaneGeometry(totalBackgroundWidth, backgroundHeight); const backgroundMaterial = new THREE.MeshBasicMaterial({ map: backgroundTexture, depthTest: false, // Render behind everything else depthWrite: false // Don't interfere with depth buffer }); this.backgroundMesh = new THREE.Mesh(backgroundGeometry, backgroundMaterial); // Position behind other elements, centered with the initial camera view const verticalShift = 10; // Match vertical shift used elsewhere this.backgroundMesh.position.set(0, verticalShift, -10); // Place it behind player/platforms this.scene.add(this.backgroundMesh); // Add the new ground, passing the renderer this.ground = createGround(this.renderer); // Pass renderer instance this.scene.add(this.ground); // --- Create Upper Platform --- this.upperPlatform = createGround(this.renderer); const groundHeight = this.ground.geometry.parameters.height; // Re-use height calculation const playerHeightApprox = PLAYER_HEIGHT; // Use imported constant const verticalGap = playerHeightApprox * 3; // Gap between platforms // Note: Ground's position.y already includes the verticalShift from ground.js this.upperPlatform.position.y = this.ground.position.y + groundHeight + verticalGap; this.upperPlatform.position.z = this.ground.position.z; // Keep same Z depth this.scene.add(this.upperPlatform); // --- Create and Add Rope --- const groundTopY = this.ground.position.y + this.ground.geometry.parameters.height / 2; const upperPlatformBottomY = this.upperPlatform.position.y - this.upperPlatform.geometry.parameters.height / 2; const upperPlatformTopY = this.upperPlatform.position.y + this.upperPlatform.geometry.parameters.height / 2; // Calculate top Y const ropeXPosition = 0; // Place it at the center horizontally for now const ropeZPosition = this.ground.position.z; // Align with platforms const ropeBottomOffset = PLAYER_HEIGHT * 0.75; // Raise the bottom by 3/4 player height const adjustedStartY = groundTopY + ropeBottomOffset; // Calculate the new bottom Y // Ensure adjustedStartY doesn't exceed upperPlatform's *bottom* (still need a gap below) const finalStartY = Math.min(adjustedStartY, upperPlatformBottomY - 1); // Leave at least 1 unit gap below platform // Extend the rope slightly above the platform top const ropeTopExtension = PLAYER_HEIGHT * 0.6; // Extend by ~60% of player height const extendedEndY = upperPlatformTopY + ropeTopExtension; this.rope = createRope(finalStartY, extendedEndY, ropeXPosition, ropeZPosition); if (this.rope) { // Only add if creation was successful // Update the stored bottomY to reflect the visual adjustment // topY is handled inside createRope based on the arguments passed this.rope.userData.bottomY = finalStartY; this.scene.add(this.rope); } // --- Add the player --- this.player = createPlayer(); // Position player on top of the *lower* ground initially const groundY = this.ground.position.y; // const groundHeight = this.ground.geometry.parameters.height; // Already calculated const playerHeight = this.player.geometry.parameters.height; // Get height from player geometry this.player.position.y = groundY + groundHeight / 2 + playerHeight / 2; this.initialPlayerY = this.player.position.y; // Store initial Y relative to lower ground // Add initial player state for physics/movement this.player.userData.velocity = new THREE.Vector3(0, 0, 0); this.player.userData.isOnGround = true; this.player.userData.isClimbing = false; this.player.userData.maxHealth = 100; this.player.userData.health = 100; this.player.userData.isHurt = false; this.player.userData.hurtStartTime = 0; this.player.userData.isFlashing = false; // Track damage flash state this.player.userData.flashStartTime = 0; // Time when flash started this.player.userData.movementLockEndTime = 0; // Time until movement is allowed again // --- Haste State --- this.player.userData.isHasteActive = false; this.player.userData.hasteEndTime = 0; this.hasteEffect = null; // Property to hold the active haste effect mesh this.scene.add(this.player); // --- Create Second Player Object (Placeholder for Multiplayer) --- this.otherPlayer = createPlayer(); // Renamed from this.npc this.otherPlayer.position.set( this.player.position.x + PLAYER_WIDTH * 2, // Position to the right of the player this.initialPlayerY, // Same initial Y level this.player.position.z // Same depth ); // Tint the other player red (temporary visual distinction) if (this.otherPlayer.material) { // Ensure material exists and is unique if possible, or apply directly if (!this.otherPlayer.material.clonedFromOriginal) { // Avoid re-cloning if already done this.otherPlayer.material = this.otherPlayer.material.clone(); this.otherPlayer.material.clonedFromOriginal = true; // Mark as cloned } this.otherPlayer.material.color.setHex(0xff0000); // Set color to red } // Add initial other player state (mostly idle for now) this.otherPlayer.userData.velocity = new THREE.Vector3(0, 0, 0); this.otherPlayer.userData.isOnGround = true; this.otherPlayer.userData.isClimbing = false; this.otherPlayer.userData.currentAnimation = 'idle'; this.otherPlayer.userData.maxHealth = 100; this.otherPlayer.userData.health = this.otherPlayer.userData.maxHealth; this.otherPlayer.userData.isHurt = false; this.otherPlayer.userData.hurtStartTime = 0; this.otherPlayer.userData.isFlashing = false; // NEW: Track damage flash state this.otherPlayer.userData.flashStartTime = 0; // NEW: Time when flash started this.scene.add(this.otherPlayer); // --- Create Health Bars --- this.playerHealthBar = createHealthBarElement('player1'); // Use 'player1' ID this.otherPlayerHealthBar = createHealthBarElement('player2'); // Renamed, use 'player2' ID // --- End Create Health Bars --- this.clock = new THREE.Clock(); // Bind the animation loop to this instance this.animate = this.animate.bind(this); // Handle window resizing window.addEventListener('resize', this.onWindowResize.bind(this), false); this.onWindowResize(); // Initial setup // --- Active Effects Management --- this.activeEffects = []; // Array to store active effect meshes this.activeProjectiles = []; // Array to store active projectile meshes // Initial lightning spawn removed - will be triggered by attack // Initialize cooldowns on game start to avoid NaN issues if not set in main.js if (!this.controlsState.skillCooldowns.lightning) { this.controlsState.skillCooldowns.lightning = 0; } // Initialize energy blast cooldown too if (!this.controlsState.skillCooldowns.energyBlast) { this.controlsState.skillCooldowns.energyBlast = 0; } // Initialize haste cooldown too if (!this.controlsState.skillCooldowns.haste) { this.controlsState.skillCooldowns.haste = 0; } // --- Load Sounds --- loadSound('magicAttack', 'https://play.rosebud.ai/assets/703249__xkeril__magic-attack-small.wav?ZZ6r'); // Load background music (using the El Nath track from assets) loadSound('backgroundMusic', 'https://play.rosebud.ai/assets/[MapleStory BGM] El Nath_ Snowy Village.mp3?0cP4'); // Load haste activation sound loadSound('hasteActivate', 'https://play.rosebud.ai/assets/789596__13712885766__chimes-1-short.mp3?V4h9'); // Load basic attack sound loadSound('basicAttackWoosh', 'https://play.rosebud.ai/assets/9509__petenice__whoosh.wav?DcAK'); // Add other sound loading here later this.backgroundMusicSource = null; // Initialize background music source reference } setupCamera() { const aspect = this.renderDiv.clientWidth / this.renderDiv.clientHeight; const frustumSize = 45; // Reduced frustum size to zoom in (was 60) const camera = new THREE.OrthographicCamera( frustumSize * aspect / -2, frustumSize * aspect / 2, frustumSize / 2, frustumSize / -2, 1, 1000 ); // Position the camera to look from the side // Adjust camera Y to match the scene shift const verticalShift = 10; // Same value as in ground.js camera.position.set(0, verticalShift, 10); // Positioned along Z-axis, shifted up camera.lookAt(0, verticalShift, 0); // Look at the shifted center return camera; } onWindowResize() { const aspect = this.renderDiv.clientWidth / this.renderDiv.clientHeight; const frustumSize = 45; // Keep consistent with setupCamera (was 60) this.camera.left = frustumSize * aspect / -2; this.camera.right = frustumSize * aspect / 2; this.camera.top = frustumSize / 2; this.camera.bottom = frustumSize / -2; this.camera.updateProjectionMatrix(); this.renderer.setSize(this.renderDiv.clientWidth, this.renderDiv.clientHeight); // Background plane width is now fixed, only update height potentially if needed // For now, we keep the background height tied to the initial frustum size, // so no background resize logic needed here unless the vertical size should change. // If vertical resizing is needed later, the texture repeat logic would also need adjustment. } // Method to be called after first user interaction startBackgroundMusic() { console.log("[Game.startBackgroundMusic] Entering function..."); // resumeAudioContext(); // <<< REMOVED - Context is now resumed explicitly in main.js on first interaction // Start playing background music (looped, moderate volume) console.log("[Game.startBackgroundMusic] About to call playSound('backgroundMusic', 0.3, true)..."); // Store the returned source node this.backgroundMusicSource = playSound('backgroundMusic', 0.3, true); if (this.backgroundMusicSource) { console.log("[Game.startBackgroundMusic] playSound returned an audio source node. Music should be attempting to play."); // No further listeners needed here for AudioBufferSourceNode } else { console.warn("[Game.startBackgroundMusic] playSound did NOT return an audio source node. Check soundManager.js."); } console.log("[Game.startBackgroundMusic] Exiting function."); } start() { // Music playback moved to startBackgroundMusic() this.animate(); } animate() { this.animationFrameId = requestAnimationFrame(this.animate); // Store the frame ID const deltaTime = Math.min(this.clock.getDelta(), 0.05); // Clamp delta time const currentTime = this.clock.elapsedTime; // Get current time once per frame // Update game objects this.updatePlayerMovement(deltaTime, currentTime); // Pass currentTime here this.checkRopeInteraction(currentTime); // Pass currentTime here too this.updateCharacterAnimation(this.player, deltaTime, currentTime); // Pass currentTime this.updateCharacterAnimation(this.otherPlayer, deltaTime, currentTime); // Pass currentTime // Apply player velocity (partially handled in updatePlayerMovement for climbing) if (!this.player.userData.isClimbing) { this.player.position.addScaledVector(this.player.userData.velocity, deltaTime); } // Basic ground collision (only if not climbing) if (!this.player.userData.isClimbing) { this.checkGroundCollision(deltaTime); // Pass deltaTime } // --- Camera Follow --- const targetCameraX = this.player.position.x; const targetCameraY = this.player.position.y; // Camera should also follow player Y // Smoothly interpolate the camera's position const lerpFactor = 0.05; // Adjust this value for faster/slower follow this.camera.position.x = THREE.MathUtils.lerp(this.camera.position.x, targetCameraX, lerpFactor); this.camera.position.y = THREE.MathUtils.lerp(this.camera.position.y, targetCameraY, lerpFactor); this.camera.lookAt(this.camera.position.x, this.camera.position.y, 0); // --- Update Active Effects --- // currentTime defined earlier in the frame for (let i = this.activeEffects.length - 1; i >= 0; i--) { const effect = this.activeEffects[i]; const isActive = updateEffectAnimation(effect, currentTime); // --- Lightning Damage Check --- // Check if the effect is lightning, still active, hasn't dealt damage yet, and the other player exists/is visible if (isActive && effect.userData.type === 'lightning' && !effect.userData.damageApplied && this.otherPlayer && this.otherPlayer.visible) { // --- Tighter 2D AABB Collision Check (Ignoring Z) --- // Use even smaller multipliers for a much tighter hitbox const playerHitboxWidth = PLAYER_WIDTH * 0.4; // Reduced from 0.6 const playerHitboxHeight = PLAYER_HEIGHT * 0.6; // Reduced from 0.8 const otherPlayerHalfWidth = playerHitboxWidth / 2; const otherPlayerHalfHeight = playerHitboxHeight / 2; const otherPlayerMinX = this.otherPlayer.position.x - otherPlayerHalfWidth; const otherPlayerMaxX = this.otherPlayer.position.x + otherPlayerHalfWidth; const otherPlayerMinY = this.otherPlayer.position.y - otherPlayerHalfHeight; const otherPlayerMaxY = this.otherPlayer.position.y + otherPlayerHalfHeight; // Further reduce effect hitbox size const effectHitboxSize = LIGHTNING_EFFECT_SIZE * 0.3; // Reduced from 0.5 const effectHalfSize = effectHitboxSize / 2; const effectMinX = effect.position.x - effectHalfSize; const effectMaxX = effect.position.x + effectHalfSize; const effectMinY = effect.position.y - effectHalfSize; const effectMaxY = effect.position.y + effectHalfSize; // Check for overlap in X and Y axes using the tighter boxes const overlapsX = effectMaxX > otherPlayerMinX && effectMinX < otherPlayerMaxX; const overlapsY = effectMaxY > otherPlayerMinY && effectMinY < otherPlayerMaxY; if (overlapsX && overlapsY) { this.applyDamage(this.otherPlayer, LIGHTNING_DAMAGE); // Apply damage effect.userData.damageApplied = true; // Mark damage as applied // Player death logic removed - handled within applyDamage // console.log("Lightning Hit Player 2!"); // Log moved to applyDamage } // --- End 2D Collision Check --- } // --- End Lightning Damage Check --- if (!isActive) { this.scene.remove(effect); this.activeEffects.splice(i, 1); // Dispose geometry/material if needed, but basic for now } } // Reset single-frame states this.controlsState.jump = false; this.controlsState.attack = false; this.controlsState.utility = false; // Reset utility button state this.controlsState.mobility = false; // Reset mobility button state // --- Update Projectiles --- this.updateProjectiles(deltaTime); // New function call // --- Update Haste Effect Position --- if (this.hasteEffect && this.hasteEffect.userData.isAttachedToPlayer) { this.hasteEffect.position.copy(this.player.position); // Follow player this.hasteEffect.position.z = this.player.position.z - 0.1; // Keep slightly behind } // --- Update Skill Cooldown UI --- const nowSeconds = performance.now() / 1000; for (const skillId in this.controlsState.skillCooldowns) { const cooldownEndTime = this.controlsState.skillCooldowns[skillId] || 0; const remainingTime = Math.max(0, cooldownEndTime - nowSeconds); // Determine which button UI needs updating based on the skill ID if (this.updateSkillButtonUI) { // Check if the callback object exists if (skillId === this.controlsState.equippedSkill && this.updateSkillButtonUI.damage) { this.updateSkillButtonUI.damage(skillId, remainingTime); } else if (skillId === this.controlsState.equippedUtilitySkill && this.updateSkillButtonUI.utility) { this.updateSkillButtonUI.utility(skillId, remainingTime); } else if (skillId === this.controlsState.equippedMobilitySkill && this.updateSkillButtonUI.mobility) { this.updateSkillButtonUI.mobility(skillId, remainingTime); } // Note: If a skill is on cooldown but not currently equipped to a button, // its timer display won't update on that button until it's re-equipped. // handleSkillSelect in main.js sets the initial state correctly upon equipping. } } // Damage flashing updates removed // --- Update Health Bar Positions and Values --- if (this.playerHealthBar && this.player.visible) { updateHealthBarPosition(this.playerHealthBar, this.player, this.camera, this.renderer); updateHealthBarValue(this.playerHealthBar, this.player.userData.health, this.player.userData.maxHealth); } if (this.otherPlayerHealthBar && this.otherPlayer.visible) { // Use otherPlayer variables updateHealthBarPosition(this.otherPlayerHealthBar, this.otherPlayer, this.camera, this.renderer); updateHealthBarValue(this.otherPlayerHealthBar, this.otherPlayer.userData.health, this.otherPlayer.userData.maxHealth); } // --- Update Status Icons --- this.updateStatusIcons(); // Add this call // Render the scene this.renderer.render(this.scene, this.camera); } updatePlayerMovement(deltaTime, currentTime) { // Added currentTime const velocity = this.player.userData.velocity; const isOnGround = this.player.userData.isOnGround; const isClimbing = this.player.userData.isClimbing; const movementLockEndTime = this.player.userData.movementLockEndTime || 0; // Get lock time const isHasteActive = this.player.userData.isHasteActive; // Get haste state const hasteEndTime = this.player.userData.hasteEndTime || 0; // Get haste end time // Reset velocities based on state velocity.x = 0; if (!isClimbing) { // Apply gravity only when not climbing velocity.y = isOnGround ? Math.max(0, velocity.y) : velocity.y + GRAVITY * deltaTime; } else { velocity.y = 0; // Climbing controls vertical movement directly, start at 0 } // --- Haste Activation --- const nowSeconds = performance.now() / 1000; if (this.controlsState.mobility && // Mobility button pressed this frame this.controlsState.equippedMobilitySkill === 'haste' && // Haste is equipped !isHasteActive && // Haste is not already active nowSeconds >= (this.controlsState.skillCooldowns.haste || 0)) // Cooldown is ready { console.log("Activating Haste!"); this.player.userData.isHasteActive = true; this.player.userData.hasteEndTime = currentTime + HASTE_DURATION; this.controlsState.skillCooldowns.haste = nowSeconds + HASTE_COOLDOWN; // Trigger UI update for cooldown if (this.updateSkillButtonUI && this.updateSkillButtonUI.mobility) { this.updateSkillButtonUI.mobility('haste', HASTE_COOLDOWN); } // --- Add Haste Visual Effect --- if (!this.hasteEffect) { // Only create if it doesn't exist this.hasteEffect = createHasteEffect(this.player.position, currentTime); this.scene.add(this.hasteEffect); this.activeEffects.push(this.hasteEffect); // Add to active effects for animation updates console.log("Haste visual effect created and added."); } // Play haste activation sound playSound('hasteActivate', 0.6); // Play chime sound at 60% volume // --- End Add Haste Visual Effect --- } // --- Check Haste Duration --- if (isHasteActive && currentTime >= hasteEndTime) { console.log("Haste ended."); this.player.userData.isHasteActive = false; // --- Remove Haste Visual Effect --- if (this.hasteEffect) { this.hasteEffect.userData.finished = true; // Mark for removal by updateEffectAnimation this.hasteEffect = null; // Clear the reference console.log("Haste visual effect marked for removal."); } // --- End Remove Haste Visual Effect --- } // Update local isHasteActive for logic below after potential deactivation const currentHasteActive = this.player.userData.isHasteActive; if (isClimbing) { // --- Climbing Movement --- // Ensure player stays centered on the rope horizontally this.player.position.x = this.rope.position.x; // Keep snapped // Allow upward movement if joystick is up if (this.controlsState.joystickUp) { // Removed jumpHeld check velocity.y = CLIMB_SPEED; } else if (this.controlsState.down) { // Check for down press velocity.y = -CLIMB_SPEED; // Move downwards } else { velocity.y = 0; // Stop vertical movement if neither up nor down is held } // Apply vertical movement and clamp position to rope limits directly // Player's center can now reach the very top edge of the rope geometry const ropeTop = this.rope.userData.topY; const ropeBottom = this.rope.userData.bottomY + PLAYER_HEIGHT / 2; // Allow center to reach adjusted bottom edge const targetY = this.player.position.y + velocity.y * deltaTime; // Apply climbing movement and clamp to the full rope height. // The player will now stop at the top unless they jump or move off. this.player.position.y = Math.max(ropeBottom, Math.min(ropeTop, targetY)); // Reset vertical velocity after clamping velocity.y = 0; // Explicitly ensure no horizontal movement while climbing if (this.player.userData.isClimbing) { velocity.x = 0; this.player.position.x = this.rope.position.x; // Re-snap X if still climbing } } else { // --- Ground/Air Movement --- // Reset horizontal velocity *before* checking inputs for this frame velocity.x = 0; // Check if movement is currently locked const isMovementLocked = currentTime < movementLockEndTime; // Determine current move speed (apply reduction if attacking) const isBasicAttacking = this.player.userData.spriteState.isAttacking && this.controlsState.equippedSkill === null; // Check attack state and ensure it's basic attack // Apply Haste speed multiplier if active const baseMoveSpeed = isBasicAttacking ? PLAYER_MOVE_SPEED * 0.5 : PLAYER_MOVE_SPEED; const currentMoveSpeed = currentHasteActive ? baseMoveSpeed * HASTE_SPEED_MULTIPLIER : baseMoveSpeed; // Horizontal Movement using currentMoveSpeed (only if not locked) if (!isMovementLocked) { if (this.controlsState.left) { velocity.x -= currentMoveSpeed; } if (this.controlsState.right) { velocity.x += currentMoveSpeed; } } // Jumping // Prevent jumping while movement locked? Optional, but feels natural to allow jump even if horizontal is locked. if (this.controlsState.jump && isOnGround) { // Apply Haste jump multiplier if active const currentJumpStrength = currentHasteActive ? PLAYER_JUMP_STRENGTH * HASTE_JUMP_MULTIPLIER : PLAYER_JUMP_STRENGTH; velocity.y = currentJumpStrength; this.player.userData.isOnGround = false; // Player is now airborne // console.log("Jump initiated", velocity.y); } // --- Update Player Facing Direction Immediately based on Controls --- // This should happen *after* velocity is potentially set by controls. // It only changes direction if a directional key is actively pressed AND movement is not locked. if (!isMovementLocked) { // Check lock here too for direction change if (this.controlsState.left) { this.player.userData.spriteState.facingDirection = -1; // Face Left } else if (this.controlsState.right) { this.player.userData.spriteState.facingDirection = 1; // Face Right } } // If neither is pressed, direction remains unchanged from the last input. // --- End Direction Update --- } } checkRopeInteraction() { if (!this.rope) return; // No rope to interact with const playerBox = new THREE.Box3().setFromObject(this.player); // Slightly extend rope box vertically for easier grabbing? Optional. const ropeBox = new THREE.Box3().setFromObject(this.rope); const playerHalfWidth = this.player.geometry.parameters.width / 2; const ropeRadius = this.rope.geometry.parameters.radiusTop; // Assuming uniform radius // Reduced threshold: Require player center to be within half-width + rope radius (no extra leeway) const horizontalThreshold = playerHalfWidth + ropeRadius; const isHorizontallyAligned = Math.abs(this.player.position.x - this.rope.position.x) < horizontalThreshold; const isVerticallyAligned = playerBox.min.y < ropeBox.max.y && playerBox.max.y > ropeBox.min.y; const canInteract = isHorizontallyAligned && isVerticallyAligned; // Check if trying to climb up using ONLY joystick up const isTryingToClimbUp = canInteract && this.controlsState.joystickUp; // Trying to climb UP (Jump removed) // Ensure downward climb initiation uses the joystick state or down button const isTryingToClimbDown = canInteract && this.controlsState.down; // Using joystick/button 'down' state // --- Debugging Logs --- // Re-enabled these lines to see the state in the console when near the rope // Log only when horizontally aligned to reduce noise, but show vertical alignment status if (isHorizontallyAligned) { console.log(`H_Align: ${isHorizontallyAligned}, V_Align: ${isVerticallyAligned}, CanInteract: ${canInteract}, Jump: ${this.controlsState.jump}, JoystickUp: ${this.controlsState.joystickUp}, DownHeld: ${this.controlsState.down}, IsClimbing: ${this.player.userData.isClimbing}, TryingUp: ${isTryingToClimbUp}, TryingDown: ${isTryingToClimbDown}`); // Added Jump log } // --- End Debugging --- // Initiate climb if trying to go up OR down, not already climbing, AND NOT pressing left/right if ((isTryingToClimbUp || isTryingToClimbDown) && !this.player.userData.isClimbing && !(this.controlsState.left || this.controlsState.right)) { // --- Initiate Climb --- this.player.userData.isClimbing = true; this.player.userData.isOnGround = false; // Not on ground when climbing this.player.userData.velocity.set(0, 0, 0); // Stop existing momentum this.player.position.x = this.rope.position.x; // Snap to rope center X console.log("Started Climbing at X:", this.player.position.x, "TryingUp:", isTryingToClimbUp, "TryingDown:", isTryingToClimbDown); } else if (this.player.userData.isClimbing) { // --- Check conditions to STOP climbing --- // PRIORITIZE JUMP DETACHMENT: if (this.controlsState.jump) { // Check for single-frame jump press this.player.userData.isClimbing = false; console.log("Stopped Climbing - Jumped Off Rope"); // Apply standard jump strength this.player.userData.velocity.y = PLAYER_JUMP_STRENGTH; // Apply standard horizontal impulse based on facing direction when jumping off this.player.userData.velocity.x = this.player.userData.spriteState.facingDirection * PLAYER_MOVE_SPEED * 0.6; // Consistent impulse return; // Handled jump detachment } // NEXT, PRIORITIZE DETACHMENT via left/right press: const wantsToDetach = this.controlsState.left || this.controlsState.right; if (wantsToDetach) { this.player.userData.isClimbing = false; console.log("Stopped Climbing - Detach via Left/Right Press"); // Apply horizontal impulse immediately this.player.userData.velocity.x = this.controlsState.left ? -PLAYER_MOVE_SPEED * 0.75 : PLAYER_MOVE_SPEED * 0.75; // Optional: Give a small upward boost to help clear platforms // this.player.userData.velocity.y = 5; return; // Handled detachment, exit function early for this frame } // --- Check other conditions to STOP climbing (if not detaching via left/right) --- // Use the same reduced threshold for checking if still aligned while climbing const stillHorizontallyAligned = Math.abs(this.player.position.x - this.rope.position.x) < horizontalThreshold; // Use updated reduced threshold const stillVerticallyAligned = playerBox.min.y < ropeBox.max.y && playerBox.max.y > ropeBox.min.y; const stillCanInteract = stillHorizontallyAligned && stillVerticallyAligned; // Stop climbing if player is no longer aligned with the rope if (!stillCanInteract) { this.player.userData.isClimbing = false; console.log("Stopped Climbing - Lost Rope Alignment"); // No sideways boost needed here, just fall naturally } } } checkGroundCollision(deltaTime) { const playerHeight = this.player.geometry.parameters.height; const velocity = this.player.userData.velocity; // Get velocity // Calculate previous bottom position (approximate) const previousPlayerBottom = (this.player.position.y - playerHeight / 2) - (velocity.y * deltaTime); // Current bottom position const playerBottom = this.player.position.y - playerHeight / 2; // Platform Y coordinates const groundTopY = this.ground.position.y + this.ground.geometry.parameters.height / 2; const upperPlatformBottomY = this.upperPlatform.position.y - this.upperPlatform.geometry.parameters.height / 2; const upperPlatformTopY = this.upperPlatform.position.y + this.upperPlatform.geometry.parameters.height / 2; let landedOnGround = false; // --- Down-Jump Check --- // Check if holding down long enough *while* on the upper platform const now = performance.now(); const isHoldingDownLongEnough = this.controlsState.down && this.controlsState.downHoldStartTime > 0 && (now - this.controlsState.downHoldStartTime >= DOWN_HOLD_THRESHOLD_MS); let shouldIgnoreUpperPlatform = false; // Adjusted condition: Player bottom is at or slightly below top, but above bottom if (isHoldingDownLongEnough && playerBottom <= upperPlatformTopY + 0.1 && playerBottom > upperPlatformBottomY) { shouldIgnoreUpperPlatform = true; console.log("Down-Jump Triggered! Ignoring upper platform."); // Optionally add a small downward impulse to ensure separation // velocity.y -= 5; // Reset hold start time immediately after triggering to prevent continuous dropping - REMOVED this line // The timer is reset when 'down' is released in main.js event handlers. } // --- End Down-Jump Check --- // Check collision with lower ground's TOP SURFACE // Condition: Was above last frame, is at/below this frame, and moving downwards/stationary if (previousPlayerBottom >= groundTopY && playerBottom <= groundTopY && velocity.y <= 0) { this.player.position.y = groundTopY + playerHeight / 2; // Snap position precisely velocity.y = 0; // Stop vertical velocity landedOnGround = true; // console.log("Landed on lower ground"); // Optional debug } // Check collision with upper platform's TOP SURFACE (only if not ignoring it) // Condition: Was above last frame, is at/below this frame, is above bottom, moving downwards/stationary, AND not intentionally dropping through if (!shouldIgnoreUpperPlatform && previousPlayerBottom >= upperPlatformTopY && playerBottom <= upperPlatformTopY && playerBottom > upperPlatformBottomY && velocity.y <= 0) { velocity.y = 0; // Stop vertical velocity landedOnGround = true; // console.log("Landed on upper platform"); // Optional debug // Ensure player doesn't fall through if they landed exactly on the edge this.player.position.y = Math.max(this.player.position.y, upperPlatformTopY + playerHeight / 2); } this.player.userData.isOnGround = landedOnGround; // Explicitly set to false if no landing occurred this frame // This helps prevent the 'isOnGround' state sticking incorrectly if (!landedOnGround && this.player.userData.isOnGround && !this.player.userData.isClimbing) { this.player.userData.isOnGround = false; // console.log("Set isOnGround to false"); // Optional debug } } // Renamed function and added 'character' parameter, and currentTime updateCharacterAnimation(character, deltaTime, currentTime) { // Added currentTime // Use 'character' instead of 'this.player' const { animations, spriteState, currentAnimation, velocity, isClimbing, isOnGround, isHurt, hurtStartTime, isFlashing, flashStartTime } = character.userData; // Include flash states const material = character.material; if (!animations || !spriteState || !material) return; // Guard clause, include material check // --- Damage Flash Logic --- const baseColor = (character === this.player) ? PLAYER_BASE_COLOR : OTHER_PLAYER_BASE_COLOR; if (isFlashing) { if (currentTime - flashStartTime >= FLASH_DURATION) { // Flash duration ended character.userData.isFlashing = false; material.color.copy(baseColor); // Restore base color console.log("Flash ended, restoring color:", baseColor.getHexString()); } else { // Still flashing, ensure color is gray if (!material.color.equals(FLASH_COLOR)) { material.color.copy(FLASH_COLOR); // console.log("Applying flash color"); // Optional: Debug log } } } else { // Not flashing, ensure base color is set (if not already) if (!material.color.equals(baseColor)) { material.color.copy(baseColor); // console.log("Ensuring base color is set:", baseColor.getHexString()); // Optional: Debug log } } // --- End Damage Flash Logic --- // --- Hurt State Check --- // Check if the character is currently hurt and if the duration has passed if (isHurt && currentTime - hurtStartTime >= HURT_DURATION) { character.userData.isHurt = false; // Reset hurt state console.log("Hurt state ended for character"); // Optionally switch back to idle or appropriate animation if needed, // but the regular logic below should handle that now. } // --- End Hurt State Check --- // currentTime is now passed in // currentTime is now passed in let currentAnimData = animations[currentAnimation]; // Use let for potential update // --- Determine Target Animation and Direction --- let targetAnimationName = currentAnimation; // Start by assuming we continue current anim // --- Hurt Animation Override --- // If the character is hurt, force the hurt animation (if it exists) if (isHurt && animations.hurt) { targetAnimationName = 'hurt'; } // --- End Hurt Animation Override --- // (Continue with attack/movement checks below, hurt override takes precedence if active) // --- Attack Initiation Check (Player Only) --- // This block handles STARTING an attack else if (character === this.player && this.controlsState.attack && !spriteState.isAttacking && animations.attack1) { spriteState.isAttacking = true; targetAnimationName = 'attack1'; spriteState.currentFrame = 0; // Reset frame for new attack spriteState.lastFrameTime = currentTime; // Reset timer for new attack // --- Execute Action Based on Equipped Skill --- console.log(`[Attack Trigger] Equipped Skill: ${this.controlsState.equippedSkill}`); // <<< ADDED LOG switch (this.controlsState.equippedSkill) { case 'lightning': const nowSeconds = performance.now() / 1000; const cooldownEndTime = this.controlsState.skillCooldowns.lightning || 0; if (nowSeconds >= cooldownEndTime) { console.log("Using Lightning!"); // Set new cooldown end time this.controlsState.skillCooldowns.lightning = nowSeconds + LIGHTNING_COOLDOWN; // Spawn effect... // --- Stop Player Movement & Set Lock Timer --- character.userData.velocity.set(0, 0, 0); // Zero out current velocity character.userData.movementLockEndTime = currentTime + LIGHTNING_MOVEMENT_LOCK_DURATION; // Set lock end time // --- End Stop Player Movement --- const effectPosition = character.position.clone(); const horizontalOffset = PLAYER_WIDTH * 1.2 * spriteState.facingDirection; const verticalOffset = LIGHTNING_EFFECT_SIZE * 0.15; // Raise it by 15% of its height (a small amount) effectPosition.x += horizontalOffset; effectPosition.y = character.position.y + verticalOffset; // Add the small vertical offset const lightningEffect = createLightningEffect(effectPosition, this.clock.elapsedTime); lightningEffect.userData.damageApplied = false; this.scene.add(lightningEffect); this.activeEffects.push(lightningEffect); playSound('magicAttack', 0.7); // Play sound for lightning // Update UI... // Ensure the callback object and specific damage function exist if (this.updateSkillButtonUI && this.updateSkillButtonUI.damage) { this.updateSkillButtonUI.damage('lightning', LIGHTNING_COOLDOWN); // Call the specific damage UI update function } } else { console.log("Lightning on cooldown!"); // Attack animation plays, but no effect/cooldown update } break; case 'energyBlast': const nowBlastSeconds = performance.now() / 1000; const blastCooldownEndTime = this.controlsState.skillCooldowns.energyBlast || 0; if (nowBlastSeconds >= blastCooldownEndTime) { console.log("Using Energy Blast!"); // Set new cooldown this.controlsState.skillCooldowns.energyBlast = nowBlastSeconds + ENERGY_BLAST_COOLDOWN; // --- Spawn Projectile --- // Slightly offset the projectile's start position from the player's center const projectileSpawnOffset = PLAYER_WIDTH * 0.5 * spriteState.facingDirection; const projectileStartPosition = character.position.clone(); projectileStartPosition.x += projectileSpawnOffset; // Adjust Y slightly to align better with character center (optional) // projectileStartPosition.y -= PLAYER_HEIGHT * 0.1; const projectile = createProjectile(projectileStartPosition, spriteState.facingDirection); this.scene.add(projectile); this.activeProjectiles.push(projectile); // Add to tracking array console.log("Projectile spawned!"); // playSound('magicAttack', 0.6); // Removed sound for energy blast // --- End Spawn Projectile --- // Update UI... // Ensure the callback object and specific function exist if (this.updateSkillButtonUI && this.updateSkillButtonUI.damage) { this.updateSkillButtonUI.damage('energyBlast', ENERGY_BLAST_COOLDOWN); } } else { console.log("Energy Blast on cooldown!"); // Attack animation plays, but no effect/cooldown update } break; default: // Basic Attack console.log("[Attack Trigger] Reached default (Basic Attack) case."); // <<< ADDED LOG console.log("Using Basic Attack!"); spriteState.damageAppliedThisAttack = false; // Reset damage flag for basic attack console.log("[Attack Start] damageAppliedThisAttack reset to false"); console.log("[Attack Sound] Attempting to play basicAttackWoosh..."); // Debug log before playSound('basicAttackWoosh', 0.7); // Play whoosh sound at 70% volume console.log("[Attack Sound] ...basicAttackWoosh playSound called."); // Debug log after break; } // End of attack initiation block } // --- Ongoing Attack Check --- // If already attacking, ensure the animation stays 'attack1' // This overrides subsequent movement checks until the attack finishes in the frame update logic else if (spriteState.isAttacking && animations.attack1) { targetAnimationName = 'attack1'; } // --- Movement/Idle Checks (Only if not hurt and not attacking) --- else if (isClimbing) { // Check climbing state if (animations.climb) { targetAnimationName = 'climb'; } else { targetAnimationName = 'idle'; // Fallback } } else if (!isOnGround) { // Check airborne state if (animations.jump) { // If the current animation is not jump (or attack), switch to jump. if (currentAnimation !== 'jump' && currentAnimation !== 'attack1') { targetAnimationName = 'jump'; } else if (currentAnimation === 'jump') { // If already jumping, keep target as jump. Frame logic handles non-looping. targetAnimationName = 'jump'; } else { // If falling but not explicitly jumping (e.g., walked off edge), default to jump targetAnimationName = 'jump'; } } else { targetAnimationName = 'idle'; // Fallback } } else if (Math.abs(velocity.x) > 0.1) { // Check running state targetAnimationName = 'run'; } else { // Idle state (on ground, not moving, not attacking, not climbing, not hurt) targetAnimationName = 'idle'; } // Update facing direction based on horizontal movement, but only if NOT climbing. // Allow direction change even during attack/hurt. if (!isClimbing) { // --- Player-Specific Direction Update (REMOVED - Moved to updatePlayerMovement) --- // --- Non-Player Character Direction --- // Only apply velocity-based direction check if it's NOT the main player if (character !== this.player) { const directionThreshold = 0.01; // Use threshold for NPCs to avoid jitter if (velocity.x > directionThreshold) { spriteState.facingDirection = 1; // Right } else if (velocity.x < -directionThreshold) { spriteState.facingDirection = -1; // Left } // If velocity is near zero, NPC direction remains unchanged. } // --- End Direction Update --- } // --- Switch Animation if Necessary --- // Switch if the target animation name differs from the current one. // Don't reset frame/timer if switching *to* attack (attack logic already did it above). // --- Switch Animation if Necessary --- // Switch if the target animation name differs from the current one. // Always reset frame/timer when switching, except maybe special cases later. if (currentAnimation !== targetAnimationName) { const newAnimData = animations[targetAnimationName]; if (!newAnimData) { // Safety check console.warn(`Animation "${targetAnimationName}" not found! Defaulting to idle.`); targetAnimationName = 'idle'; // Fallback to idle if target is invalid if (currentAnimation === 'idle') return; // Already idle, do nothing more currentAnimData = animations['idle']; // Use idle data if (!currentAnimData) return; // Serious issue if idle is missing material.map = currentAnimData.texture; } else { // --- Immediately apply flip state to the NEW texture --- const newTexture = newAnimData.texture; const repeatX = (1 / newAnimData.framesX); // Use the authoritative facingDirection from the spriteState newTexture.repeat.x = repeatX * spriteState.facingDirection; if (spriteState.facingDirection === 1) { newTexture.offset.x = 0; // Offset for frame 0 (normal) } else { // Offset for frame 0 (flipped). Frame 0 offset is -(0) - repeatX = -repeatX newTexture.offset.x = -repeatX; } newTexture.needsUpdate = true; // Crucial: ensure the new texture's state is registered // --- End immediate flip apply --- currentAnimData = newAnimData; // Update currentAnimData for frame logic below material.map = newTexture; // Switch material to use the pre-configured new texture } character.userData.currentAnimation = targetAnimationName; // Update state spriteState.currentFrame = 0; // Reset frame spriteState.lastFrameTime = currentTime; // Reset timer } // --- Advance Frame for Current Animation --- // Use the potentially updated currentAnimData const texture = material.map; // This is now the new texture if switched // --- Pause Check for Climbing --- let shouldAdvanceFrame = true; // Only apply climbing pause logic to the actual player character if (character === this.player && isClimbing && character.userData.currentAnimation === 'climb') { // Pause climbing animation if not actively moving up or down if (!this.controlsState.jumpHeld && !this.controlsState.down) { shouldAdvanceFrame = false; // Optionally reset to frame 0 or hold current frame? Resetting looks better. spriteState.currentFrame = 0; } } // --- Advance Frame (if not paused) --- // --- Advance Frame (if not paused) --- // Removed duplicated/incomplete frame advancement block // Use the correct currentAnimData here if (shouldAdvanceFrame && currentTime - spriteState.lastFrameTime >= currentAnimData.frameDuration) { // (Moved block start up) spriteState.lastFrameTime = currentTime; const nextFrame = spriteState.currentFrame + 1; // Handle non-looping animations (Jump, Attack1) if (currentAnimData.loop === false && nextFrame >= currentAnimData.framesX) { // Stay on the last frame for non-looping animations spriteState.currentFrame = currentAnimData.framesX - 1; // If the attack animation just finished, reset the attacking state if (character.userData.currentAnimation === 'attack1') { spriteState.isAttacking = false; // Damage applied flag is reset at the start of the next attack } // Don't loop back to frame 0 for non-looping anims } else { // Loop for looping animations or continue non-looping ones if not finished spriteState.currentFrame = nextFrame % currentAnimData.framesX; } // --- Apply Melee Damage (during attack animation) --- if (character === this.player && character.userData.currentAnimation === 'attack1') { console.log(`[Damage Check] Attack Frame: ${spriteState.currentFrame}, DamageApplied: ${spriteState.damageAppliedThisAttack}`); // DEBUG LOG } // Check specifically if the *player* is attacking and hasn't dealt damage yet this swing if (character === this.player && character.userData.currentAnimation === 'attack1' && !spriteState.damageAppliedThisAttack && this.otherPlayer && this.otherPlayer.visible // Check if otherPlayer exists and is visible ) { const distanceX = this.otherPlayer.position.x - this.player.position.x; const distanceY = Math.abs(this.otherPlayer.position.y - this.player.position.y); const directionToTarget = Math.sign(distanceX); // Check horizontal distance, vertical proximity, and facing direction if (Math.abs(distanceX) < MELEE_RANGE && distanceY < PLAYER_HEIGHT * 0.8 && // Target needs to be roughly vertically aligned spriteState.facingDirection === directionToTarget) // Player must face the target { console.log(`[Damage Apply] Applying damage! Setting damageAppliedThisAttack = true. Frame: ${spriteState.currentFrame}`); // <-- ADDED DEBUG LOG this.applyDamage(this.otherPlayer, BASIC_ATTACK_DAMAGE); // Apply damage spriteState.damageAppliedThisAttack = true; // Mark damage as applied for this attack // Player death logic removed - handled within applyDamage now // console.log("Basic Attack Hit Player 2!"); // Log moved to applyDamage } // --- End Apply Melee Damage --- } // --- Update Texture Offset and Repeat (always needed, even if frame doesn't change) --- // This section needs to run even if paused or finished non-looping to display the correct frame // Player direction is now updated in updatePlayerMovement // This section now primarily updates the offset for frame changes, // as the repeat/flip should be set correctly on switch or from previous frame. const frameOffsetX = spriteState.currentFrame / currentAnimData.framesX; const repeatX = (1 / currentAnimData.framesX); // Still need this for offset calculation // Re-assert repeat.x in case it somehow got reverted (belt-and-suspenders) texture.repeat.x = repeatX * spriteState.facingDirection; if (spriteState.facingDirection === 1) { texture.offset.x = frameOffsetX; // Normal offset update for current frame } else { // Flipped offset update for current frame texture.offset.x = -frameOffsetX - repeatX; } // Ensure needsUpdate is always true if we potentially changed offset/repeat texture.needsUpdate = true; } // Closing brace for the 'if (shouldAdvanceFrame...)' block } applyDamage(targetCharacter, damageAmount) { if (!targetCharacter || !targetCharacter.visible || !targetCharacter.userData || typeof targetCharacter.userData.health !== 'number') { console.warn("Invalid target or health data for applyDamage."); return; // Don't apply damage if target is invalid } // Don't apply damage if already hurt or flashing (prevent overlapping effects) if (targetCharacter.userData.isHurt || targetCharacter.userData.isFlashing) { return; } targetCharacter.userData.health -= damageAmount; console.log(`Applied ${damageAmount} damage. Target health: ${targetCharacter.userData.health}`); // --- Trigger Hurt State & Damage Flash --- const now = this.clock.elapsedTime; // Get current time once targetCharacter.userData.isHurt = true; targetCharacter.userData.hurtStartTime = now; targetCharacter.userData.isFlashing = true; targetCharacter.userData.flashStartTime = now; console.log("Damage flash started"); // --- End Trigger Hurt State & Damage Flash --- // Update the corresponding health bar value let healthBarElement = null; if (targetCharacter === this.player) { healthBarElement = this.playerHealthBar; } else if (targetCharacter === this.otherPlayer) { healthBarElement = this.otherPlayerHealthBar; } if (healthBarElement) { updateHealthBarValue(healthBarElement, targetCharacter.userData.health, targetCharacter.userData.maxHealth); } // Check for death if (targetCharacter.userData.health <= 0) { targetCharacter.userData.health = 0; // Prevent negative health display targetCharacter.visible = false; // Hide the character mesh // Hide the health bar as well if (healthBarElement) { healthBarElement.classList.add('health-bar-hidden'); // Use the hidden class } console.log("Target defeated!"); // Potentially trigger other game events (respawn timer, etc.) later } } // --- Update Status Icons --- updateStatusIcons() { const statusContainer = document.getElementById('player1-status-icons'); console.log(`[updateStatusIcons] Trying to find container 'player1-status-icons'. Found: ${!!statusContainer}`); // Log finding container if (!statusContainer) { console.log("[updateStatusIcons] Container not found, exiting."); return; // Exit if container not found } const hasteIconId = 'status-icon-haste'; let hasteIcon = statusContainer.querySelector(`#${hasteIconId}`); // const isHasteCurrentlyActive = this.player.userData.isHasteActive; // Temporarily disabled for testing console.log(`[updateStatusIcons] (Test Mode) Icon Element Found: ${!!hasteIcon}`); // Log icon presence (test mode) // --- TEMPORARY TEST: Always try to add the icon --- if (!hasteIcon) { console.log("[updateStatusIcons] (Test Mode) Icon NOT found. Creating and appending icon."); // Log adding icon (test mode) hasteIcon = document.createElement('span'); hasteIcon.id = hasteIconId; hasteIcon.innerHTML = '👟'; // Haste icon // Optional: Add tooltip or class for styling hasteIcon.title = 'Haste Status (Testing)'; // Update title for test statusContainer.appendChild(hasteIcon); } else { console.log("[updateStatusIcons] (Test Mode) Icon already exists."); // Optional log (test mode) } // --- END TEMPORARY TEST --- /* Original Logic: if (isHasteCurrentlyActive) { // Haste is active, add icon if it doesn't exist if (!hasteIcon) { console.log("[updateStatusIcons] Haste active, icon NOT found. Creating and appending icon."); // Log adding icon hasteIcon = document.createElement('span'); hasteIcon.id = hasteIconId; hasteIcon.innerHTML = '👟'; // Haste icon hasteIcon.title = 'Haste Active'; statusContainer.appendChild(hasteIcon); } } else { // Haste is inactive, remove icon if it exists if (hasteIcon) { console.log("[updateStatusIcons] Haste inactive, icon found. Removing icon."); // Log removing icon statusContainer.removeChild(hasteIcon); } } */ // Add logic for other status icons here later } // Removed updateDamageFlash function updateProjectiles(deltaTime) { for (let i = this.activeProjectiles.length - 1; i >= 0; i--) { const projectile = this.activeProjectiles[i]; const isActive = updateProjectile(projectile, deltaTime); if (isActive) { // --- Projectile Collision Check --- if (this.otherPlayer && this.otherPlayer.visible && !this.otherPlayer.userData.isHurt && !this.otherPlayer.userData.isFlashing) { const projectileHitboxSize = PROJECTILE_SIZE * 0.6; // Adjust hitbox size const projectileHalfSize = projectileHitboxSize / 2; const projectileMinX = projectile.position.x - projectileHalfSize; const projectileMaxX = projectile.position.x + projectileHalfSize; const projectileMinY = projectile.position.y - projectileHalfSize; const projectileMaxY = projectile.position.y + projectileHalfSize; const playerHitboxWidth = PLAYER_WIDTH * 0.6; const playerHitboxHeight = PLAYER_HEIGHT * 0.8; const otherPlayerHalfWidth = playerHitboxWidth / 2; const otherPlayerHalfHeight = playerHitboxHeight / 2; const otherPlayerMinX = this.otherPlayer.position.x - otherPlayerHalfWidth; const otherPlayerMaxX = this.otherPlayer.position.x + otherPlayerHalfWidth; const otherPlayerMinY = this.otherPlayer.position.y - otherPlayerHalfHeight; const otherPlayerMaxY = this.otherPlayer.position.y + otherPlayerHalfHeight; const overlapsX = projectileMaxX > otherPlayerMinX && projectileMinX < otherPlayerMaxX; const overlapsY = projectileMaxY > otherPlayerMinY && projectileMinY < otherPlayerMaxY; if (overlapsX && overlapsY) { console.log("Projectile Hit!"); this.applyDamage(this.otherPlayer, ENERGY_BLAST_DAMAGE); // --- Create Impact Effect --- const impactPosition = projectile.position.clone(); // Use projectile's position const impactEffect = createImpactEffect(impactPosition, this.clock.elapsedTime); this.scene.add(impactEffect); this.activeEffects.push(impactEffect); // Add to active effects array // --- End Create Impact Effect --- // Remove projectile immediately on hit this.scene.remove(projectile); this.activeProjectiles.splice(i, 1); // Dispose geometry/material? Not critical now for basic planes. continue; // Skip to next projectile since this one is removed } } // --- End Projectile Collision Check --- } else { // Remove expired projectile this.scene.remove(projectile); this.activeProjectiles.splice(i, 1); // Dispose geometry/material? Not critical now. } } } // Removed resumeAudioContext method - handled by soundManager.js dispose() { console.log("Disposing game resources..."); // Stop the animation loop if (this.animationFrameId) { cancelAnimationFrame(this.animationFrameId); } window.removeEventListener('resize', this.onWindowResize.bind(this), false); // Remove health bar elements from DOM if (this.playerHealthBar && this.playerHealthBar.parentNode) { this.playerHealthBar.parentNode.removeChild(this.playerHealthBar); } if (this.otherPlayerHealthBar && this.otherPlayerHealthBar.parentNode) { // Use otherPlayerHealthBar this.otherPlayerHealthBar.parentNode.removeChild(this.otherPlayerHealthBar); } // Dispose active effects and projectiles [...this.activeEffects, ...this.activeProjectiles].forEach(effect => { this.scene.remove(effect); if (effect.geometry) effect.geometry.dispose(); if (effect.material) { if (effect.material.map) effect.material.map.dispose(); effect.material.dispose(); } }); this.activeEffects = []; this.activeProjectiles = []; // Dispose background if (this.backgroundMesh) { this.scene.remove(this.backgroundMesh); if (this.backgroundMesh.geometry) this.backgroundMesh.geometry.dispose(); if (this.backgroundMesh.material) { if (this.backgroundMesh.material.map) this.backgroundMesh.material.map.dispose(); this.backgroundMesh.material.dispose(); } } // Dispose player and otherPlayer [this.player, this.otherPlayer].forEach(char => { if (char) { this.scene.remove(char); if (char.geometry) char.geometry.dispose(); if (char.material) { // Dispose textures stored in userData.animations if (char.userData && char.userData.animations) { Object.values(char.userData.animations).forEach(animData => { if (animData.texture) animData.texture.dispose(); }); } // Dispose the main material map (if different) and the material itself if (char.material.map && (!char.userData || !char.userData.animations || !Object.values(char.userData.animations).some(a => a.texture === char.material.map))) { char.material.map.dispose(); } char.material.dispose(); } } }); // Dispose ground and platforms [this.ground, this.upperPlatform].forEach(platform => { if (platform) { this.scene.remove(platform); if (platform.geometry) platform.geometry.dispose(); if (platform.material) { // Ground material uses CanvasTexture which doesn't need explicit map disposal here platform.material.dispose(); } } }); // Dispose rope if (this.rope) { this.scene.remove(this.rope); if (this.rope.geometry) this.rope.geometry.dispose(); if (this.rope.material) { if (this.rope.material.map) this.rope.material.map.dispose(); // If rope had a texture this.rope.material.dispose(); } } // Dispose renderer and remove canvas if (this.renderer) { this.renderer.dispose(); if (this.renderer.domElement && this.renderer.domElement.parentNode) { this.renderer.domElement.parentNode.removeChild(this.renderer.domElement); } } // Stop background music if it's playing if (this.backgroundMusicSource) { try { this.backgroundMusicSource.stop(); console.log("Stopped background music source during disposal."); } catch (e) { console.warn("Could not stop background music source (might have already finished):", e); } this.backgroundMusicSource = null; // Clear reference } // Clear scene (optional, might help GC) // this.scene.clear(); // Be careful if objects are managed elsewhere } }