import * as THREE from 'three'; import { GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader.js'; import { EmberParticles } from 'Particles'; // Import the particle system import { HealthBar } from 'HealthBar'; // Import the HealthBar class import { Decoy } from 'Decoy'; // Import the Decoy class import { Block } from 'Block'; // Import the Block class import { PoisonStrike } from 'PoisonStrike'; // Import the PoisonStrike class const MOVE_SPEED = 5.0; const JUMP_VELOCITY = 8.0; const GRAVITY = -20.0; const MODEL_SCALE = 1.0; // Adjust if the model is too big or small const PLAYER_HEIGHT_OFFSET = 0.8; // Approximate height from model base to center for collision const HEALTH_BAR_Y_OFFSET = 3.0; // Nudged the health bar up a bit more // const INVINCIBILITY_DURATION = 0.5; // Seconds of invincibility after taking damage - REMOVED export class Player { // Make offset accessible via static property for external use (e.g., game collision) static PLAYER_HEIGHT_OFFSET = PLAYER_HEIGHT_OFFSET; isCloneBlinking = false; // Add property to track clone blinking state // Removed stealth state properties as clone blink no longer uses stealth // Add controls parameter to constructor constructor(scene, game, controls, isLocalPlayer = false, initialPosition = new THREE.Vector3(0, Player.PLAYER_HEIGHT_OFFSET, 0), modelUrl = null) { this.modelUrl = modelUrl; // Store the model URL this.scene = scene; this.game = game; this.controls = controls; // Store the controls reference this.isLocalPlayer = isLocalPlayer; // Flag to identify the locally controlled player this.mesh = new THREE.Group(); // Use a Group as the main object this.mesh.position.copy(initialPosition); // Use the provided initial position this.activeShroudEffect = null; // Track the shroud mesh created *by this player* this.shroudCenter = null; // Track the center position of the active shroud this.shroudRadius = 0; // Track the radius of the active shroud this.shroudTimeoutId = null; // Store the timeout ID for shroud removal this.isInShroud = false; // Track if currently stealthed this.originalMaterials = new Map(); // Store original material states for opacity changes scene.add(this.mesh); this.velocity = new THREE.Vector3(0, 0, 0); this.isOnGround = true; // Assume starting on ground this.attackCooldown = 0; this.ATTACK_COOLDOWN_TIME = 0.5; // Seconds between attacks this.ATTACK_RANGE = 1.8; // How far the attack reaches this.ATTACK_DAMAGE = 15; // How much damage the attack does this.SHURIKEN_DAMAGE = 20; // Damage for the shuriken projectile this.SHURIKEN_SPEED = 12.0; // Speed of the shuriken (Reduced) this.SHURIKEN_LIFESPAN = 2.0; // Seconds before shuriken disappears this.modelLoaded = false; // Flag to track model loading this.mixer = null; // Animation mixer this.animations = {}; // Store animation clips by name this.currentAction = null; // Currently playing animation action this.sword = null; // Reference to the sword mesh this.swordLight = null; // Reference to the sword's light this.emberParticles = null; // Reference to the particle system this.lastAttackAnimationName = null; // Track the name of the last played attack animation // Health (Now using 0-100 scale internally) this.maxHealth = 100; this.currentHealth = this.maxHealth; // Start at 100 this.healthBar = new HealthBar(game.container); // HealthBar still expects 0.0-1.0 this.statusEffects = []; // Array to store active status effects { type, duration, tickInterval, damagePerTick, timeRemaining, lastTickTime } // this.lastDamagedTime = -Infinity; // Initialize to allow taking damage immediately - REMOVED this.skillCooldown = 0; // Cooldown for skills like potion this.SKILL_COOLDOWN_TIME = 3.0; // Increased to 3 seconds cooldown for potion this.loadModel(); } loadModel() { const loader = new GLTFLoader(); loader.load( this.modelUrl || 'https://play.rosebud.ai/assets/Knight.glb?3VqC', (gltf) => { const model = gltf.scene; model.scale.setScalar(MODEL_SCALE); model.traverse((child) => { if (child.isMesh) { child.castShadow = true; child.receiveShadow = true; } }); // Add the loaded model to the player's group this.mesh.add(model); // Add the visual model to the group this.model = model; // Store reference to the model itself this.modelLoaded = true; console.log("Knight model loaded for player.", gltf.animations); this.findSwordMesh(); // Attempt to find the sword after loading // --- Animation Setup --- this.mixer = new THREE.AnimationMixer(model); gltf.animations.forEach((clip) => { // Assuming standard names like 'Idle', 'Run', 'Jump', 'Attack' // Adjust these names based on your actual GLB file this.animations[clip.name] = clip; console.log(`Stored animation: ${clip.name}`); }); // Start with Idle animation if available this.playAnimation('Idle'); // --- End Animation Setup --- }, undefined, // onProgress callback (optional) (error) => { console.error('An error occurred loading the Knight model:', error); // Fallback to a simple cube if loading fails? const fallbackGeo = new THREE.BoxGeometry(0.8, 1.6, 0.8); const fallbackMat = new THREE.MeshStandardMaterial({ color: 0xff00ff }); const fallbackMesh = new THREE.Mesh(fallbackGeo, fallbackMat); this.mesh.add(fallbackMesh); // Add fallback to the group this.modelLoaded = true; // Mark as loaded even with fallback } ); } findSwordMesh() { if (!this.model) return; let swordMesh = null; this.model.traverse((child) => { // Try finding by name first (common practice) // Adjust 'Sword', 'sword', 'Weapon', etc. based on actual model structure if (child.isMesh && (child.name.toLowerCase().includes('sword') || child.name.toLowerCase().includes('weapon'))) { swordMesh = child; return; // Found it, stop traversing this branch } // Add more specific checks if name isn't reliable (e.g., based on material) }); if (swordMesh) { console.log("Sword mesh found:", swordMesh.name, swordMesh); this.sword = swordMesh; // Store reference to the sword this.addSwordGlow(); // Add the light effect this.addEmberEffect(); // Add the particle effect } else { console.warn("Could not automatically find a sword mesh by name."); // Fallback: You might need to inspect the model structure manually // and use a more specific name or index if the above doesn't work. } } addSwordGlow() { if (!this.sword) return; // Create a point light for the glow const light = new THREE.PointLight(0xffa500, 2, 3); // Orange color, Intensity 2, Distance 3 light.castShadow = false; // No shadows needed for this effect light // Position the light further up the blade relative to the sword mesh's origin // The exact values might need tuning depending on the model's pivot point light.position.set(0, 0.6, 0); // Increased Y offset this.sword.add(light); // Attach the light to the sword mesh this.swordLight = light; // Store reference console.log("Added point light to sword:", this.sword.name); } addEmberEffect() { if (!this.sword) return; // Ensure scene is available (it should be via this.scene) if (!this.scene) { console.error("Scene is not available in Player class to add particles."); return; } // Create the particle system, parenting it to the sword this.emberParticles = new EmberParticles(this.sword, this.scene); // Offset the particle system's position along the blade if (this.emberParticles.particles) { this.emberParticles.particles.position.set(0, 0.6, 0); // Same offset as the light } console.log("Added ember particles effect to sword:", this.sword.name); } update(deltaTime, controlsState) { if (!this.modelLoaded) return; // Don't update until model and animations are ready // If player is dead, only update animation and position, skip controls if (this.isDead) { // Update animation mixer even when dead if (this.mixer) { this.mixer.update(deltaTime); } // Update health bar position this.updateHealthBarPosition(); return; // Skip the rest of the update method } // --- Status Effect Check (for speed modification) --- let currentMoveSpeed = MOVE_SPEED; // Start with default speed const slowEffect = this.statusEffects.find(effect => effect.type === 'slow'); if (slowEffect) { currentMoveSpeed *= slowEffect.speedMultiplier; // Apply slow // console.log(`Slow effect active. Speed: ${currentMoveSpeed.toFixed(2)}`); // Optional: Log slow effect } // --- End Status Effect Check --- // Update animation mixer if (this.mixer) { this.mixer.update(deltaTime); } // Update attack cooldown timer if (this.attackCooldown > 0) { this.attackCooldown -= deltaTime; } // Apply gravity if (!this.isOnGround) { this.velocity.y += GRAVITY * deltaTime; } // Reset platform collision flag each frame this.isOnPlatform = false; let moveDirection = new THREE.Vector3(0, 0, 0); // Initialize move direction let isMoving = false; let isAttacking = false; let isJumping = false; // Only process controls if this is the local player if (this.isLocalPlayer) { moveDirection.set(controlsState.joystick.x, 0, controlsState.joystick.y); if (moveDirection.length() > 1) { moveDirection.normalize(); } this.velocity.x = moveDirection.x * currentMoveSpeed; // Use potentially modified speed this.velocity.z = moveDirection.z * currentMoveSpeed; // Use potentially modified speed // Jumping isJumping = controlsState.jumpPressed && this.isOnGround; if (isJumping) { this.velocity.y = JUMP_VELOCITY; this.isOnGround = false; // Play the jump animation - non-looping this.playAnimation('Jump_Full_Short', false); } // Attack isAttacking = controlsState.attackPressed && this.isOnGround; if (isAttacking) { this.performAttack(); // Call the renamed method (cooldown check moved inside the method) } // Defend / Use Skill (check skill cooldown) const isUsingSkill = controlsState.defendPressed && this.isOnGround && this.skillCooldown <= 0; if (isUsingSkill && this.controls && this.controls.equippedDefenseSkillId) { this.skillCooldown = this.SKILL_COOLDOWN_TIME; // Apply cooldown this.useDefenseSkill(this.controls.equippedDefenseSkillId); } } else { // Non-local player logic (e.g., apply networked state) - For now, just damp velocity this.velocity.x *= 0.9; // Simple damping this.velocity.z *= 0.9; } // Apply velocity to position (common for both local and remote) this.mesh.position.x += this.velocity.x * deltaTime; this.mesh.position.y += this.velocity.y * deltaTime; this.mesh.position.z += this.velocity.z * deltaTime; // Ground collision detection - Use the height offset const groundY = PLAYER_HEIGHT_OFFSET; if (this.mesh.position.y <= groundY && !this.isOnPlatform) { this.mesh.position.y = groundY; this.velocity.y = 0; this.isOnGround = true; } else if (!this.isOnPlatform && this.mesh.position.y > groundY) { this.isOnGround = false; } // Make the player model face the direction it's moving (only apply if actually moving) isMoving = moveDirection.lengthSq() > 0.01; // Recalculate based on processed moveDirection if (isMoving) { const angle = Math.atan2(moveDirection.x, moveDirection.z); const targetQuaternion = new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(0, 1, 0), angle); // Apply rotation instantly or smoothly this.mesh.quaternion.slerp(targetQuaternion, 15 * deltaTime); // Smoother rotation } // --- Animation Logic --- // Note: Attack animation is triggered in performAttack and its 'finished' listener handles returning to Idle/Run. // The main loop should respect the currently playing action if it's the attack. // We only switch to Idle/Run if the *current* action ISN'T the attack and movement dictates it. // const attackAnimName = '1H_Melee_Attack_Slice_Horizontal'; // No longer hardcoded here const jumpAnimName = 'Jump_Full_Short'; const interactAnimName = 'Interact'; const cheerAnimName = 'Cheer'; // Define Cheer animation name const cloneBlinkAnimName = 'Dodge_Right'; // Define clone blink animation name const isPlayingAttack = this.currentAction && this.lastAttackAnimationName && this.currentAction.getClip().name === this.lastAttackAnimationName && this.currentAction.isRunning(); const isPlayingJump = this.currentAction && this.currentAction.getClip().name === jumpAnimName && this.currentAction.isRunning(); const isPlayingInteract = this.currentAction && this.currentAction.getClip().name === interactAnimName && this.currentAction.isRunning(); const isPlayingCheer = this.currentAction && this.currentAction.getClip().name === cheerAnimName && this.currentAction.isRunning(); // Check if Cheer is playing const isPlayingCloneBlink = this.isCloneBlinking || (this.currentAction && this.currentAction.getClip().name === cloneBlinkAnimName && this.currentAction.isRunning()); // Animation state machine logic if (isPlayingAttack) { // Attack animation has priority } else if (isPlayingCloneBlink) { // Clone Blink animation has priority } else if (isPlayingJump && !this.isOnGround) { // Jump animation has priority while airborne } else if (isPlayingInteract) { // Interact animation has priority while it's running if (isPlayingInteract) { // No longer slowing movement *during* the animation // Update velocity based on the *intended* move direction and normal speed this.velocity.x = moveDirection.x * currentMoveSpeed; // Use normal speed unless slowed by status effect this.velocity.z = moveDirection.z * currentMoveSpeed; // Still prevent jumping isJumping = false; // Update isMoving based on if there *was* intended movement before the slow isMoving = moveDirection.lengthSq() > 0.01; } } else if (isPlayingCheer) { // Cheer animation has priority while it's running } else { // Not playing a priority non-looping animation. Determine Idle/Run/Fall. if (this.isOnGround) { if (isMoving) { this.playAnimation('Running_A'); // Loop running if moving on ground } else { this.playAnimation('Idle'); // Loop idle if standing still on ground } } else { // Player is in the air, but not playing the main jump animation loop (e.g., falling) // If a dedicated falling animation existed, we'd play it here. // We already checked above that Jump/Attack/Interact/Cheer isn't playing, so this handles falling. if (!isMoving) { this.playAnimation('Idle'); // Fallback to idle if falling straight down } else { // Optionally, could play 'Running_A' while falling and moving, but Idle might look better. this.playAnimation('Idle'); } } } // --- End Animation Logic --- // --- Health Bar Update --- this.updateHealthBarPosition(); // --- Particle Update --- if (this.emberParticles) { this.emberParticles.update(deltaTime); } // --- End Particle Update --- // --- Process Status Effects --- this.processStatusEffects(deltaTime); // --- End Status Effects --- // --- Update Health Bar Icons --- if (this.healthBar) { this.healthBar.updateStatusIcons(this.statusEffects); } // --- End Health Bar Icons --- // --- End Health Bar Icons --- // Update skill cooldown if (this.skillCooldown > 0) { this.skillCooldown -= deltaTime; } // --- Shroud Stealth Logic --- // Check if THIS player is inside the shroud THEY created // Note: This doesn't handle entering another player's shroud yet const currentlyInShroud = !!this.activeShroudEffect; // True if this player has an active shroud mesh if (currentlyInShroud !== this.isInShroud) { // State changed this.isInShroud = currentlyInShroud; this.updateStealthVisuals(this.isInShroud); } // --- Check if player left their own shroud --- if (this.activeShroudEffect && this.shroudCenter) { const distanceToCenter = this.mesh.position.distanceTo(this.shroudCenter); if (distanceToCenter > this.shroudRadius) { // console.log(`Player ${this.isLocalPlayer ? '1' : '2'} moved outside their shroud. Cancelling effect.`); this.cancelShroudEffect(); } } // Check for Clone Blink distance limit (using same shroud radius logic) // Clone Blink range check removed // --- End Shroud Exit Check --- // --- End Shroud Stealth Logic --- // --- End Health Bar Update --- } playAnimation(name, loop, crossFadeDuration, speedMultiplier) { // Assign default values if not provided const shouldLoop = loop === undefined ? true : loop; const fadeDuration = crossFadeDuration === undefined ? 0.2 : crossFadeDuration; const timeScale = speedMultiplier === undefined ? 1.0 : speedMultiplier; // Default speed is 1.0 if (!this.mixer || !this.animations[name]) { console.warn(`Animation "${name}" not found or mixer not ready. Available animations:`, Object.keys(this.animations)); return null; // Animation not found or ready } const newAction = this.mixer.clipAction(this.animations[name]); // If it's the exact same action and already running (likely looping), do nothing. // Also handles the case where we try to play the same non-looping action again immediately. if (this.currentAction === newAction && newAction.isRunning()) { return newAction; } // Prepare the new action newAction.enabled = true; newAction.setLoop(shouldLoop ? THREE.LoopRepeat : THREE.LoopOnce, Infinity); newAction.clampWhenFinished = !shouldLoop; newAction.timeScale = timeScale; // Set the playback speed newAction.reset(); // Always reset before playing/fading if (this.currentAction) { // If the *new* action is non-looping (like attack), explicitly stop the current one. if (!shouldLoop) { this.currentAction.stop(); newAction.play(); // Play the new non-looping action directly after stopping the old one } else { // Otherwise (new action is looping), use crossfade for smooth transition. this.currentAction.crossFadeTo(newAction, fadeDuration, true); newAction.fadeIn(fadeDuration).play(); // Fade in the looping action } } else { // No current animation, just play the new one newAction.play(); } this.currentAction = newAction; return newAction; } performAttack() { // Renamed method for clarity // Check if player is dead - if so, prevent attacking if (this.isDead) { console.log("Cannot attack: Player is dead"); return; } // --- Cancel Stealth Effects Immediately --- this.cancelShroudEffect(); // Break shroud stealth before attacking // Clone blink stealth cancellation removed // --- End Cancel Stealth --- const equippedSkillId = this.isLocalPlayer && this.controls ? this.controls.equippedAttackSkillId : null; // Add skill-specific cooldowns if (equippedSkillId === 'pain' && this.attackCooldown <= 0) { this.attackCooldown = 2.0; // 2-second cooldown for Pain } else if (equippedSkillId === 'conduit' && this.attackCooldown <= 0) { this.attackCooldown = 5.0; // 5-second cooldown for Conduit } else if (this.attackCooldown <= 0) { this.attackCooldown = this.ATTACK_COOLDOWN_TIME; // Default cooldown for other skills } else { return; // Still on cooldown, don't continue } // Select the appropriate animation based on the equipped skill const attackAnim = equippedSkillId === 'pain' ? 'Cheer' : equippedSkillId === 'shuriken' ? 'Throw' : equippedSkillId === 'conduit' ? 'Interact' : equippedSkillId === 'puncture' ? '1H_Melee_Attack_Stab' : // Stab animation for puncture equippedSkillId === 'plagueStrike' ? '1H_Melee_Attack_Stab' : // Use same stab animation for plague strike equippedSkillId === 'poisonStrike' ? '1H_Melee_Attack_Stab' : // Use stab animation for poison strike '1H_Melee_Attack_Slice_Horizontal'; // Default slice animation for basic attacks if (attackAnim) { const animSpeed = attackAnim === 'Throw' ? 5.0 : attackAnim === '1H_Melee_Attack_Stab' ? 1.5 : // 1.5x speed for Puncture stab animation 1.0; // 1x for others this.playAnimation(attackAnim, false, 0.1, animSpeed); // Pass speed multiplier this.lastAttackAnimationName = attackAnim; // Store the name of the animation played } else { this.lastAttackAnimationName = null; // Reset if no specific attack animation played } if (equippedSkillId === 'shuriken') { // --- Spawn Shuriken --- this.spawnShuriken(); } else if (equippedSkillId === 'conduit') { // --- Spawn Conduit Lightning --- this.spawnConduit(); } else if (equippedSkillId === 'puncture') { // --- Spawn Puncture Blade --- this.spawnPunctureBlade(); } else if (equippedSkillId === 'plagueStrike') { // --- Spawn Plague Strike effect --- this.spawnPlagueStrike(); } else if (equippedSkillId === 'poisonStrike') { // --- Spawn Poison Strike cone --- this.spawnPoisonStrike(); } // --- Damage/Effect Application --- // --- Check for Self-Inflicted Effects FIRST (like Pain skill) --- // Only the local player can activate skills that cause self-damage if (this.isLocalPlayer && this.controls && equippedSkillId === 'pain') { console.log(`Player ${this.isLocalPlayer ? '1' : '2'} used Pain! Taking 10 damage.`); // Apply damage after a short delay setTimeout(() => { this.takeDamage(10); }, 160); // Apply self-damage shortly after button press } // --- End Self-Inflicted Effects --- // --- Damage Check on Others (Delayed) --- // Slightly delay the damage check to align better with the swing animation visually setTimeout(() => { // --- Hitbox Intersection Damage Check --- if (!this.sword) return; // Need the sword mesh for hitbox check // Only check for hits if the attack *isn't* a self-damaging one like 'Pain' // Or, allow 'Pain' to *also* hit others if desired (currently it won't) // Only check for hits if the attack *isn't* a self-damaging one like 'Pain' // Or, allow 'Pain' to *also* hit others if desired (currently it won't) // If we want Pain to *also* hit others, remove this check: `&& equippedSkillId !== 'pain'` if (equippedSkillId !== 'pain') { const swordBox = new THREE.Box3().setFromObject(this.sword, true); // Get sword's world bounding box // Check against other players this.game.players.forEach(otherPlayer => { // Ensure target isn't self, is loaded, has health, and has a model if (otherPlayer !== this && otherPlayer.modelLoaded && otherPlayer.currentHealth > 0 && otherPlayer.model) { const targetBox = new THREE.Box3().setFromObject(otherPlayer.model, true); // Get target's world bounding box // Check for intersection if (swordBox.intersectsBox(targetBox)) { console.log(`Puncture blade hit ${otherPlayer.isLocalPlayer ? 'local' : 'remote'} player with model: ${otherPlayer.modelUrl}`); console.log(`Player ${this.isLocalPlayer ? '1' : '2'} sword hitbox collided with Player ${otherPlayer.isLocalPlayer ? '1' : '2'}`); // Apply effects based on attacker's skill (already checked it's not 'pain' above) if (equippedSkillId === 'puncture') { console.log(`Applying Puncture defense reduction from Player ${this.isLocalPlayer ? '1' : '2'} to Player ${otherPlayer.isLocalPlayer ? '1' : '2'}!`); // Apply defense reduction status effect otherPlayer.applyStatusEffect({ type: 'defensereduction', duration: 4, // 4 seconds as specified in skill description speedMultiplier: 1.0, // Not slowing them down defenseMultiplier: 0.75 // 25% defense reduction (0.75 = 75% of normal) }); // Apply base damage otherPlayer.takeDamage(15); // 15 damage as specified in skill description // Apply bleed effect after a short delay setTimeout(() => { // Apply bleed status effect otherPlayer.applyStatusEffect({ type: 'bleed', duration: 6, // 6 seconds of bleeding tickInterval: 1.0, // Damage every 1 second damagePerTick: 3, // 3 damage per tick lastTickTime: otherPlayer.game.clock.elapsedTime // Start ticking immediately }); console.log(`Applied Bleed effect from sword hit to ${otherPlayer.isLocalPlayer ? 'local' : 'remote'} player!`); }, 200); // 200ms delay before bleed starts } else { console.log(`Applying default attack damage from Player ${this.isLocalPlayer ? '1' : '2'} to Player ${otherPlayer.isLocalPlayer ? '1' : '2'}.`); // Apply default damage if no specific skill is equipped or recognized otherPlayer.takeDamage(this.ATTACK_DAMAGE); } // TODO: Add mechanism to prevent multiple hits/effects from a single swing } } }); } // End of check: if (equippedSkillId !== 'pain') // --- End Hitbox Intersection Damage Check --- }, 150); // Delay for hitbox check in milliseconds // --- End Damage Check on Others --- // Sword light/particle effects are handled elsewhere or could be triggered here too. } // Handle using a defense/utility skill useDefenseSkill(skillId) { // Check if player is dead - if so, prevent using defense skills if (this.isDead) { console.log("Cannot use defense skill: Player is dead"); return; } // No need to check for stealth - clone blink no longer has stealth console.log(`Player ${this.isLocalPlayer ? '1' : '2'} using defense skill: ${skillId}`); if (skillId === 'healthPotion') { // Attempt to play 'Interact' animation at roughly 1/2 speed (for ~2 sec duration) const action = this.playAnimation('Interact', false, 0.1, 0.5); // Non-looping, medium speed // Apply slow effect immediately console.log("Potion used, applying slow effect immediately."); this.applyStatusEffect({ type: 'slow', duration: 3, // 3 seconds speedMultiplier: 0.5, // 50% speed reduction // tickInterval and damagePerTick are not needed for slow }); // Remove the animation 'finished' listener logic this.restoreHealth(10); // Restore 10 health // Maybe add a visual effect later? } else if (skillId === 'shroud') { // Check if a shroud is already active if (this.activeShroudEffect) return; // Don't stack shrouds this.shroudRadius = 5; // Store radius const shroudDuration = 10000; // 10 seconds in milliseconds // Create the visual effect: a flat gray circle on the ground const geometry = new THREE.CircleGeometry(this.shroudRadius, 32); // Use stored radius const material = new THREE.MeshBasicMaterial({ color: 0x808080, // Gray transparent: true, opacity: 0.4, side: THREE.DoubleSide // Visible from both top and bottom }); const shroudMesh = new THREE.Mesh(geometry, material); // Position it at the player's feet on the ground plane (y=0) this.shroudCenter = this.mesh.position.clone(); // Store the center position this.shroudCenter.y = 0.01; // Match the shroud mesh Y shroudMesh.position.copy(this.shroudCenter); // Position the mesh at the stored center shroudMesh.rotation.x = -Math.PI / 2; // Rotate to lie flat on the XZ plane this.scene.add(shroudMesh); this.activeShroudEffect = shroudMesh; // Store reference console.log(`Shroud activated at ${this.shroudCenter.x.toFixed(1)},${this.shroudCenter.z.toFixed(1)} for Player ${this.isLocalPlayer ? '1' : '2'}`); // Remove the effect after the duration - store the timeout ID this.shroudTimeoutId = setTimeout(() => { this.cancelShroudEffect(); // Use the cancel method for cleanup }, shroudDuration); // Optional: Play an animation or sound (Use normal speed for Shroud) this.playAnimation('Interact', false, 0.1); } else if (skillId === 'deceive') { // Create three decoys of the player around the original position this.createMultipleDecoys(3); // Play the animation for the skill this.playAnimation('Interact', false, 0.1); } else if (skillId === 'dash') { // Implement clone blink movement - quickly teleport in current facing direction leaving a decoy behind console.log(`Player ${this.isLocalPlayer ? '1' : '2'} using Clone Blink!`); // Create a clone blink shroud effect this.shroudRadius = 10; // Larger radius than normal shroud for more movement freedom const dashShroudDuration = 5000; // 5 seconds // Store the origin position for the dash shroud this.shroudCenter = this.mesh.position.clone(); console.log(`Setting Clone Blink shroud center to: ${this.shroudCenter.x.toFixed(2)}, ${this.shroudCenter.z.toFixed(2)}`); // Remove immediate stealth application - will be applied after delay console.log(`Player ${this.isLocalPlayer ? '1' : '2'} using Clone Blink, stealth will activate in 1 second.`); // Create stealth entry visual effect this.createStealthEntryEffect(); // Create a decoy at the player's current position before dashing this.createDecoy(); // Set up delayed stealth activation setTimeout(() => { // Apply stealth effect to the player AFTER a delay this.isInShroud = true; this.updateStealthVisuals(true); console.log(`Player ${this.isLocalPlayer ? '1' : '2'} entered Clone Blink stealth after delay.`); // Create stealth entry visual effect again this.createStealthEntryEffect(); }, 1000); // 1 second delay before stealth activates // Get current facing direction (forward vector) const dashDirection = new THREE.Vector3(0, 0, 1); dashDirection.applyQuaternion(this.mesh.quaternion); // Reset current velocity first (to make the dash more consistent regardless of current movement) this.velocity.x = 0; this.velocity.z = 0; // Apply a massively powerful impulse in that direction const dashPower = 150.0; // Massively increased power for an extreme dash distance this.velocity.x = dashDirection.x * dashPower; this.velocity.z = dashDirection.z * dashPower; // Apply a slower deceleration after the dash to let it travel further const dashDuration = 0.25; // Longer duration for the dash setTimeout(() => { // Apply more gradual stopping to allow sliding further this.velocity.x *= 0.3; // Less abrupt deceleration this.velocity.z *= 0.3; // Add a secondary deceleration to eventually stop the player setTimeout(() => { this.velocity.x *= 0.1; // Final strong deceleration this.velocity.z *= 0.1; }, 150); // Short delay for secondary deceleration }, dashDuration * 1000); // Create a trail effect this.createDashTrail(); // Play the dodge animation for the dash and ensure it completes const dashAnimName = 'Dodge_Right'; // Store a reference to keep track of animation completion const dashAction = this.playAnimation(dashAnimName, false, 0, 1.0); // Force the animation to play fully if (dashAction) { // Get current animation duration const duration = dashAction.getClip().duration * 1000; // Convert to milliseconds // Set a timer to ensure we wait for the full animation to complete // regardless of other animations trying to interrupt this.isCloneBlinking = true; // Add flag to prevent interruption setTimeout(() => { this.isCloneBlinking = false; // Clear clone blinking flag // Create invisible shroud for tracking distance // We don't create a visible shroud mesh, but we set a timer to clean up the stealth // Clone Blink stealth timeout removed // Return to idle/run animation if we're still on the ground if (this.isOnGround) { const isMoving = this.velocity.x * this.velocity.x + this.velocity.z * this.velocity.z > 0.1; this.playAnimation(isMoving ? 'Running_A' : 'Idle'); } }, duration); // Use the actual animation duration } } else if (skillId === 'block') { // Create a block shield this.createBlockShield(); // Play the animation for the skill this.playAnimation('Interact', false, 0.1); } // Add other defense skills here if needed } // --- Health Bar Related --- // Gets the world position above the player's head for the health bar getHealthBarWorldPosition() { // Start with the mesh's world position const position = new THREE.Vector3(); this.mesh.getWorldPosition(position); // Adjust upwards position.y += HEALTH_BAR_Y_OFFSET; // Use the defined offset return position; } updateHealthBarPosition() { const worldPosition = this.getHealthBarWorldPosition(); const camera = this.game.sceneInfo.camera; // Access camera from game const canvas = this.game.renderer.domElement; // Access canvas from game this.healthBar.updatePosition(worldPosition, camera, canvas); } // Call this method to reduce player health takeDamage(amount) { if (this.currentHealth <= 0) return; // Already dead // Invincibility Check - REMOVED // const currentTime = this.game.clock.elapsedTime; // if (currentTime - this.lastDamagedTime < INVINCIBILITY_DURATION) { // // console.log("Player invincible, damage skipped."); // return; // Still invincible // } // Apply Damage this.currentHealth -= amount; this.currentHealth = Math.max(0, this.currentHealth); // Clamp health above 0 // this.lastDamagedTime = currentTime; // Update last damaged time - REMOVED // Update Health Bar const healthPercent = this.currentHealth / this.maxHealth; this.healthBar.setHealth(healthPercent); // Pass the 0.0-1.0 value console.log(`Player took ${amount} damage. Current health: ${this.currentHealth}/${this.maxHealth}`); // Log the 0-100 value // Handle Death if (this.currentHealth <= 0) { this.handleDeath(); } } // Restores health to the player restoreHealth(amount) { if (this.currentHealth <= 0) return; // Cannot heal if dead this.currentHealth += amount; this.currentHealth = Math.min(this.maxHealth, this.currentHealth); // Clamp health below maxHealth // Update Health Bar const healthPercent = this.currentHealth / this.maxHealth; this.healthBar.setHealth(healthPercent); // Pass the 0.0-1.0 value console.log(`Player restored ${amount} health. Current health: ${this.currentHealth}/${this.maxHealth}`); // Optional: Show a '+ health' visual effect near the player } // Applies a new status effect to the player // Applies a new status effect to the player, optionally delaying the first tick applyStatusEffect(effectData, firstTickTime = -Infinity) { const newEffect = { ...effectData, timeRemaining: effectData.duration, // Set the lastTickTime to delay the first tick if firstTickTime is provided lastTickTime: effectData.tickInterval ? firstTickTime : -Infinity, // Only relevant for ticking effects stack: 1 // Initialize stack count to 1 }; // Handle different stacking behavior based on effect type if (effectData.type === 'bleed') { // For bleed, find and replace any existing bleed effect (no stacking) const existingBleedIndex = this.statusEffects.findIndex(effect => effect.type === 'bleed'); if (existingBleedIndex >= 0) { this.statusEffects[existingBleedIndex] = newEffect; } else { this.statusEffects.push(newEffect); } } else if (effectData.type === 'poison') { // For poison, allow stacking up to 3 stacks const existingPoisonEffects = this.statusEffects.filter(effect => effect.type === 'poison'); if (existingPoisonEffects.length >= 3) { // Find the poison effect with the least time remaining and replace it let minTimeIndex = -1; let minTime = Infinity; for (let i = 0; i < this.statusEffects.length; i++) { const effect = this.statusEffects[i]; if (effect.type === 'poison' && effect.timeRemaining < minTime) { minTime = effect.timeRemaining; minTimeIndex = i; } } if (minTimeIndex >= 0) { this.statusEffects[minTimeIndex] = newEffect; } } else { // Add new poison stack this.statusEffects.push(newEffect); } // Update stack count display for all poison effects const poisonCount = this.statusEffects.filter(effect => effect.type === 'poison').length; this.statusEffects.forEach(effect => { if (effect.type === 'poison') { effect.stack = poisonCount; } }); } else { // For all other effects, just add them this.statusEffects.push(newEffect); } const logDetails = effectData.tickInterval ? `First tick starts around: ${firstTickTime > 0 ? firstTickTime.toFixed(2) : 'immediate'}` : `Speed Multiplier: ${effectData.speedMultiplier}`; console.log(`Applied ${effectData.type} effect. Duration: ${effectData.duration}s. ${logDetails}`); } // Processes active status effects each frame processStatusEffects(deltaTime) { const currentTime = this.game.clock.elapsedTime; for (let i = this.statusEffects.length - 1; i >= 0; i--) { const effect = this.statusEffects[i]; effect.timeRemaining -= deltaTime; // Check if it's time for the next tick // Note: This simple time check might cause drift. A more robust solution // would track total elapsed time or expected tick count. if (currentTime - effect.lastTickTime >= effect.tickInterval) { if (effect.type === 'bleed') { this.takeDamage(effect.damagePerTick); console.log(`Bleed tick: ${effect.damagePerTick} damage. ${effect.timeRemaining.toFixed(1)}s remaining.`); } else if (effect.type === 'poison') { this.takeDamage(effect.damagePerTick); console.log(`Poison tick: ${effect.damagePerTick} damage. ${effect.timeRemaining.toFixed(1)}s remaining. Stack: ${effect.stack || 1}`); } // Add other ticking effect types here effect.lastTickTime = currentTime; // Record the time of this tick } // Remove effect if duration is over if (effect.timeRemaining <= 0) { console.log(`${effect.type} effect expired.`); this.statusEffects.splice(i, 1); } } } handleDeath() { console.log("Player has died."); this.healthBar.hide(); // Hide health bar on death // Play the Death_A animation and prevent it from being interrupted this.playAnimation('Death_A', false); this.isDead = true; // Add flag to track death state // Clear status effects on death this.statusEffects = []; // Ensure visuals are reset on death this.updateStealthVisuals(false); // Cancel any active stealth effects this.cancelShroudEffect(); // Clone blink stealth cancellation removed // If this is the local player, show a death message if (this.isLocalPlayer) { console.log("Game over - player has died!"); } } // --- End Health Bar Related --- // --- Stealth Visuals --- updateStealthVisuals(isStealthed) { if (!this.model) return; // Model not loaded yet if (isStealthed) { // Entering stealth console.log(`Player ${this.isLocalPlayer ? '1' : '2'} entering stealth.`); if (this.isLocalPlayer) { // Local player: Become semi-transparent this.model.traverse((child) => { if (child.isMesh && child.material) { const materials = Array.isArray(child.material) ? child.material : [child.material]; materials.forEach(material => { // Store original properties if not already stored if (!this.originalMaterials.has(material)) { this.originalMaterials.set(material, { transparent: material.transparent, opacity: material.opacity, depthWrite: material.depthWrite }); } // Apply stealth effect material.transparent = true; material.opacity = 0.35; // Semi-transparent material.depthWrite = false; // Often needed for transparency sorting material.needsUpdate = true; }); } }); } else { // Remote player: Become completely invisible this.model.visible = false; } } else { // Exiting stealth console.log(`Player ${this.isLocalPlayer ? '1' : '2'} exiting stealth.`); if (this.isLocalPlayer) { // Local player: Restore original material properties this.model.traverse((child) => { if (child.isMesh && child.material) { const materials = Array.isArray(child.material) ? child.material : [child.material]; materials.forEach(material => { if (this.originalMaterials.has(material)) { const originalProps = this.originalMaterials.get(material); material.transparent = originalProps.transparent; material.opacity = originalProps.opacity; material.depthWrite = originalProps.depthWrite; material.needsUpdate = true; } }); } }); this.originalMaterials.clear(); // Clear stored states after restoring } else { // Remote player: Become visible again this.model.visible = true; } } } // --- End Stealth Visuals --- // --- Shuriken Spawning --- spawnShuriken() { // We need access to the game instance to add the shuriken to the global update loop if (!this.game) return; console.log(`Player ${this.isLocalPlayer ? '1' : '2'} throwing shuriken!`); // Calculate initial position and direction const startPosition = this.mesh.position.clone(); startPosition.y += Player.PLAYER_HEIGHT_OFFSET + 0.2; // Start slightly above player center const direction = new THREE.Vector3(0, 0, 1); // Forward direction relative to player direction.applyQuaternion(this.mesh.quaternion); // Rotate to match player's facing direction // --- This is where we'll create the Shuriken instance in the next step --- this.game.createShuriken(startPosition, direction, this); // Pass necessary info to Game } // Spawn a lightning bolt effect in front of the player spawnConduit() { // We need access to the game instance to create effects if (!this.game) return; console.log(`Player ${this.isLocalPlayer ? '1' : '2'} summoning lightning conduit!`); // Calculate target position for the lightning strike // We want it to appear a few units in front of the player const playerForward = new THREE.Vector3(0, 0, 1); // Forward direction in local space playerForward.applyQuaternion(this.mesh.quaternion); // Convert to world space direction // Set the lightning strike position 5 units in front of the player const targetPosition = this.mesh.position.clone().add(playerForward.multiplyScalar(5)); // Use the game instance to create the conduit effect this.game.createConduit(targetPosition, this); // Pass target position and the player who summoned it } // --- Spawn Puncture Cone Projectile --- spawnPunctureBlade() { if (!this.scene || !this.game) return; // Need scene and game for visual and collisions console.log(`Player ${this.isLocalPlayer ? '1' : '2'} using Puncture cone attack!`); // Calculate forward direction const forward = new THREE.Vector3(0, 0, 1); forward.applyQuaternion(this.mesh.quaternion); // Cone properties const coneHeight = 1.8; // Reduced length of the cone const coneRadius = 0.9; // Reduced width at the wide end const coneSegments = 16; // Smoothness of the cone // Create a cone visual effect with a sharper, more aerodynamic look const coneGeometry = new THREE.ConeGeometry(coneRadius, coneHeight, coneSegments, 1, false, 0, Math.PI * 2); // Create a gradient material that's darker and more intense at the tip const coneMaterial = new THREE.ShaderMaterial({ uniforms: { color1: { value: new THREE.Color(0xFF3333) }, // Base red color color2: { value: new THREE.Color(0xCC0000) }, // Darker red for the tip tipFactor: { value: 0.8 } // How much of the cone is affected by the tip color }, vertexShader: ` varying vec2 vUv; void main() { vUv = uv; gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0); } `, fragmentShader: ` uniform vec3 color1; uniform vec3 color2; uniform float tipFactor; varying vec2 vUv; void main() { // Create a gradient that's more intense at the tip (vUv.y = 1.0 is at the tip) float factor = pow(vUv.y, tipFactor); vec3 finalColor = mix(color1, color2, factor); // Add a pulsing glow effect float pulse = sin(vUv.y * 10.0) * 0.1 + 0.9; finalColor *= pulse; // Add some variation based on distance from center float edge = smoothstep(0.0, 0.5, 1.0 - length(vUv - vec2(0.5, 0.5)) * 2.0); float opacity = 0.6 * edge; gl_FragColor = vec4(finalColor, opacity); } `, transparent: true, side: THREE.DoubleSide, depthWrite: false }); const coneMesh = new THREE.Mesh(coneGeometry, coneMaterial); // Position the cone in front of the player const startPosition = this.mesh.position.clone(); startPosition.y += this.constructor.PLAYER_HEIGHT_OFFSET; // Same height as player center // Create a group to make rotation handling cleaner const coneGroup = new THREE.Group(); this.scene.add(coneGroup); // Reverse the cone geometry to have pointy side facing outward // We'll rotate it 180 degrees instead of changing the cone construction // Create an enhanced flash effect when the cone appears const flashGeometry = new THREE.CircleGeometry(coneRadius * 1.8, 32); const flashMaterial = new THREE.ShaderMaterial({ uniforms: { color: { value: new THREE.Color(0xFF5555) }, time: { value: 0.0 } }, vertexShader: ` varying vec2 vUv; void main() { vUv = uv; gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0); } `, fragmentShader: ` uniform vec3 color; uniform float time; varying vec2 vUv; void main() { float dist = length(vUv - vec2(0.5, 0.5)) * 2.0; float edge = 1.0 - smoothstep(0.0, 0.9, dist); // Add radial rays emanating from center float rays = sin(atan(vUv.y - 0.5, vUv.x - 0.5) * 12.0) * 0.5 + 0.5; float finalOpacity = edge * (0.8 - dist * 0.5) * (rays * 0.3 + 0.7); gl_FragColor = vec4(color, finalOpacity); } `, transparent: true, side: THREE.DoubleSide, depthWrite: false }); const flashMesh = new THREE.Mesh(flashGeometry, flashMaterial); // Position the flash perpendicular to the cone direction flashMesh.position.copy(coneMesh.position); flashMesh.rotation.y = Math.PI / 2; // Face the flash circle perpendicular to the cone direction coneGroup.add(flashMesh); // Add the cone to the group coneGroup.add(coneMesh); // Position the cone with the tip at the player's hand position (near where staff would be) // Find a better offset for the mage's staff position - higher and to the side const handOffset = new THREE.Vector3(0.4, 1.1, 0.6); // Increased forward offset (Z value increased from 0.2 to 0.6) // Rotate the cone so the point faces outward (away from player) // The cone in THREE.js points along positive Y by default // First rotate it to be horizontal by rotating 90 degrees around X coneMesh.rotation.x = Math.PI / 2; // Position the cone mesh within the group so the wide base is closer to player // and the pointy end extends outward coneMesh.position.z = -coneHeight / 2; // Negative to extend forward (away from player) // Position and rotate the group to match player's position and orientation coneGroup.position.copy(startPosition); coneGroup.quaternion.copy(this.mesh.quaternion); // Apply the hand offset in local space (relative to player orientation) const localHandOffset = handOffset.clone(); localHandOffset.applyQuaternion(this.mesh.quaternion); coneGroup.position.add(localHandOffset); // Extend the cone forward from the hand position const coneOffset = forward.clone().multiplyScalar(coneHeight * 0.75); // Further increased offset (from coneHeight/2 to coneHeight*0.75) coneGroup.position.add(coneOffset); // Don't add coneMesh directly to scene since it's already in the coneGroup // Create a hitbox for the cone (using the group that contains the cone) const coneBox = new THREE.Box3().setFromObject(coneGroup); // Check for collision with the cone setTimeout(() => { // Check against other players - reduced delay to match faster animation this.game.players.forEach(otherPlayer => { if (otherPlayer !== this && otherPlayer.modelLoaded && otherPlayer.currentHealth > 0 && otherPlayer.model) { const targetBox = new THREE.Box3().setFromObject(otherPlayer.model); if (coneBox.intersectsBox(targetBox)) { console.log(`Puncture cone hit ${otherPlayer.isLocalPlayer ? 'local' : 'remote'} player!`); // Calculate how centered in the cone the player is // The closer to the center, the more damage const targetPosition = new THREE.Vector3(); targetBox.getCenter(targetPosition); // Get the direction from player to target const directionToTarget = targetPosition.clone().sub(startPosition).normalize(); // Dot product gives a value between -1 and 1 indicating how aligned the vectors are // 1 means perfectly aligned (target directly in front) const alignment = forward.dot(directionToTarget); // Only hit if the target is actually in front of the player (alignment > 0) if (alignment > 0) { // Apply defense reduction status effect otherPlayer.applyStatusEffect({ type: 'defensereduction', duration: 4, // 4 seconds as specified in skill description speedMultiplier: 1.0, // Not slowing them down defenseMultiplier: 0.75 // 25% defense reduction (0.75 = 75% of normal) }); // Apply damage based on how centered the target is in the cone // Scaling factor from 0.7 to 1.0 of base damage const damageFactor = 0.7 + (alignment * 0.3); const damage = Math.round(15 * damageFactor); otherPlayer.takeDamage(damage); console.log(`Applied Puncture cone damage: ${damage}, alignment: ${alignment.toFixed(2)}`); // Apply bleed effect after a short delay (to visually separate from initial hit) setTimeout(() => { // Apply bleed status effect otherPlayer.applyStatusEffect({ type: 'bleed', duration: 6, // 6 seconds of bleeding tickInterval: 1.0, // Damage every 1 second damagePerTick: 3, // 3 damage per tick lastTickTime: otherPlayer.game.clock.elapsedTime // Start ticking immediately }); console.log(`Applied Bleed effect to ${otherPlayer.isLocalPlayer ? 'local' : 'remote'} player!`); }, 200); // 200ms delay before bleed starts } } } }); }, 70); // Reduced delay for visuals to match faster animation // Animation and cleanup let elapsedTime = 0; const animationDuration = 0.25; // seconds, reduced from 0.4 to make the animation faster // Flash animation variables let flashScale = 1.0; let flashOpacity = 0.8; const animate = () => { elapsedTime += 0.016; // Approximately 60fps // Quick flash animation at the start if (elapsedTime < 0.15) { // Only during first 150ms // Expand and fade the flash flashScale = 1.0 + (elapsedTime / 0.15) * 2.5; // Increased expansion flashOpacity = 0.8 * (1.0 - (elapsedTime / 0.15)); // Update shader time uniform for animated effects if (flashMaterial.uniforms) { flashMaterial.uniforms.time.value = elapsedTime; } // Apply scale and opacity flashMesh.scale.set(flashScale, flashScale, flashScale); } else if (flashMesh.parent) { // Remove the flash after its animation is complete coneGroup.remove(flashMesh); } // Progress of the animation from 0 to 1 const progress = Math.min(elapsedTime / animationDuration, 1.0); // Add a streaking effect to the cone to make it look more like it's piercing through air const scale = 1.0 + Math.sin(progress * Math.PI * 3) * 0.08; // Higher frequency, less amplitude // Scale the cone more along its length for a more piercing look coneMesh.scale.set(scale * 0.9, scale * 1.4, scale * 0.9); // More elongated for aerodynamic effect // Add a slight rotational effect to suggest drilling/piercing motion coneMesh.rotation.z = Math.sin(progress * Math.PI * 6) * 0.05; // Subtle rotation // Update shader uniforms if they exist if (coneMaterial.uniforms) { // Pulsate the tip color intensity const pulseFactor = 0.7 + Math.sin(progress * Math.PI * 4) * 0.3; coneMaterial.uniforms.tipFactor.value = pulseFactor; } // Fade out toward the end with a more dramatic disappearance if (progress > 0.7) { const fadeProgress = (progress - 0.7) / 0.3; // 0 to 1 during the last 30% of animation // Non-linear fade out for more dramatic effect const opacity = 0.3 * Math.pow(1 - fadeProgress, 2); if (coneMaterial.uniforms) { // For shader materials, we'd modify a uniform // But the opacity is handled in the fragment shader } } if (progress < 1.0) { requestAnimationFrame(animate); } else { // Cleanup when animation is done this.scene.remove(coneGroup); coneGeometry.dispose(); coneMaterial.dispose(); flashGeometry.dispose(); flashMaterial.dispose(); } }; animate(); } // --- End Spawn Methods --- dispose() { // Remove player mesh from scene if (this.mesh.parent) { this.mesh.parent.remove(this.mesh); } // Dispose health bar if (this.healthBar) { this.healthBar.dispose(); this.healthBar = null; } // Dispose particles if (this.emberParticles) { this.emberParticles.dispose(); this.emberParticles = null; } // Stop animations and remove listeners if (this.mixer) { this.mixer.stopAllAction(); // Consider removing event listeners if any were added directly to the mixer } // TODO: Dispose geometries and materials if necessary, especially for fallback mesh // Ensure shroud effect is cleaned up if player is disposed while it's active this.cancelShroudEffect(); // Use the cancel method to clean up shroud } // End of dispose method // Centralized shroud cancellation logic cancelShroudEffect() { if (!this.activeShroudEffect) return; // Nothing to cancel // Clear the scheduled removal timeout if (this.shroudTimeoutId) { clearTimeout(this.shroudTimeoutId); this.shroudTimeoutId = null; } // Remove the visual mesh from the scene and dispose of resources if (this.activeShroudEffect.parent) { this.activeShroudEffect.parent.remove(this.activeShroudEffect); } if (this.activeShroudEffect.geometry) { this.activeShroudEffect.geometry.dispose(); } if (this.activeShroudEffect.material) { // Handle array of materials if necessary const materials = Array.isArray(this.activeShroudEffect.material) ? this.activeShroudEffect.material : [this.activeShroudEffect.material]; materials.forEach(mat => mat.dispose()); } this.activeShroudEffect = null; this.shroudCenter = null; // Clear the stored center position this.shroudRadius = 0; // Clear the stored radius console.log(`Shroud cancelled/expired for Player ${this.isLocalPlayer ? '1' : '2'}`); // Immediately update visuals to exit stealth // Check if the player *was* in stealth and needs visuals updated if (this.isInShroud) { this.isInShroud = false; // Update state *before* visual update this.updateStealthVisuals(false); } } // Method to cancel the stealth effect from Clone Blink removed // Creates multiple decoys that look exactly like the player and disappear after 5 seconds // Decoys are completely separate entities and don't share status effects with players createMultipleDecoys(count) { if (!this.modelLoaded || !this.model) return; console.log(`Player ${this.isLocalPlayer ? '1' : '2'} creating ${count} decoys!`); // Store original player position and rotation const playerPosition = this.mesh.position.clone(); const playerRotation = this.mesh.quaternion.clone(); // Array to collect all created decoys const decoys = []; // Create the specified number of decoys for (let i = 0; i < count; i++) { // Calculate random offset within a small circle around the player const angle = Math.random() * Math.PI * 2; // Random angle const distance = 1 + Math.random() * 2; // Random distance between 1-3 units // Position offset from the player's position const offsetX = Math.cos(angle) * distance; const offsetZ = Math.sin(angle) * distance; // Create position for this decoy const position = playerPosition.clone(); position.x += offsetX; position.z += offsetZ; // Create rotation for this decoy (with slight variation) const rotationVariation = (Math.random() - 0.5) * 0.5; // Small random rotation const newRotation = playerRotation.clone(); const rotationAxis = new THREE.Vector3(0, 1, 0); // Rotate around Y axis const additionalRotation = new THREE.Quaternion().setFromAxisAngle( rotationAxis, rotationVariation ); newRotation.multiply(additionalRotation); // Create a completely fresh model clone to ensure no shared properties const freshModelClone = this.model.clone(); // Reset all material properties to defaults to avoid inheriting any visual effects freshModelClone.traverse((child) => { if (child.isMesh && child.material) { const materials = Array.isArray(child.material) ? child.material : [child.material]; materials.forEach(material => { // Create a new material instance to break any references to the original const newMaterial = material.clone(); // Reset material properties to default values newMaterial.transparent = false; newMaterial.opacity = 1.0; newMaterial.depthWrite = true; newMaterial.needsUpdate = true; // Replace the original material if (Array.isArray(child.material)) { const index = materials.indexOf(material); if (index !== -1) { child.material[index] = newMaterial; } } else { child.material = newMaterial; } }); } }); // Create the decoy using the Decoy class for proper collision handling const decoy = new Decoy( this.scene, freshModelClone, position, newRotation, 5000 + Math.random() * 500 // Slightly randomize lifespan ); // Explicitly call forceVisibility to ensure the decoy is separate from player stealth effects decoy.forceVisibility(); decoys.push(decoy); console.log(`Created decoy ${i+1} at position ${position.x.toFixed(2)}, ${position.z.toFixed(2)} with isolated visual properties`); } // Add all decoys to game update loop for collision detection if (this.game && decoys.length > 0) { this.game.addDecoys(decoys); } } // Keeps the original createDecoy method for compatibility with dash and other skills createDecoy() { if (!this.modelLoaded || !this.model) return; console.log(`Player ${this.isLocalPlayer ? '1' : '2'} creating single decoy!`); // Get current position and rotation const position = this.mesh.position.clone(); const rotation = this.mesh.quaternion.clone(); // Create a clone of the player model that will remain visible const clonedModel = this.model.clone(); // =========================================================================== // IMPORTANT: The code below ensures that decoys are ALWAYS fully visible // regardless of whether the player is in stealth mode or not. // // This is by design - decoys in the Clone Blink ability are meant to be // fully visible while the player is stealthed. // =========================================================================== // Force the decoy's materials to be non-transparent regardless of player's stealth state clonedModel.traverse((child) => { if (child.isMesh && child.material) { const materials = Array.isArray(child.material) ? child.material : [child.material]; materials.forEach(material => { // Explicitly set the decoy to be fully visible and never stealthed material.transparent = false; material.opacity = 1.0; material.needsUpdate = true; }); } }); // Create the decoy using the Decoy class for proper collision handling const decoy = new Decoy( this.scene, clonedModel, position, rotation, 5000 // 5 seconds lifespan ); // Double-check that the decoy is fully visible after creation // This is an extra safety measure to ensure the decoy is never stealthed if (decoy.model) { decoy.model.visible = true; decoy.model.traverse((child) => { if (child.isMesh && child.material) { const materials = Array.isArray(child.material) ? child.material : [child.material]; materials.forEach(material => { // These settings ensure the decoy is: // 1. Fully opaque (never semi-transparent) // 2. Properly rendered in the depth buffer (no z-fighting) // 3. Always visible regardless of player stealth state material.transparent = false; material.opacity = 1.0; material.depthWrite = true; material.needsUpdate = true; }); } }); console.log(`Decoy from Player ${this.isLocalPlayer ? '1' : '2'} created with full visibility (no stealth)`); } // Add decoy to game update loop for collision detection if (this.game) { // Explicitly call forceVisibility to ensure the decoy is fully visible // This provides an extra guarantee that the decoy will never be stealthed decoy.forceVisibility(); console.log(`forceVisibility called on decoy to guarantee 100% visibility`); this.game.addDecoys([decoy]); } console.log(`Created single decoy at position ${position.x.toFixed(2)}, ${position.z.toFixed(2)}`); } // Creates a block shield for blocking attacks createBlockShield() { if (!this.scene) return; console.log(`Player ${this.isLocalPlayer ? '1' : '2'} using Block!`); // Create a new Block instance with the shield visual const blockEffect = new Block(this.scene, this, 2.0); // 2 second duration // Add to game projectiles array for update loop if (this.game && this.game.projectiles) { this.game.projectiles.push(blockEffect); } // Apply damage reduction status effect to self this.applyStatusEffect({ type: 'defenseboost', duration: 2.0, // 2 seconds duration speedMultiplier: 1.0, // No speed change defenseMultiplier: 0.5 // 50% damage reduction }); } // createDashTrail method removed // Create a visual effect when entering stealth mode createStealthEntryEffect() { if (!this.scene || !this.modelLoaded) return; // Create a ripple effect around the player const rippleRadius = 2.0; const rippleGeometry = new THREE.RingGeometry(0.1, rippleRadius, 32); const rippleMaterial = new THREE.ShaderMaterial({ uniforms: { color: { value: new THREE.Color(0x00CCFF) }, // Bright cyan color time: { value: 0.0 }, radius: { value: rippleRadius } }, vertexShader: ` varying vec2 vUv; void main() { vUv = uv; gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0); } `, fragmentShader: ` uniform vec3 color; uniform float time; uniform float radius; varying vec2 vUv; void main() { // Calculate distance from center (0.5, 0.5) float dist = length(vUv - vec2(0.5, 0.5)) * 2.0; // Create a pulse wave that travels outward float wave = sin(dist * 10.0 - time * 15.0) * 0.5 + 0.5; // Sharp falloff at edge float edge = 1.0 - smoothstep(0.8, 1.0, dist); // Combine for final opacity float opacity = wave * edge * (1.0 - time * 0.8); // Add subtle shimmer float shimmer = sin(vUv.x * 30.0 + vUv.y * 20.0 + time * 20.0) * 0.1 + 0.9; gl_FragColor = vec4(color * shimmer, opacity); } `, transparent: true, side: THREE.DoubleSide, depthWrite: false }); const rippleMesh = new THREE.Mesh(rippleGeometry, rippleMaterial); rippleMesh.position.copy(this.mesh.position); rippleMesh.position.y = 0.1; // Just above ground rippleMesh.rotation.x = -Math.PI / 2; // Lay flat this.scene.add(rippleMesh); // Animate the ripple effect const startTime = performance.now(); const duration = 700; // 700ms for full effect const animateRipple = () => { const elapsedMs = performance.now() - startTime; const normalizedTime = Math.min(elapsedMs / duration, 1.0); if (normalizedTime < 1.0) { // Update shader time uniform rippleMaterial.uniforms.time.value = normalizedTime; // Scale the ring outward const scale = 1.0 + normalizedTime * 1.5; rippleMesh.scale.set(scale, scale, 1); requestAnimationFrame(animateRipple); } else { // Clean up after animation completes this.scene.remove(rippleMesh); rippleGeometry.dispose(); rippleMaterial.dispose(); } }; animateRipple(); // Add particles that swirl around the player const particleCount = 50; const particleGeometry = new THREE.BufferGeometry(); const positions = new Float32Array(particleCount * 3); const sizes = new Float32Array(particleCount); for (let i = 0; i < particleCount; i++) { // Random position in a sphere around the player const angle = Math.random() * Math.PI * 2; const radius = 1.0 + Math.random() * 1.5; const height = Math.random() * 2.0; positions[i * 3] = Math.cos(angle) * radius; positions[i * 3 + 1] = height; positions[i * 3 + 2] = Math.sin(angle) * radius; // Random sizes sizes[i] = 0.05 + Math.random() * 0.1; } particleGeometry.setAttribute('position', new THREE.BufferAttribute(positions, 3)); particleGeometry.setAttribute('size', new THREE.BufferAttribute(sizes, 1)); const particleMaterial = new THREE.PointsMaterial({ color: 0x00FFFF, size: 0.1, transparent: true, opacity: 0.7, blending: THREE.AdditiveBlending, depthWrite: false }); const particles = new THREE.Points(particleGeometry, particleMaterial); particles.position.copy(this.mesh.position); this.scene.add(particles); // Animate particles const animateParticles = () => { const elapsedMs = performance.now() - startTime; const normalizedTime = Math.min(elapsedMs / duration, 1.0); if (normalizedTime < 1.0) { // Spiral the particles inward const positions = particleGeometry.attributes.position.array; for (let i = 0; i < particleCount; i++) { const i3 = i * 3; const x = positions[i3]; const z = positions[i3 + 2]; // Calculate distance from center const dist = Math.sqrt(x * x + z * z); // Reduce distance (spiral inward) const newDist = dist * (1.0 - normalizedTime * 0.9); // Rotate around Y axis const angle = Math.atan2(z, x) + normalizedTime * 3.0; // Update position positions[i3] = Math.cos(angle) * newDist; positions[i3 + 2] = Math.sin(angle) * newDist; // Particles rise up slightly positions[i3 + 1] *= (1.0 - normalizedTime * 0.7); } particleGeometry.attributes.position.needsUpdate = true; // Fade out particles particleMaterial.opacity = 0.7 * (1.0 - normalizedTime); requestAnimationFrame(animateParticles); } else { // Clean up this.scene.remove(particles); particleGeometry.dispose(); particleMaterial.dispose(); } }; animateParticles(); } // Create a visual effect when exiting stealth mode createStealthExitEffect() { if (!this.scene || !this.modelLoaded) return; // Create a shockwave effect const waveRadius = 3.0; const waveGeometry = new THREE.CircleGeometry(waveRadius, 32); const waveMaterial = new THREE.ShaderMaterial({ uniforms: { color: { value: new THREE.Color(0x00CCFF) }, time: { value: 0.0 } }, vertexShader: ` varying vec2 vUv; void main() { vUv = uv; gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0); } `, fragmentShader: ` uniform vec3 color; uniform float time; varying vec2 vUv; void main() { float dist = length(vUv - vec2(0.5, 0.5)) * 2.0; // Create a ring effect with soft edges float innerEdge = smoothstep(time - 0.1, time, dist); float outerEdge = 1.0 - smoothstep(time, time + 0.1, dist); float ring = innerEdge * outerEdge; // Add shimmer effect float shimmer = sin(dist * 20.0 - time * 15.0) * 0.2 + 0.8; gl_FragColor = vec4(color * shimmer, ring * (1.0 - time) * 0.8); } `, transparent: true, side: THREE.DoubleSide, depthWrite: false }); const waveMesh = new THREE.Mesh(waveGeometry, waveMaterial); waveMesh.position.copy(this.mesh.position); waveMesh.position.y = 0.1; // Just above ground waveMesh.rotation.x = -Math.PI / 2; // Lay flat this.scene.add(waveMesh); // Animate the shockwave const startTime = performance.now(); const duration = 500; // 500ms - shorter, more impactful effect for exit const animateWave = () => { const elapsedMs = performance.now() - startTime; const normalizedTime = Math.min(elapsedMs / duration, 1.0); if (normalizedTime < 1.0) { // Update shader time uniform waveMaterial.uniforms.time.value = normalizedTime; // Scale slightly during animation const scale = 1.0 + normalizedTime * 0.5; waveMesh.scale.set(scale, scale, 1); requestAnimationFrame(animateWave); } else { // Clean up this.scene.remove(waveMesh); waveGeometry.dispose(); waveMaterial.dispose(); } }; animateWave(); // Add a burst of particles const particleCount = 30; const burstGeometry = new THREE.BufferGeometry(); const positions = new Float32Array(particleCount * 3); const velocities = new Array(particleCount).fill().map(() => new THREE.Vector3( (Math.random() - 0.5) * 5, Math.random() * 3 + 1, (Math.random() - 0.5) * 5 )); // Initial positions clustered at player position for (let i = 0; i < particleCount; i++) { positions[i * 3] = (Math.random() - 0.5) * 0.2; positions[i * 3 + 1] = Math.random() * 0.2; positions[i * 3 + 2] = (Math.random() - 0.5) * 0.2; } burstGeometry.setAttribute('position', new THREE.BufferAttribute(positions, 3)); const burstMaterial = new THREE.PointsMaterial({ color: 0x80FFFF, size: 0.08, transparent: true, opacity: 0.9, blending: THREE.AdditiveBlending, depthWrite: false }); const burstParticles = new THREE.Points(burstGeometry, burstMaterial); burstParticles.position.copy(this.mesh.position); this.scene.add(burstParticles); // Animate burst const animateBurst = () => { const elapsedMs = performance.now() - startTime; const normalizedTime = Math.min(elapsedMs / duration, 1.0); if (normalizedTime < 1.0) { const positions = burstGeometry.attributes.position.array; for (let i = 0; i < particleCount; i++) { const i3 = i * 3; // Apply velocity to position positions[i3] += velocities[i].x * 0.01; positions[i3 + 1] += velocities[i].y * 0.01; positions[i3 + 2] += velocities[i].z * 0.01; // Add gravity effect velocities[i].y -= 0.05; } burstGeometry.attributes.position.needsUpdate = true; // Fade out burstMaterial.opacity = 0.9 * (1.0 - normalizedTime); burstMaterial.size = 0.08 * (1.0 + normalizedTime); requestAnimationFrame(animateBurst); } else { // Clean up this.scene.remove(burstParticles); burstGeometry.dispose(); burstMaterial.dispose(); } }; animateBurst(); } // Spawn a plague strike effect spawnPlagueStrike() { if (!this.scene || !this.game) return; // Need scene and game for visual and collision detection console.log(`Player ${this.isLocalPlayer ? '1' : '2'} using Plague Strike!`); // Calculate forward direction const forward = new THREE.Vector3(0, 0, 1); forward.applyQuaternion(this.mesh.quaternion); // Calculate start position for the plague strike const startPosition = this.mesh.position.clone(); startPosition.y += this.constructor.PLAYER_HEIGHT_OFFSET; // Same height as player center // Create an instance of PlagueStrike const plagueStrike = new PlagueStrike( this.scene, startPosition, forward, () => { console.log("Plague Strike effect completed."); } ); // Add to game projectiles array for update loop if (this.game && this.game.projectiles) { this.game.projectiles.push(plagueStrike); } // Check for hit detection with plague strike setTimeout(() => { // Create a box for collision detection const strikeBox = new THREE.Box3().setFromCenterAndSize( plagueStrike.getPosition(), new THREE.Vector3(1.5, 1.5, 1.5) ); // Check against other players this.game.players.forEach(otherPlayer => { // Ensure target isn't self, is loaded, has health, and has a model if (otherPlayer !== this && otherPlayer.modelLoaded && otherPlayer.currentHealth > 0 && otherPlayer.model) { const targetBox = new THREE.Box3().setFromObject(otherPlayer.model, true); // Check for intersection if (strikeBox.intersectsBox(targetBox)) { console.log(`Plague Strike hit ${otherPlayer.isLocalPlayer ? 'local' : 'remote'} player!`); // Apply base damage otherPlayer.takeDamage(15); // 15 damage as specified in skill description // Apply defense reduction status effect otherPlayer.applyStatusEffect({ type: 'defensereduction', duration: 4, // 4 seconds of defense reduction speedMultiplier: 1.0, // Not slowing them down defenseMultiplier: 0.75 // 25% defense reduction (0.75 = 75% of normal) }); // Apply poison effect after a short delay setTimeout(() => { // Apply poison status effect (similar to bleed but with green visual) otherPlayer.applyStatusEffect({ type: 'poison', duration: 6, // 6 seconds of poison tickInterval: 1.0, // Damage every 1 second damagePerTick: 2, // 2 damage per tick (less than bleed) lastTickTime: otherPlayer.game.clock.elapsedTime // Start ticking immediately }); console.log(`Applied Poison effect from Plague Strike to ${otherPlayer.isLocalPlayer ? 'local' : 'remote'} player!`); }, 200); // 200ms delay before poison starts } } }); }, 150); // Delay for hitbox check in milliseconds } // Spawn a poison strike cone effect spawnPoisonStrike() { if (!this.scene || !this.game) return; // Need scene and game for visual and collision detection console.log(`Player ${this.isLocalPlayer ? '1' : '2'} using Poison Strike!`); // Calculate forward direction const forward = new THREE.Vector3(0, 0, 1); forward.applyQuaternion(this.mesh.quaternion); // Calculate start position for the poison strike const startPosition = this.mesh.position.clone(); startPosition.y += this.constructor.PLAYER_HEIGHT_OFFSET; // Same height as player center // Add a small offset in the forward direction to position the strike better const forwardOffset = forward.clone().multiplyScalar(0.5); startPosition.add(forwardOffset); // Create a new PoisonStrike instance from our PoisonStrike.js const poisonStrike = new PoisonStrike( this.scene, startPosition, forward, () => { console.log("Poison Strike effect completed."); } ); // Add to game projectiles array for update loop if (this.game && this.game.projectiles) { this.game.projectiles.push(poisonStrike); } // Add visual green line effect (similar to Puncture) // Find a better offset for the mage's staff position - higher and to the side const handOffset = new THREE.Vector3(0.4, 1.1, 0.6); const localHandOffset = handOffset.clone(); localHandOffset.applyQuaternion(this.mesh.quaternion); // Create a helper group for positioning const visualGroup = new THREE.Group(); this.scene.add(visualGroup); visualGroup.position.copy(startPosition); visualGroup.quaternion.copy(this.mesh.quaternion); visualGroup.position.add(localHandOffset); // Create a green cone to represent the poison strike const coneLength = 3.0; const coneRadius = 0.7; const coneGeometry = new THREE.ConeGeometry(coneRadius, coneLength, 16, 1, false); // Create a material with a pulsing green glow const coneMaterial = new THREE.ShaderMaterial({ uniforms: { time: { value: 0 }, color1: { value: new THREE.Color(0x00FF00) }, // Bright green color2: { value: new THREE.Color(0x008800) } // Darker green }, vertexShader: ` varying vec2 vUv; void main() { vUv = uv; gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0); } `, fragmentShader: ` uniform float time; uniform vec3 color1; uniform vec3 color2; varying vec2 vUv; void main() { float pulse = sin(time * 10.0) * 0.5 + 0.5; vec3 finalColor = mix(color1, color2, pulse); // Add edge effect float edge = smoothstep(0.0, 0.4, 1.0 - length(vUv - vec2(0.5, 0.5))); gl_FragColor = vec4(finalColor, 0.7 * edge); } `, transparent: true, side: THREE.DoubleSide }); const coneMesh = new THREE.Mesh(coneGeometry, coneMaterial); // Rotate cone to point forward coneMesh.rotation.x = Math.PI / 2; coneMesh.position.z = coneLength / 2; // Position the cone so its base is at the origin visualGroup.add(coneMesh); // Add particle system for poison effect const particleCount = 50; const particleGeometry = new THREE.BufferGeometry(); const particlePositions = new Float32Array(particleCount * 3); for (let i = 0; i < particleCount; i++) { // Random positions within the cone shape const radius = Math.random() * coneRadius * (1 - (i / particleCount)); // Narrower toward the tip const theta = Math.random() * Math.PI * 2; const distance = Math.random() * coneLength; particlePositions[i * 3] = radius * Math.cos(theta); particlePositions[i * 3 + 1] = radius * Math.sin(theta); particlePositions[i * 3 + 2] = distance; } particleGeometry.setAttribute('position', new THREE.BufferAttribute(particlePositions, 3)); const particleMaterial = new THREE.PointsMaterial({ color: 0x00FF44, size: 0.08, transparent: true, opacity: 0.7, blending: THREE.AdditiveBlending }); const particles = new THREE.Points(particleGeometry, particleMaterial); particles.rotation.x = Math.PI / 2; // Align with the cone visualGroup.add(particles); // Animate the effect let elapsedTime = 0; const duration = 0.75; // Match PoisonStrike duration const animateEffect = () => { elapsedTime += 0.016; // ~60fps if (elapsedTime < duration) { // Update shader time for pulsing effect if (coneMaterial.uniforms) { coneMaterial.uniforms.time.value = elapsedTime; } // Particle animation particles.rotation.z += 0.03; // Request next frame requestAnimationFrame(animateEffect); } else { // Clean up visual effects this.scene.remove(visualGroup); // Dispose geometries and materials coneGeometry.dispose(); coneMaterial.dispose(); particleGeometry.dispose(); particleMaterial.dispose(); } }; // Start animation animateEffect(); // Check for hit detection with poison strike setTimeout(() => { // Create a more appropriate hitbox for the poison strike cone // Get cone position in world space const conePosition = new THREE.Vector3(); visualGroup.getWorldPosition(conePosition); // Calculate forward direction again to make sure it's current const poisonForward = forward.clone(); // Extend the hitbox forward along the player's facing direction // This better matches the visual appearance of the cone attack const extendedPosition = conePosition.clone().add(poisonForward.clone().multiplyScalar(coneLength * 0.6)); // Create a larger, more forward-positioned hitbox that extends beyond the visual cone const strikeBox = new THREE.Box3(); const hitboxSize = new THREE.Vector3(coneRadius * 3.0, coneRadius * 3.0, coneLength * 1.8); strikeBox.setFromCenterAndSize(extendedPosition, hitboxSize); // Check against other players this.game.players.forEach(otherPlayer => { // Ensure target isn't self, is loaded, has health, and has a model if (otherPlayer !== this && otherPlayer.modelLoaded && otherPlayer.currentHealth > 0 && otherPlayer.model) { const targetBox = new THREE.Box3().setFromObject(otherPlayer.model, true); // Check for intersection if (strikeBox.intersectsBox(targetBox)) { console.log(`Poison Strike hit ${otherPlayer.isLocalPlayer ? 'local' : 'remote'} player!`); // Apply minimal base damage - poison is the main feature otherPlayer.takeDamage(5); // Reduced from 12 to 5 - just enough to notice the hit // Apply stronger poison effect instead otherPlayer.applyStatusEffect({ type: 'poison', duration: 8, // Increased from 5 to 8 seconds tickInterval: 1.0, // Damage every 1 second damagePerTick: 3, // Increased from 2 to 3 damage per tick lastTickTime: otherPlayer.game.clock.elapsedTime // Start ticking immediately }); console.log(`Applied Poison effect from Poison Strike to ${otherPlayer.isLocalPlayer ? 'local' : 'remote'} player!`); } } }); }, 150); // Delay for hitbox check in milliseconds } // Clear any stealth effects on dispose dispose() { // Remove player mesh from scene if (this.mesh.parent) { this.mesh.parent.remove(this.mesh); } // Dispose health bar if (this.healthBar) { this.healthBar.dispose(); this.healthBar = null; } // Dispose particles if (this.emberParticles) { this.emberParticles.dispose(); this.emberParticles = null; } // Stop animations and remove listeners if (this.mixer) { this.mixer.stopAllAction(); // Consider removing event listeners if any were added directly to the mixer } // Ensure all stealth effects are cleaned up this.cancelShroudEffect(); // Clone blink stealth cancellation removed } }