feat(shaman): add shaman enemy type with fireball + teleport; refactor enemy typing; improve visuals, aim, and portal FX\n\n- Add shaman enemy (hood, cape, staff, glowing eyes)\n- Fireball projectile: glow, ring, light, flicker; faster speed\n- Aim fix: target camera, update world matrices, prevent reversed shots\n- Teleport: more frequent, portal FX at depart/arrive\n- Refactor enemies to be type-aware (orc/shaman)\n- Waves: spawn 1 shaman per wave\n- Track player velocity for future prediction\n- Add portal FX system

README.md

@@ -25,3 +25,26 @@ Performance tips:
 - Lower `grassPerChunk` and/or increase `chunkSize` if GPU load is high.
 - Keep rocks/bush counts modest; they cast shadows by default.
 - Grass and flowers don’t receive/cast shadows for cheaper fills.
+
+## Performance and Tuning
+
+This pass focused on removing CPU spikes in later waves and reducing GPU shadow/render cost. Key changes:
+
+- Spatial grid for tree colliders drastically reduces O(N) scans for player/enemy movement and projectile collisions.
+- Enemy line-of-sight checks are throttled (~0.3s) and now use cheap math instead of `THREE.Raycaster` on hundreds of meshes.
+- Foliage no longer casts shadows (still receives), and enemy meshes don’t cast shadows to shrink shadow passes.
+- Shadow maps: sun maps reduced to 1024, moon and flashlight shadows disabled (big win on laptops/low-end GPUs).
+- Render pixel ratio capped at 1.0 and shadow filter uses `PCFShadowMap` (cheaper than soft PCF).
+- Lightweight FPS display added (top-right) to verify gains.
+
+If you still need more headroom:
+
+- Lower `CFG.waves.maxAlive` from 30 → 24 for fewer concurrent enemies.
+- Lower `CFG.flashlight.intensity` and/or keep it off at night (press `F`).
+- Reduce `CLOUDS.count` or disable clouds/mountains in `src/config.js`.
+- Reduce `CFG.forestSize` or `CFG.treeCount` for fewer blockers.
+
+Notes:
+
+- All removed geometry from enemies/FX is properly disposed to avoid GPU memory leaks.
+- The LOS heuristic also samples terrain height to prevent shooting through hills without expensive raycasts.

index.html

@@ -152,6 +152,10 @@
         <div class="label">ENEMIES</div>
         <div class="value" id="enemies">0</div>
       </div>
+      <div class="mini-card">
+        <div class="label">FPS</div>
+        <div class="value" id="fps">-</div>
+      </div>
     </div>
 
     <!-- Health Bottom-Left -->

src/combat.js

@@ -53,15 +53,17 @@ export function performShooting(delta) {
     G.raycaster.setFromCamera(TMP2, G.camera);
     G.raycaster.far = CFG.gun.range;
 
-    // Build hit list without creating new arrays
+    // Build hit list using lightweight proxies and trunk-only blockers
     HIT_OBJECTS.length = 0;
     for (let i = 0; i < G.enemies.length; i++) {
       const e = G.enemies[i];
-      if (e.alive) HIT_OBJECTS.push(e.mesh);
+      if (!e.alive || !e.hitProxies) continue;
+      // push proxies directly; no recursion needed
+      for (let k = 0; k < e.hitProxies.length; k++) HIT_OBJECTS.push(e.hitProxies[k]);
     }
     for (let i = 0; i < G.blockers.length; i++) HIT_OBJECTS.push(G.blockers[i]);
 
-    const hits = G.raycaster.intersectObjects(HIT_OBJECTS, true);
+    const hits = G.raycaster.intersectObjects(HIT_OBJECTS, false);
 
     G.weapon.muzzle.getWorldPosition(TMPv1);
 

src/config.js

@@ -61,6 +61,16 @@ export const CFG = {
     arrowLife: 6,
     arrowHitRadius: 0.6
   },
+  // Shaman-specific tuning
+  shaman: {
+    // Fireball slightly slower than orc arrow (40)
+    fireballSpeed: 42,
+    fireballDamage: 60,
+    fireballLife: 5,
+    fireballHitRadius: 0.9,
+    teleportCooldown: 6,
+    teleportDistance: 12
+  },
   gun: {
     // Faster, closer to AK full-auto feel (~600 RPM is 10 RPS)
     rof: 10.5,

src/enemies.js

@@ -1,9 +1,9 @@
 import * as THREE from 'three';
 import { CFG } from './config.js';
 import { G } from './globals.js';
-import { getTerrainHeight } from './world.js';
-import { spawnMuzzleFlashAt, spawnDustAt } from './fx.js';
-import { spawnEnemyArrow } from './projectiles.js';
+import { getTerrainHeight, getNearbyTrees, hasLineOfSight } from './world.js';
+import { spawnMuzzleFlashAt, spawnDustAt, spawnPortalAt } from './fx.js';
+import { spawnEnemyArrow, spawnEnemyFireball } from './projectiles.js';
 
 // Reusable temps
 const TMPv1 = new THREE.Vector3();
@@ -28,6 +28,11 @@ const MAT = {
 const RIVET_MAT = new THREE.MeshStandardMaterial({ color: 0xb0b4b8, metalness: 0.8, roughness: 0.3 });
 const STRING_MAT = new THREE.LineBasicMaterial({ color: 0xffffff });
 
+// Invisible low-poly hit proxies to reduce raycast CPU on shots
+const PROXY_MAT = new THREE.MeshBasicMaterial({ visible: false });
+const PROXY_HEAD = new THREE.SphereGeometry(0.32, 10, 8);
+const PROXY_BODY = new THREE.CapsuleGeometry(0.45, 0.6, 6, 8);
+
 function ballisticVelocity(start, target, speed, gravity, preferHigh = false) {
   const disp = TMPv1.subVectors(target, start);
   const dxz = Math.hypot(disp.x, disp.z);
@@ -47,7 +52,7 @@ function ballisticVelocity(start, target, speed, gravity, preferHigh = false) {
   return hdir.multiplyScalar(vxz).add(TMPv3.set(0, vy, 0));
 }
 
-export function spawnEnemy() {
+export function spawnEnemy(type = 'orc') {
   // Spawn near a single wave anchor, not around center
   const halfSize = CFG.forestSize / 2;
   const anchor = G.waves.spawnAnchor || new THREE.Vector3(
@@ -67,6 +72,139 @@ export function spawnEnemy() {
     if (Math.abs(x) > halfSize || Math.abs(z) > halfSize) return;
   }
 
+  if (type === 'shaman') {
+    // Create shaman: red with a cape, fires fireballs and teleports
+    const enemyGroup = new THREE.Group();
+
+    const skin = MAT.skin;
+    const robe = new THREE.MeshStandardMaterial({ color: 0x6f0c0c, roughness: 0.9 });
+    const capeMat = new THREE.MeshStandardMaterial({ color: 0xcc2222, roughness: 0.95 });
+
+    // Torso and head
+    const torso = new THREE.Mesh(new THREE.BoxGeometry(0.75, 1.15, 0.45), robe);
+    torso.position.set(0, 1.3, 0);
+    torso.castShadow = false; torso.receiveShadow = true;
+    enemyGroup.add(torso);
+
+    const head = new THREE.Mesh(new THREE.SphereGeometry(0.3, 12, 10), skin);
+    head.position.set(0, 1.95, 0);
+    head.castShadow = false; head.receiveShadow = true;
+    enemyGroup.add(head);
+
+    // Hood (larger dome over head, dark red)
+    const hoodMat = new THREE.MeshStandardMaterial({ color: 0x4d0909, roughness: 0.95 });
+    const hood = new THREE.Mesh(new THREE.SphereGeometry(0.42, 12, 10), hoodMat);
+    hood.scale.y = 0.7; hood.position.set(0, 2.03, 0);
+    hood.castShadow = false; hood.receiveShadow = true;
+    enemyGroup.add(hood);
+
+    // Glowing eyes
+    const eyeMat = new THREE.MeshStandardMaterial({ color: 0x550000, emissive: 0xff2200, emissiveIntensity: 1.2 });
+    const eyeL = new THREE.Mesh(new THREE.SphereGeometry(0.05, 8, 6), eyeMat);
+    eyeL.position.set(-0.1, 1.98, -0.25);
+    const eyeR = new THREE.Mesh(new THREE.SphereGeometry(0.05, 8, 6), eyeMat);
+    eyeR.position.set(0.1, 1.98, -0.25);
+    enemyGroup.add(eyeL); enemyGroup.add(eyeR);
+
+    // Simple arms
+    const armL = new THREE.Mesh(new THREE.BoxGeometry(0.18, 0.55, 0.18), robe);
+    armL.position.set(-0.5, 1.35, 0);
+    armL.castShadow = false; enemyGroup.add(armL);
+    const armR = new THREE.Mesh(new THREE.BoxGeometry(0.18, 0.55, 0.18), robe);
+    armR.position.set(0.5, 1.35, 0);
+    armR.castShadow = false; enemyGroup.add(armR);
+
+    // Legs
+    const legL = new THREE.Mesh(new THREE.BoxGeometry(0.22, 0.75, 0.24), robe);
+    legL.position.set(-0.22, 0.5, 0);
+    legL.castShadow = false; enemyGroup.add(legL);
+    const legR = new THREE.Mesh(new THREE.BoxGeometry(0.22, 0.75, 0.24), robe);
+    legR.position.set(0.22, 0.5, 0);
+    legR.castShadow = false; enemyGroup.add(legR);
+
+    // Cape (thin panel on back)
+    const cape = new THREE.Mesh(new THREE.BoxGeometry(0.9, 1.3, 0.04), capeMat);
+    cape.position.set(0, 1.18, 0.30);
+    cape.castShadow = false; cape.receiveShadow = true;
+    enemyGroup.add(cape);
+
+    // Staff held forward in right hand with glowing tip
+    const staffGroup = new THREE.Group();
+    const staff = new THREE.Mesh(new THREE.CylinderGeometry(0.05, 0.06, 1.6, 8), new THREE.MeshStandardMaterial({ color: 0x3b2b1b, roughness: 0.9 }));
+    staff.position.set(0, 0.8, 0);
+    const orb = new THREE.Mesh(new THREE.SphereGeometry(0.16, 12, 10), new THREE.MeshStandardMaterial({ color: 0xff4a1d, emissive: 0xff2200, emissiveIntensity: 1.5 }));
+    orb.position.set(0, 1.6 * 0.5 + 0.16, 0);
+    staffGroup.add(staff);
+    staffGroup.add(orb);
+    staffGroup.position.set(0.42, 1.2, -0.25);
+    staffGroup.rotation.x = -0.3; staffGroup.rotation.y = 0.1;
+    enemyGroup.add(staffGroup);
+
+    // Fireball spawn point at the orb tip
+    const projectileSpawn = new THREE.Object3D();
+    projectileSpawn.position.set(0, 1.6 * 0.5 + 0.16, 0);
+    staffGroup.add(projectileSpawn);
+
+    enemyGroup.position.set(x, getTerrainHeight(x, z), z);
+    G.scene.add(enemyGroup);
+
+    // Invisible hit proxies
+    const proxyHead = new THREE.Mesh(PROXY_HEAD, PROXY_MAT);
+    proxyHead.position.set(0, 1.95, 0);
+    proxyHead.userData = { enemy: null, hitZone: 'head' };
+    enemyGroup.add(proxyHead);
+    const proxyBody = new THREE.Mesh(PROXY_BODY, PROXY_MAT);
+    proxyBody.position.set(0, 1.3, 0);
+    proxyBody.userData = { enemy: null, hitZone: 'body' };
+    enemyGroup.add(proxyBody);
+
+    // Tag (only proxies are raycasted)
+    torso.userData = { enemy: null, hitZone: 'body' };
+    head.userData = { enemy: null, hitZone: 'head' };
+    armL.userData = { enemy: null, hitZone: 'limb' };
+    armR.userData = { enemy: null, hitZone: 'limb' };
+    legL.userData = { enemy: null, hitZone: 'limb' };
+    legR.userData = { enemy: null, hitZone: 'limb' };
+
+    const enemy = {
+      type: 'shaman',
+      mesh: enemyGroup,
+      body: torso,
+      pos: enemyGroup.position,
+      radius: CFG.enemy.radius,
+      hp: CFG.enemy.hp,
+      baseSpeed: CFG.enemy.baseSpeed + CFG.enemy.speedPerWave * (G.waves.current - 1),
+      damagePerSecond: CFG.enemy.dps,
+      alive: true,
+      deathTimer: 0,
+      projectileSpawn,
+      shootCooldown: 0,
+      helmet: null,
+      helmetAttached: false,
+      // LOS throttling
+      losTimer: 0,
+      hasLOS: true,
+      hitProxies: [],
+      // Teleport ability
+      teleTimer: CFG.shaman.teleportCooldown * (0.6 + G.random() * 0.8)
+    };
+
+    enemyGroup.userData = { enemy };
+    torso.userData.enemy = enemy;
+    head.userData.enemy = enemy;
+    armL.userData.enemy = enemy;
+    armR.userData.enemy = enemy;
+    legL.userData.enemy = enemy;
+    legR.userData.enemy = enemy;
+    proxyHead.userData.enemy = enemy;
+    proxyBody.userData.enemy = enemy;
+    enemy.hitProxies.push(proxyBody, proxyHead);
+
+    G.enemies.push(enemy);
+    G.waves.aliveCount++;
+    return;
+  }
+
   // Create enemy mesh (orc with cute helmet + bow)
   const enemyGroup = new THREE.Group();
 
@@ -80,7 +218,7 @@ export function spawnEnemy() {
   // Torso (bulky base under armor)
   const torso = new THREE.Mesh(new THREE.BoxGeometry(0.8, 1.1, 0.4), tunic);
   torso.position.set(0, 1.3, 0);
-  torso.castShadow = true; torso.receiveShadow = true;
+  torso.castShadow = false; torso.receiveShadow = true;
   enemyGroup.add(torso);
 
   // Silver armor: keep back plate + pauldrons; remove front plate for subtler look
@@ -88,7 +226,7 @@ export function spawnEnemy() {
   {
     const backPlate = new THREE.Mesh(new THREE.BoxGeometry(0.86, 0.58, 0.10), metal);
     backPlate.position.set(0, 1.34, 0.26);
-    backPlate.castShadow = true; backPlate.receiveShadow = true;
+    backPlate.castShadow = false; backPlate.receiveShadow = true;
     backPlate.userData = { enemy: null, hitZone: 'body' };
     enemyGroup.add(backPlate); armorPieces.push(backPlate);
 
@@ -96,21 +234,21 @@ export function spawnEnemy() {
     const pauldronGeo = new THREE.SphereGeometry(0.27, 12, 10);
     const pL = new THREE.Mesh(pauldronGeo, silver);
     pL.scale.y = 0.6; pL.position.set(-0.52, 1.62, -0.02);
-    pL.castShadow = true; pL.receiveShadow = true; pL.userData = { enemy: null, hitZone: 'body' };
+    pL.castShadow = false; pL.receiveShadow = true; pL.userData = { enemy: null, hitZone: 'body' };
     enemyGroup.add(pL); armorPieces.push(pL);
     const pR = new THREE.Mesh(pauldronGeo, silver);
     pR.scale.y = 0.6; pR.position.set(0.52, 1.62, -0.02);
-    pR.castShadow = true; pR.receiveShadow = true; pR.userData = { enemy: null, hitZone: 'body' };
+    pR.castShadow = false; pR.receiveShadow = true; pR.userData = { enemy: null, hitZone: 'body' };
     enemyGroup.add(pR); armorPieces.push(pR);
 
     // Leather belt with a simple metal buckle
     const belt = new THREE.Mesh(new THREE.TorusGeometry(0.36, 0.04, 8, 20), leather);
     belt.rotation.x = Math.PI / 2; belt.position.set(0, 1.0, 0);
-    belt.castShadow = true; belt.receiveShadow = true; belt.userData = { enemy: null, hitZone: 'body' };
+    belt.castShadow = false; belt.receiveShadow = true; belt.userData = { enemy: null, hitZone: 'body' };
     enemyGroup.add(belt); armorPieces.push(belt);
     const buckle = new THREE.Mesh(new THREE.BoxGeometry(0.16, 0.12, 0.03), metal);
     buckle.position.set(0, 1.0, -0.34);
-    buckle.castShadow = true; buckle.receiveShadow = true; buckle.userData = { enemy: null, hitZone: 'body' };
+    buckle.castShadow = false; buckle.receiveShadow = true; buckle.userData = { enemy: null, hitZone: 'body' };
     enemyGroup.add(buckle); armorPieces.push(buckle);
 
     // Small rivets on back plate corners only
@@ -122,7 +260,7 @@ export function spawnEnemy() {
     for (const pos of rivets) {
       const r = new THREE.Mesh(rivetGeo, RIVET_MAT);
       r.position.copy(pos);
-      r.castShadow = true; r.receiveShadow = true; r.userData = { enemy: null, hitZone: 'body' };
+      r.castShadow = false; r.receiveShadow = true; r.userData = { enemy: null, hitZone: 'body' };
       enemyGroup.add(r); armorPieces.push(r);
     }
   }
@@ -130,13 +268,13 @@ export function spawnEnemy() {
   // Head (slightly larger) + cute helmet (small dome)
   const head = new THREE.Mesh(new THREE.SphereGeometry(0.3, 12, 10), skin);
   head.position.set(0, 1.95, 0);
-  head.castShadow = true; head.receiveShadow = true;
+  head.castShadow = false; head.receiveShadow = true;
   enemyGroup.add(head);
 
   const helmet = new THREE.Mesh(new THREE.SphereGeometry(0.33, 12, 10), metal);
   helmet.scale.y = 0.7;
   helmet.position.set(0, 2.07, 0);
-  helmet.castShadow = true; helmet.receiveShadow = true;
+  helmet.castShadow = false; helmet.receiveShadow = true;
   // Tag helmet as a head hit zone so headshots register even when helmet is hit
   helmet.userData = { enemy: null, hitZone: 'head', isHelmet: true };
   enemyGroup.add(helmet);
@@ -144,20 +282,20 @@ export function spawnEnemy() {
   // Arms
   const armL = new THREE.Mesh(new THREE.BoxGeometry(0.18, 0.55, 0.18), tunic);
   armL.position.set(-0.5, 1.35, 0);
-  armL.castShadow = true; enemyGroup.add(armL);
+  armL.castShadow = false; enemyGroup.add(armL);
 
   const armR = new THREE.Mesh(new THREE.BoxGeometry(0.18, 0.55, 0.18), tunic);
   armR.position.set(0.5, 1.35, 0);
-  armR.castShadow = true; enemyGroup.add(armR);
+  armR.castShadow = false; enemyGroup.add(armR);
 
   // Legs
   const legL = new THREE.Mesh(new THREE.BoxGeometry(0.24, 0.75, 0.24), pants);
   legL.position.set(-0.22, 0.5, 0);
-  legL.castShadow = true; enemyGroup.add(legL);
+  legL.castShadow = false; enemyGroup.add(legL);
 
   const legR = new THREE.Mesh(new THREE.BoxGeometry(0.24, 0.75, 0.24), pants);
   legR.position.set(0.22, 0.5, 0);
-  legR.castShadow = true; enemyGroup.add(legR);
+  legR.castShadow = false; enemyGroup.add(legR);
 
   // Bow (curved torus segment + string) held slightly forward on left side
   const bowGroup = new THREE.Group();
@@ -185,6 +323,16 @@ export function spawnEnemy() {
   enemyGroup.position.set(x, getTerrainHeight(x, z), z);
   G.scene.add(enemyGroup);
 
+  // Add invisible hit proxies (head + body) for fast ray hits
+  const proxyHead = new THREE.Mesh(PROXY_HEAD, PROXY_MAT);
+  proxyHead.position.set(0, 1.95, 0);
+  proxyHead.userData = { enemy: null, hitZone: 'head' };
+  enemyGroup.add(proxyHead);
+  const proxyBody = new THREE.Mesh(PROXY_BODY, PROXY_MAT);
+  proxyBody.position.set(0, 1.3, 0);
+  proxyBody.userData = { enemy: null, hitZone: 'body' };
+  enemyGroup.add(proxyBody);
+
   // Tag hit zones for headshot logic
   torso.userData = { enemy: null, hitZone: 'body' };
   head.userData = { enemy: null, hitZone: 'head' };
@@ -193,8 +341,11 @@ export function spawnEnemy() {
   legL.userData = { enemy: null, hitZone: 'limb' };
   legR.userData = { enemy: null, hitZone: 'limb' };
   bow.userData = { enemy: null, hitZone: 'gear' };
+  proxyHead.userData.enemy = null; // will assign below
+  proxyBody.userData.enemy = null;
 
   const enemy = {
+    type: 'orc',
     mesh: enemyGroup,
     body: torso,
     pos: enemyGroup.position,
@@ -207,7 +358,11 @@ export function spawnEnemy() {
     projectileSpawn,
     shootCooldown: 0,
     helmet,
-    helmetAttached: true
+    helmetAttached: true,
+    // LOS throttling to avoid per-frame raycasting
+    losTimer: 0,
+    hasLOS: true,
+    hitProxies: []
   };
 
   enemyGroup.userData = { enemy };
@@ -219,6 +374,9 @@ export function spawnEnemy() {
   legR.userData.enemy = enemy;
   bow.userData.enemy = enemy;
   helmet.userData.enemy = enemy;
+  proxyHead.userData.enemy = enemy;
+  proxyBody.userData.enemy = enemy;
+  enemy.hitProxies.push(proxyBody, proxyHead);
   // Assign enemy to armor pieces so they count as body hits
   for (const part of armorPieces) {
     if (part && part.userData) part.userData.enemy = enemy;
@@ -236,9 +394,11 @@ export function updateEnemies(delta, onPlayerDeath) {
     if (!enemy.alive) {
       // Spawn a quick dust puff at death position, then despawn
       spawnDustAt(enemy.pos);
+      // Defer geometry disposal to avoid frame spikes
       enemy.mesh.traverse((obj) => {
-        if (obj.isMesh && obj.geometry && obj.geometry.dispose) {
-          obj.geometry.dispose();
+        if (obj.isMesh && obj.geometry) {
+          G.disposeQueue.push(obj.geometry);
+          obj.geometry = null;
         }
       });
       G.scene.remove(enemy.mesh);
@@ -256,8 +416,10 @@ export function updateEnemies(delta, onPlayerDeath) {
       const moveSpeed = enemy.baseSpeed * delta;
       enemy.pos.add(dir.multiplyScalar(moveSpeed));
 
-      // Simple tree avoidance
-      for (const tree of G.treeColliders) {
+      // Simple tree avoidance (use spatial grid)
+      const nearby = getNearbyTrees(enemy.pos.x, enemy.pos.z, 4);
+      for (let ti = 0; ti < nearby.length; ti++) {
+        const tree = nearby[ti];
         const dx = enemy.pos.x - tree.x;
         const dz = enemy.pos.z - tree.z;
         const treeDist = Math.sqrt(dx * dx + dz * dz);
@@ -280,38 +442,46 @@ export function updateEnemies(delta, onPlayerDeath) {
 
     // Ranged conditions
     if (dist < CFG.enemy.range && enemy.alive) {
-      // LOS check against trees/ground
-      ORIGIN.set(enemy.pos.x, 1.6, enemy.pos.z);
-      TO_PLAYER.subVectors(G.player.pos, ORIGIN);
-      const distanceToPlayer = TO_PLAYER.length();
-      TO_PLAYER.normalize();
-
-      G.raycaster.set(ORIGIN, TO_PLAYER);
-      G.raycaster.far = distanceToPlayer;
-      const hits = G.raycaster.intersectObjects(G.blockers, true);
-      const hasBlocker = hits.length > 0;
-
-      if (!hasBlocker && enemy.shootCooldown <= 0) {
-
-        // Aim with bloom + ballistic compensation; shoot an arrow
-        const spread = CFG.enemy.bloom;
-        if (enemy.projectileSpawn) enemy.projectileSpawn.getWorldPosition(START); else START.copy(ORIGIN);
-
-        TARGET.set(G.player.pos.x, G.player.pos.y - 0.2, G.player.pos.z);
-        // Add small random jitter to target for bloom
-        TARGET.x += (G.random() - 0.5) * spread * 20;
-        TARGET.y += (G.random() - 0.5) * spread * 8;
-        TARGET.z += (G.random() - 0.5) * spread * 20;
-
-        // If too far for this speed/gravity, don't waste a shot
-        const dxz = Math.hypot(TARGET.x - START.x, TARGET.z - START.z);
-        const maxRangeFlat = (CFG.enemy.arrowSpeed * CFG.enemy.arrowSpeed) / CFG.enemy.arrowGravity;
-        if (dxz <= maxRangeFlat * 0.98) {
-          let vel = ballisticVelocity(START, TARGET, CFG.enemy.arrowSpeed, CFG.enemy.arrowGravity, false);
-          if (vel) {
-            enemy.shootCooldown = 1 / CFG.enemy.rof;
-            spawnEnemyArrow(START, vel, true);
-            spawnMuzzleFlashAt(START, 0xffc080);
+      // Throttled line-of-sight check using fast approximations
+      enemy.losTimer -= delta;
+      if (enemy.losTimer <= 0) {
+        ORIGIN.set(enemy.pos.x, 1.6, enemy.pos.z);
+        enemy.hasLOS = hasLineOfSight(ORIGIN, G.player.pos);
+        enemy.losTimer = 0.28 + G.random() * 0.18;
+      }
+
+      if (enemy.hasLOS && enemy.shootCooldown <= 0) {
+        // Ensure world matrices reflect current enemy position before sampling spawn
+        enemy.mesh.updateMatrixWorld(true);
+        if (enemy.type === 'shaman') {
+          // Fireball: aim directly toward camera position (robust), no wobble
+          if (enemy.projectileSpawn) enemy.projectileSpawn.getWorldPosition(START); else START.copy(ORIGIN);
+          TARGET.copy(G.camera.position);
+          const dir = TMPv2.subVectors(TARGET, START).normalize();
+          enemy.shootCooldown = 1 / CFG.enemy.rof;
+          spawnEnemyFireball(START, dir, false);
+          spawnMuzzleFlashAt(START, 0xff5a22);
+        } else {
+          // Archer orc: ballistic arrow
+          const spread = CFG.enemy.bloom;
+          if (enemy.projectileSpawn) enemy.projectileSpawn.getWorldPosition(START); else START.copy(ORIGIN);
+
+          TARGET.set(G.player.pos.x, G.player.pos.y - 0.2, G.player.pos.z);
+          // Add small random jitter to target for bloom
+          TARGET.x += (G.random() - 0.5) * spread * 20;
+          TARGET.y += (G.random() - 0.5) * spread * 8;
+          TARGET.z += (G.random() - 0.5) * spread * 20;
+
+          // If too far for this speed/gravity, don't waste a shot
+          const dxz = Math.hypot(TARGET.x - START.x, TARGET.z - START.z);
+          const maxRangeFlat = (CFG.enemy.arrowSpeed * CFG.enemy.arrowSpeed) / CFG.enemy.arrowGravity;
+          if (dxz <= maxRangeFlat * 0.98) {
+            let vel = ballisticVelocity(START, TARGET, CFG.enemy.arrowSpeed, CFG.enemy.arrowGravity, false);
+            if (vel) {
+              enemy.shootCooldown = 1 / CFG.enemy.rof;
+              spawnEnemyArrow(START, vel, true);
+              spawnMuzzleFlashAt(START, 0xffc080);
+            }
           }
         }
       }
@@ -329,6 +499,46 @@ export function updateEnemies(delta, onPlayerDeath) {
       }
     }
 
+    // Shaman teleport ability (periodic)
+    if (enemy.type === 'shaman') {
+      enemy.teleTimer -= delta;
+      if (enemy.teleTimer <= 0) {
+        enemy.teleTimer = CFG.shaman.teleportCooldown * (0.85 + G.random() * 0.3);
+        // Attempt to teleport closer towards player by ~distance
+        const dirTo = TO_PLAYER.copy(G.player.pos).sub(enemy.pos);
+        dirTo.y = 0;
+        const dlen = dirTo.length();
+        if (dlen > 1) {
+          dirTo.normalize();
+          let tdist = CFG.shaman.teleportDistance;
+          // Don't teleport into the player's radius
+          if (dlen - tdist < (G.player.radius + enemy.radius + 2)) {
+            tdist = Math.max(0, dlen - (G.player.radius + enemy.radius + 2));
+          }
+          const nx = enemy.pos.x + dirTo.x * tdist;
+          const nz = enemy.pos.z + dirTo.z * tdist;
+          // Simple tree clash check
+          const trees = getNearbyTrees(nx, nz, 3);
+          let blocked = false;
+          for (let ti = 0; ti < trees.length; ti++) {
+            const tr = trees[ti];
+            const dx = nx - tr.x; const dz = nz - tr.z;
+            const rr = tr.radius + enemy.radius * 0.8;
+            if (dx * dx + dz * dz < rr * rr) { blocked = true; break; }
+          }
+          if (!blocked) {
+            // Portal and dust at departure
+            spawnPortalAt(enemy.pos, 0xff5522, 1.0, 0.32);
+            spawnDustAt(enemy.pos, 0x9c3322, 0.7, 0.18);
+            enemy.pos.set(nx, getTerrainHeight(nx, nz), nz);
+            // Portal and dust at arrival
+            spawnPortalAt(enemy.pos, 0xff5522, 1.1, 0.36);
+            spawnDustAt(enemy.pos, 0xcc4422, 0.9, 0.22);
+          }
+        }
+      }
+    }
+
     // Look at player
     enemy.mesh.lookAt(G.player.pos.x, enemy.pos.y + 1.4, G.player.pos.z);
   }

src/fx.js

@@ -81,6 +81,30 @@ export function spawnDustAt(worldPos, color = 0xcdbf9e, size = 0.55, life = 0.14
   G.fx.dusts.push({ mesh: quad, life, maxLife: life });
 }
 
+// Portal effect: additive ring that grows and fades, plus soft light
+export function spawnPortalAt(worldPos, color = 0xff5522, size = 1.1, life = 0.35) {
+  const ring = new THREE.Mesh(
+    new THREE.TorusGeometry(size * 0.35, size * 0.08, 12, 28),
+    new THREE.MeshBasicMaterial({ color, transparent: true, opacity: 0.95, blending: THREE.AdditiveBlending, depthWrite: false })
+  );
+  ring.position.copy(worldPos);
+  ring.rotation.x = Math.PI / 2;
+  ring.renderOrder = 12;
+  const flare = new THREE.Mesh(
+    new THREE.PlaneGeometry(size * 0.9, size * 0.9),
+    new THREE.MeshBasicMaterial({ color, transparent: true, opacity: 0.6, blending: THREE.AdditiveBlending, depthWrite: false })
+  );
+  flare.position.copy(worldPos);
+  flare.lookAt(G.camera.position);
+  flare.renderOrder = 12;
+  const light = new THREE.PointLight(color, 5, size * 6, 2);
+  light.position.copy(worldPos);
+  G.scene.add(ring);
+  G.scene.add(flare);
+  G.scene.add(light);
+  G.fx.portals.push({ ring, flare, light, life, maxLife: life, rot: Math.random() * Math.PI * 2 });
+}
+
 export function updateFX(delta) {
   for (let i = G.fx.tracers.length - 1; i >= 0; i--) {
     const t = G.fx.tracers[i];
@@ -134,4 +158,29 @@ export function updateFX(delta) {
       G.fx.dusts.splice(i, 1);
     }
   }
+  // Portals
+  for (let i = G.fx.portals.length - 1; i >= 0; i--) {
+    const p = G.fx.portals[i];
+    p.life -= delta;
+    const t = Math.max(0, p.life / p.maxLife);
+    const s = 1 + (1 - t) * 1.6;
+    p.rot += delta * 4;
+    p.ring.rotation.z = p.rot;
+    p.ring.material.opacity = 0.25 + 0.7 * t;
+    p.ring.scale.setScalar(s);
+    p.flare.material.opacity = 0.15 + 0.45 * t;
+    p.flare.scale.setScalar(s * 1.2);
+    if (p.light) p.light.intensity = 2 + 8 * t;
+    p.flare.lookAt(G.camera.position);
+    if (p.life <= 0) {
+      G.scene.remove(p.ring);
+      G.scene.remove(p.flare);
+      if (p.light) G.scene.remove(p.light);
+      p.ring.geometry.dispose();
+      p.flare.geometry.dispose();
+      if (p.ring.material && p.ring.material.dispose) p.ring.material.dispose();
+      if (p.flare.material && p.flare.material.dispose) p.flare.material.dispose();
+      G.fx.portals.splice(i, 1);
+    }
+  }
 }

src/globals.js

@@ -38,6 +38,10 @@ export const G = {
   enemies: [],
   treeColliders: [],
   treeMeshes: [],
+  // Subset of meshes used for bullet blocking (trunks only)
+  treeTrunks: [],
+  // Spatial index for trees to accelerate queries
+  treeGrid: null,
   // Static blockers array for raycasting (ground + trees)
   blockers: [],
 
@@ -69,7 +73,7 @@ export const G = {
     appliedYaw: 0
   },
 
-  fx: { tracers: [], impacts: [], flashes: [], dusts: [] },
+  fx: { tracers: [], impacts: [], flashes: [], dusts: [], portals: [] },
   enemyProjectiles: [],
   // Health orbs and other pickups
   orbs: [],
@@ -79,6 +83,8 @@ export const G = {
   helmets: [],
   damageFlash: 0,
   healFlash: 0,
+  // Deferred GPU resource disposal queue to avoid frame spikes
+  disposeQueue: [],
 
   waves: {
     current: 1,
@@ -87,7 +93,8 @@ export const G = {
     nextSpawnTimer: 0,
     breakTimer: 0,
     inBreak: false,
-    spawnAnchor: null
+    spawnAnchor: null,
+    shamansToSpawn: 0
   },
 
   random: null,

src/lighting.js

@@ -38,8 +38,8 @@ export function setupLights() {
   sun.shadow.camera.bottom = -60;
   sun.shadow.camera.near = 0.1;
   sun.shadow.camera.far = 240;
-  sun.shadow.mapSize.width = 2048;
-  sun.shadow.mapSize.height = 2048;
+  sun.shadow.mapSize.width = 1024;
+  sun.shadow.mapSize.height = 1024;
   sun.target = new THREE.Object3D();
   G.scene.add(sun);
   G.scene.add(sun.target);
@@ -48,15 +48,8 @@ export function setupLights() {
   // Moon light (key during night)
   const moon = new THREE.DirectionalLight(0x6a8fc5, 0.8);
   moon.position.set(50, 80, -50);
-  moon.castShadow = true;
-  moon.shadow.camera.left = -60;
-  moon.shadow.camera.right = 60;
-  moon.shadow.camera.top = 60;
-  moon.shadow.camera.bottom = -60;
-  moon.shadow.camera.near = 0.1;
-  moon.shadow.camera.far = 240;
-  moon.shadow.mapSize.width = 2048;
-  moon.shadow.mapSize.height = 2048;
+  // Disable moon shadows to reduce shadow pass cost
+  moon.castShadow = false;
   moon.target = new THREE.Object3D();
   G.scene.add(moon);
   G.scene.add(moon.target);
@@ -86,9 +79,8 @@ export function setupLights() {
   flashlight.penumbra = 0.2;
   flashlight.distance = CFG.flashlight.distance;
   flashlight.decay = 1.5;
-  flashlight.castShadow = true;
-  flashlight.shadow.mapSize.width = 2048;
-  flashlight.shadow.mapSize.height = 2048;
+  // Flashlight shadowing is expensive; disable for performance
+  flashlight.castShadow = false;
   flashlight.shadow.camera.near = 0.1;
   flashlight.shadow.camera.far = CFG.flashlight.distance;
   flashlight.visible = CFG.flashlight.on;

src/main.js

@@ -28,9 +28,11 @@ function init() {
   // Renderer
   G.renderer = new THREE.WebGLRenderer({ antialias: true });
   G.renderer.setSize(window.innerWidth, window.innerHeight);
-  G.renderer.setPixelRatio(Math.min(window.devicePixelRatio, 1.5));
+  // Lower pixel ratio cap for significant fill-rate savings
+  G.renderer.setPixelRatio(Math.min(window.devicePixelRatio, 1.0));
   G.renderer.shadowMap.enabled = true;
-  G.renderer.shadowMap.type = THREE.PCFSoftShadowMap;
+  // Slightly cheaper shadow filter
+  G.renderer.shadowMap.type = THREE.PCFShadowMap;
   document.body.appendChild(G.renderer.domElement);
 
   // Scene
@@ -199,4 +201,25 @@ function animate() {
   tickForest(G.clock.elapsedTime);
 
   G.renderer.render(G.scene, G.camera);
+
+  // Lightweight FPS meter (updates ~2x/sec)
+  if (!G._fpsAccum) { G._fpsAccum = 0; G._fpsFrames = 0; G._fpsNext = 0.5; }
+  G._fpsAccum += delta; G._fpsFrames++;
+  if (G._fpsAccum >= G._fpsNext) {
+    const fps = Math.round(G._fpsFrames / G._fpsAccum);
+    const el = document.getElementById('fps');
+    if (el) el.textContent = String(fps);
+    G._fpsAccum = 0; G._fpsFrames = 0;
+  }
+
+  // Process a small budget of deferred disposals to avoid spikes
+  if (G.disposeQueue && G.disposeQueue.length) {
+    const budget = 24; // dispose up to N geometries per frame
+    for (let i = 0; i < budget && G.disposeQueue.length; i++) {
+      const geom = G.disposeQueue.pop();
+      if (geom && geom.dispose) {
+        try { geom.dispose(); } catch (e) { /* noop */ }
+      }
+    }
+  }
 }

src/pickups.js

@@ -3,7 +3,7 @@ import { G } from './globals.js';
 import { CFG } from './config.js';
 import { getTerrainHeight } from './world.js';
 
-// Share orb material to avoid per-orb material allocations
+// Share orb material/geometry to avoid per-orb allocations
 const ORB_MAT = new THREE.MeshStandardMaterial({
   color: 0x33ff66,
   emissive: 0x1faa4e,
@@ -11,6 +11,7 @@ const ORB_MAT = new THREE.MeshStandardMaterial({
   roughness: 0.3,
   metalness: 0.0
 });
+const ORB_GEO = new THREE.SphereGeometry(0.12, 14, 12);
 
 // Spawns N small glowing green health orbs around a position
 export function spawnHealthOrbs(center, count) {
@@ -28,7 +29,7 @@ export function spawnHealthOrbs(center, count) {
       center.z + Math.sin(t) * r
     );
 
-    const sphere = new THREE.Mesh(new THREE.SphereGeometry(0.12, 14, 12), ORB_MAT);
+    const sphere = new THREE.Mesh(ORB_GEO, ORB_MAT);
     sphere.castShadow = true;
     sphere.receiveShadow = false;
     group.add(sphere);

src/player.js

@@ -1,12 +1,13 @@
 import * as THREE from 'three';
 import { CFG } from './config.js';
 import { G } from './globals.js';
-import { getTerrainHeight } from './world.js';
+import { getTerrainHeight, getNearbyTrees } from './world.js';
 
 const MOVE = new THREE.Vector3();
 const FWD = new THREE.Vector3();
 const RIGHT = new THREE.Vector3();
 const NEXT = new THREE.Vector3();
+const PREV = new THREE.Vector3();
 
 export function updatePlayer(delta) {
   if (!G.player.alive) return;
@@ -34,13 +35,14 @@ export function updatePlayer(delta) {
   // Apply movement with collision
   NEXT.copy(G.player.pos).add(MOVE);
 
-  // Tree collisions
-  for (const tree of G.treeColliders) {
+  // Tree collisions (use spatial grid)
+  const nearTrees = getNearbyTrees(NEXT.x, NEXT.z, 3.5);
+  for (let i = 0; i < nearTrees.length; i++) {
+    const tree = nearTrees[i];
     const dx = NEXT.x - tree.x;
     const dz = NEXT.z - tree.z;
     const dist = Math.sqrt(dx * dx + dz * dz);
     const minDist = G.player.radius + tree.radius;
-
     if (dist < minDist && dist > 0) {
       const pushX = (dx / dist) * (minDist - dist);
       const pushZ = (dz / dist) * (minDist - dist);
@@ -68,6 +70,13 @@ export function updatePlayer(delta) {
     G.player.grounded = false;
   }
 
+  // Update velocity estimate (units/sec)
+  PREV.copy(G.player.pos);
   G.player.pos.copy(NEXT);
+  if (delta > 0) {
+    G.player.vel.copy(G.player.pos).sub(PREV).multiplyScalar(1 / delta);
+    // Ignore vertical component for prediction stability
+    G.player.vel.y = 0;
+  }
   G.camera.position.copy(G.player.pos);
 }

src/projectiles.js

@@ -1,8 +1,8 @@
 import * as THREE from 'three';
 import { CFG } from './config.js';
 import { G } from './globals.js';
-import { getTerrainHeight } from './world.js';
-import { spawnImpact } from './fx.js';
+import { getTerrainHeight, getNearbyTrees } from './world.js';
+import { spawnImpact, spawnMuzzleFlashAt } from './fx.js';
 
 // Shared arrow geometry/material to avoid per-shot allocations
 const ARROW = (() => {
@@ -13,6 +13,17 @@ const ARROW = (() => {
   return { shaftGeo, headGeo, shaftMat, headMat };
 })();
 
+// Shared fireball geometry/material (core + outer glow)
+const FIREBALL = (() => {
+  const coreGeo = new THREE.SphereGeometry(0.22, 16, 12);
+  const coreMat = new THREE.MeshStandardMaterial({ color: 0xff3b1d, emissive: 0xff2200, emissiveIntensity: 1.6, roughness: 0.55 });
+  const glowGeo = new THREE.SphereGeometry(0.36, 14, 12);
+  const glowMat = new THREE.MeshBasicMaterial({ color: 0xff6622, transparent: true, opacity: 0.9, blending: THREE.AdditiveBlending, depthWrite: false });
+  const ringGeo = new THREE.TorusGeometry(0.28, 0.04, 10, 24);
+  const ringMat = new THREE.MeshBasicMaterial({ color: 0xffaa55, transparent: true, opacity: 0.7, blending: THREE.AdditiveBlending, depthWrite: false });
+  return { coreGeo, coreMat, glowGeo, glowMat, ringGeo, ringMat };
+})();
+
 const UP = new THREE.Vector3(0, 1, 0);
 const TMPv = new THREE.Vector3();
 const TMPq = new THREE.Quaternion();
@@ -45,6 +56,7 @@ export function spawnEnemyArrow(start, dirOrVel, asVelocity = false) {
     : TMPv.copy(dirOrVel).normalize().multiplyScalar(speed);
 
   const projectile = {
+    kind: 'arrow',
     mesh: group,
     pos: group.position,
     vel,
@@ -54,15 +66,61 @@ export function spawnEnemyArrow(start, dirOrVel, asVelocity = false) {
   G.enemyProjectiles.push(projectile);
 }
 
+// Spawns a straight-traveling shaman fireball
+export function spawnEnemyFireball(start, dirOrVel, asVelocity = false) {
+  const speed = CFG.shaman.fireballSpeed;
+  // Visual group: core + additive glow + fiery ring + light
+  const group = new THREE.Group();
+  const core = new THREE.Mesh(FIREBALL.coreGeo, FIREBALL.coreMat);
+  const glow = new THREE.Mesh(FIREBALL.glowGeo, FIREBALL.glowMat);
+  const ring = new THREE.Mesh(FIREBALL.ringGeo, FIREBALL.ringMat);
+  ring.rotation.x = Math.PI / 2;
+  core.castShadow = true; core.receiveShadow = false;
+  glow.castShadow = false; glow.receiveShadow = false;
+  group.add(core);
+  group.add(glow);
+  group.add(ring);
+  const light = new THREE.PointLight(0xff5522, 7, 11, 2);
+  group.add(light);
+
+  group.position.copy(start);
+  G.scene.add(group);
+
+  // Compute velocity without aliasing TMP vectors
+  const velocity = asVelocity ? dirOrVel.clone() : dirOrVel.clone().normalize().multiplyScalar(speed);
+  // Safety: if somehow pointing away from camera, flip (prevents “opposite” shots)
+  const toCam = new THREE.Vector3().subVectors(G.camera.position, group.position).normalize();
+  if (velocity.clone().normalize().dot(toCam) < 0) velocity.multiplyScalar(-1);
+
+  // Orient to direction for consistency
+  const nd = velocity.clone().normalize();
+  TMPq.setFromUnitVectors(UP, nd);
+  group.quaternion.copy(TMPq);
+
+  const projectile = {
+    kind: 'fireball',
+    mesh: group,
+    pos: group.position,
+    vel: velocity,
+    life: CFG.shaman.fireballLife,
+    core,
+    glow,
+    ring,
+    light,
+    osc: Math.random() * Math.PI * 2
+  };
+
+  G.enemyProjectiles.push(projectile);
+}
+
 export function updateEnemyProjectiles(delta, onPlayerDeath) {
   const gravity = CFG.enemy.arrowGravity;
-  const hitR = CFG.enemy.arrowHitRadius;
 
   for (let i = G.enemyProjectiles.length - 1; i >= 0; i--) {
     const p = G.enemyProjectiles[i];
 
-    // Integrate
-    p.vel.y -= gravity * delta;
+    // Integrate (gravity only affects arrows)
+    if (p.kind === 'arrow') p.vel.y -= gravity * delta;
     p.pos.addScaledVector(p.vel, delta);
 
     // Re-orient to velocity
@@ -70,26 +128,39 @@ export function updateEnemyProjectiles(delta, onPlayerDeath) {
     TMPq.setFromUnitVectors(UP, vdir);
     p.mesh.quaternion.copy(TMPq);
 
+    // Fireball visual flicker
+    if (p.kind === 'fireball') {
+      p.osc += delta * 14;
+      const pulse = 1 + Math.sin(p.osc) * 0.18 + (Math.random() - 0.5) * 0.06;
+      p.mesh.scale.setScalar(pulse);
+      if (p.ring) p.ring.rotation.z += delta * 3;
+      if (p.glow) p.glow.material.opacity = 0.6 + Math.abs(Math.sin(p.osc * 1.3)) * 0.5;
+      if (p.light) p.light.intensity = 6 + Math.abs(Math.sin(p.osc * 2.1)) * 6;
+    }
     p.life -= delta;
 
-    // Ground hit against terrain
+    // Ground hit against terrain (fireballs usually won't arc down)
     const gy = getTerrainHeight(p.pos.x, p.pos.z);
     if (p.pos.y <= gy) {
       TMPv.set(p.pos.x, gy + 0.02, p.pos.z);
       spawnImpact(TMPv, UP);
+      if (p.kind === 'fireball') spawnMuzzleFlashAt(TMPv, 0xff5522);
       G.scene.remove(p.mesh);
       G.enemyProjectiles.splice(i, 1);
       continue;
     }
 
-    // Tree collision (2D cylinder test)
-    for (const tree of G.treeColliders) {
+    // Tree collision (2D cylinder test using spatial grid)
+    const nearTrees = getNearbyTrees(p.pos.x, p.pos.z, 3.5);
+    for (let ti = 0; ti < nearTrees.length; ti++) {
+      const tree = nearTrees[ti];
       const dx = p.pos.x - tree.x;
       const dz = p.pos.z - tree.z;
       const dist2 = dx * dx + dz * dz;
       const r = tree.radius + 0.2; // small allowance for arrow
       if (dist2 < r * r && p.pos.y < 8) { // below canopy-ish
         spawnImpact(p.pos, UP);
+        if (p.kind === 'fireball') spawnMuzzleFlashAt(p.pos, 0xff5522);
         G.scene.remove(p.mesh);
         G.enemyProjectiles.splice(i, 1);
         continue;
@@ -97,9 +168,10 @@ export function updateEnemyProjectiles(delta, onPlayerDeath) {
     }
 
     // Player collision (sphere)
+    const hitR = p.kind === 'arrow' ? CFG.enemy.arrowHitRadius : CFG.shaman.fireballHitRadius;
     const pr = hitR + G.player.radius * 0.6; // slightly generous
     if (p.pos.distanceTo(G.player.pos) < pr) {
-      const dmg = CFG.enemy.arrowDamage;
+      const dmg = p.kind === 'arrow' ? CFG.enemy.arrowDamage : CFG.shaman.fireballDamage;
       G.player.health -= dmg;
       G.damageFlash = Math.min(1, G.damageFlash + CFG.hud.damagePulsePerHit + dmg * CFG.hud.damagePulsePerHP);
       if (G.player.health <= 0 && G.player.alive) {
@@ -108,6 +180,7 @@ export function updateEnemyProjectiles(delta, onPlayerDeath) {
         if (onPlayerDeath) onPlayerDeath();
       }
       spawnImpact(p.pos, UP);
+      if (p.kind === 'fireball') spawnMuzzleFlashAt(p.pos, 0xff5522);
       G.scene.remove(p.mesh);
       G.enemyProjectiles.splice(i, 1);
       continue;

src/waves.js

@@ -12,6 +12,7 @@ export function startNextWave() {
   );
   G.waves.spawnQueue = waveCount;
   G.waves.nextSpawnTimer = 0;
+  G.waves.shamansToSpawn = 1; // exactly 1 shaman per wave
 
   // Choose a single spawn anchor for this wave (not near the center)
   const half = CFG.forestSize / 2;
@@ -42,7 +43,12 @@ export function updateWaves(delta) {
   if (G.waves.spawnQueue > 0 && G.waves.aliveCount < CFG.waves.maxAlive) {
     G.waves.nextSpawnTimer -= delta;
     if (G.waves.nextSpawnTimer <= 0) {
-      spawnEnemy();
+      if (G.waves.shamansToSpawn > 0) {
+        spawnEnemy('shaman');
+        G.waves.shamansToSpawn--;
+      } else {
+        spawnEnemy('orc');
+      }
       G.waves.spawnQueue--;
       const spawnRate = Math.max(
         CFG.waves.spawnMin,

src/world.js

@@ -758,8 +758,12 @@ export function setupGround() {
   G.scene.add(ground);
   G.ground = ground;
   // Keep blockers in sync if trees already exist
-  if (G.treeMeshes && Array.isArray(G.treeMeshes)) {
+  if (G.treeTrunks && Array.isArray(G.treeTrunks) && G.treeTrunks.length) {
+    G.blockers = [ground, ...G.treeTrunks];
+  } else if (G.treeMeshes && Array.isArray(G.treeMeshes) && G.treeMeshes.length) {
     G.blockers = [ground, ...G.treeMeshes];
+  } else {
+    G.blockers = [ground];
   }
 }
 
@@ -772,6 +776,8 @@ export function generateForest() {
 
   G.treeColliders.length = 0;
   G.treeMeshes.length = 0;
+  if (!G.treeTrunks) G.treeTrunks = [];
+  G.treeTrunks.length = 0;
 
   while (placed < CFG.treeCount && attempts < maxAttempts) {
     attempts++;
@@ -817,7 +823,8 @@ export function generateForest() {
     foliage2.scale.set(fScale, fScale, fScale);
     foliage3.scale.set(fScale, fScale, fScale);
     crown.scale.set(fScale, fScale, fScale);
-    foliage1.castShadow = foliage2.castShadow = foliage3.castShadow = crown.castShadow = true;
+    // Keep only trunk casting shadows; foliage receiving only to reduce shadow pass cost
+    foliage1.castShadow = foliage2.castShadow = foliage3.castShadow = crown.castShadow = false;
     foliage1.receiveShadow = foliage2.receiveShadow = foliage3.receiveShadow = crown.receiveShadow = true;
     tree.add(foliage1, foliage2, foliage3, crown);
 
@@ -828,6 +835,7 @@ export function generateForest() {
     tree.position.set(x, y, z);
     G.scene.add(tree);
     G.treeMeshes.push(tree);
+    G.treeTrunks.push(trunk);
 
     // Add collider roughly matching trunk base radius
     const trunkBaseRadius = 1.2 * s;
@@ -837,8 +845,120 @@ export function generateForest() {
   }
   // Update blockers list once trees are generated
   if (G.ground) {
-    G.blockers = [G.ground, ...G.treeMeshes];
+    G.blockers = [G.ground, ...G.treeTrunks];
   } else {
-    G.blockers = [...G.treeMeshes];
+    G.blockers = [...G.treeTrunks];
+  }
+  // Build spatial index for tree colliders to accelerate queries
+  buildTreeGrid();
+}
+
+// ---- Spatial index for tree colliders ----
+// Simple uniform grid over the world to reduce O(N) scans
+export function buildTreeGrid(cellSize = 12) {
+  const half = CFG.forestSize / 2;
+  const minX = -half, minZ = -half;
+  const cols = Math.max(1, Math.ceil(CFG.forestSize / cellSize));
+  const rows = Math.max(1, Math.ceil(CFG.forestSize / cellSize));
+  const cells = new Array(cols * rows);
+  for (let i = 0; i < cells.length; i++) cells[i] = [];
+  function cellIndex(ix, iz) { return iz * cols + ix; }
+  for (const t of G.treeColliders) {
+    const ix = Math.max(0, Math.min(cols - 1, Math.floor((t.x - minX) / cellSize)));
+    const iz = Math.max(0, Math.min(rows - 1, Math.floor((t.z - minZ) / cellSize)));
+    cells[cellIndex(ix, iz)].push(t);
+  }
+  G.treeGrid = { cellSize, minX, minZ, cols, rows, cells };
+}
+
+const _nearTrees = [];
+function clamp(v, a, b) { return v < a ? a : (v > b ? b : v); }
+
+// Gathers tree colliders around a point within a given radius (XZ plane)
+export function getNearbyTrees(x, z, radius = 4) {
+  _nearTrees.length = 0;
+  const grid = G.treeGrid;
+  if (!grid) return _nearTrees;
+  const { cellSize, minX, minZ, cols, rows, cells } = grid;
+  const r = Math.max(radius, 0);
+  const minIx = clamp(Math.floor((x - r - minX) / cellSize), 0, cols - 1);
+  const maxIx = clamp(Math.floor((x + r - minX) / cellSize), 0, cols - 1);
+  const minIz = clamp(Math.floor((z - r - minZ) / cellSize), 0, rows - 1);
+  const maxIz = clamp(Math.floor((z + r - minZ) / cellSize), 0, rows - 1);
+  for (let iz = minIz; iz <= maxIz; iz++) {
+    for (let ix = minIx; ix <= maxIx; ix++) {
+      const cell = cells[iz * cols + ix];
+      for (let k = 0; k < cell.length; k++) _nearTrees.push(cell[k]);
+    }
+  }
+  return _nearTrees;
+}
+
+const _aabbTrees = [];
+export function getTreesInAABB(minX, minZ, maxX, maxZ) {
+  _aabbTrees.length = 0;
+  const grid = G.treeGrid;
+  if (!grid) return _aabbTrees;
+  const { cellSize, minX: gx, minZ: gz, cols, rows, cells } = grid;
+  const minIx = clamp(Math.floor((minX - gx) / cellSize), 0, cols - 1);
+  const maxIx = clamp(Math.floor((maxX - gx) / cellSize), 0, cols - 1);
+  const minIz = clamp(Math.floor((minZ - gz) / cellSize), 0, rows - 1);
+  const maxIz = clamp(Math.floor((maxZ - gz) / cellSize), 0, rows - 1);
+  for (let iz = minIz; iz <= maxIz; iz++) {
+    for (let ix = minIx; ix <= maxIx; ix++) {
+      const cell = cells[iz * cols + ix];
+      for (let k = 0; k < cell.length; k++) _aabbTrees.push(cell[k]);
+    }
+  }
+  return _aabbTrees;
+}
+
+// Fast 2D segment-vs-circle test
+function segIntersectsCircle(x1, z1, x2, z2, cx, cz, r) {
+  const vx = x2 - x1, vz = z2 - z1;
+  const wx = cx - x1, wz = cz - z1;
+  const vv = vx * vx + vz * vz;
+  if (vv <= 1e-6) return false;
+  let t = (wx * vx + wz * vz) / vv;
+  if (t < 0) t = 0; else if (t > 1) t = 1;
+  const px = x1 + t * vx, pz = z1 + t * vz;
+  const dx = cx - px, dz = cz - pz;
+  return (dx * dx + dz * dz) <= r * r;
+}
+
+// Approximate line-of-sight using tree cylinders and terrain samples (no raycaster)
+export function hasLineOfSight(from, to) {
+  // Terrain occlusion: sample a few points along the ray
+  const steps = 6;
+  for (let i = 1; i < steps; i++) {
+    const t = i / steps;
+    const x = from.x + (to.x - from.x) * t;
+    const z = from.z + (to.z - from.z) * t;
+    const y = from.y + (to.y - from.y) * t;
+    const gy = getTerrainHeight(x, z) + 0.1;
+    if (y <= gy) return false;
+  }
+  // Tree occlusion using grid-restricted set
+  const minX = Math.min(from.x, to.x) - 2.0;
+  const maxX = Math.max(from.x, to.x) + 2.0;
+  const minZ = Math.min(from.z, to.z) - 2.0;
+  const maxZ = Math.max(from.z, to.z) + 2.0;
+  const candidates = getTreesInAABB(minX, minZ, maxX, maxZ);
+  for (let i = 0; i < candidates.length; i++) {
+    const t = candidates[i];
+    // Use a slightly inflated radius to account for foliage
+    const r = t.radius + 0.3;
+    if (segIntersectsCircle(from.x, from.z, to.x, to.z, t.x, t.z, r)) {
+      // If the segment is sufficiently high (e.g., arrow arc), allow pass
+      // Estimate height at closest approach t in [0,1]
+      const vx = to.x - from.x, vz = to.z - from.z;
+      const wx = t.x - from.x, wz = t.z - from.z;
+      const vv = vx * vx + vz * vz;
+      let u = (wx * vx + wz * vz) / (vv || 1);
+      if (u < 0) u = 0; else if (u > 1) u = 1;
+      const yAt = from.y + (to.y - from.y) * u;
+      if (yAt < 8) return false; // below canopy -> blocked
+    }
   }
+  return true;
 }