feat(enemies, waves): add golem enemy with specific behaviors, health orbs, and projectile mechanics

src/combat.js

@@ -156,8 +156,14 @@ export function performShooting(delta) {
           enemy.deathTimer = 0;
           G.waves.aliveCount--;
           G.player.score += isHead ? 15 : 10;
-          const cnt = 1 + Math.floor(G.random() * 5);
-          spawnHealthOrbs(enemy.pos, cnt);
+          // Drop more orbs for special enemies
+          if (enemy.type === 'golem') {
+            const cnt = 15 + Math.floor(G.random() * 6); // 15..20
+            spawnHealthOrbs(enemy.pos, cnt);
+          } else {
+            const cnt = 1 + Math.floor(G.random() * 5);
+            spawnHealthOrbs(enemy.pos, cnt);
+          }
         }
       } else if (firstHit.object !== G.ground) {
         const n = firstHit.face?.normal

src/config.js

@@ -104,6 +104,25 @@ export const CFG = {
     teleportCooldown: 6,
     teleportDistance: 12
   },
+  // Golem-specific tuning
+  golem: {
+    hp: 1000,             // 5x basic enemy (100)
+    radius: 1.8,         // bigger footprint
+    baseSpeed: 1.6,
+    speedPerWave: 0.10,
+    dps: 20,             // contact damage if you hug it
+    range: 90,
+    // Throwing
+    throwInterval: 1.8,  // seconds between throws
+    throwWindup: 0.40,
+    bloom: 0.01,
+    // Rock projectile
+    rockSpeed: 34,
+    rockGravity: 22,
+    rockDamage: 45,
+    rockLife: 7,
+    rockHitRadius: 0.9
+  },
   gun: {
     // Faster, closer to AK full-auto feel (~600 RPM is 10 RPS)
     rof: 10.5,

src/enemies.js

@@ -3,7 +3,7 @@ import { CFG } from './config.js';
 import { G } from './globals.js';
 import { getTerrainHeight, getNearbyTrees, hasLineOfSight } from './world.js';
 import { spawnMuzzleFlashAt, spawnDustAt, spawnPortalAt } from './fx.js';
-import { spawnEnemyArrow, spawnEnemyFireball } from './projectiles.js';
+import { spawnEnemyArrow, spawnEnemyFireball, spawnEnemyRock } from './projectiles.js';
 
 // Reusable temps
 const TMPv1 = new THREE.Vector3();
@@ -376,6 +376,178 @@ export function spawnEnemy(type = 'orc') {
     return;
   }
 
+  if (type === 'golem') {
+    // Blocky golem from simple boxes, with arm/leg pivots and a throw anchor
+    const golem = new THREE.Group();
+
+    // Materials inspired by the provided model
+    const iron = new THREE.MeshStandardMaterial({ color: 0xE0E0E0, roughness: 0.95, metalness: 0.05, flatShading: true });
+    const ironDark = new THREE.MeshStandardMaterial({ color: 0xCFCFCF, roughness: 0.95, metalness: 0.05, flatShading: true });
+    const woodish = new THREE.MeshStandardMaterial({ color: 0x8A6B58, roughness: 1.0, metalness: 0.0, flatShading: true });
+    const vine = new THREE.MeshStandardMaterial({ color: 0x2f8f38, roughness: 0.9, metalness: 0.0, flatShading: true });
+    const eyeMat = new THREE.MeshStandardMaterial({ color: 0x661c1c, emissive: 0x5b0a0a, emissiveIntensity: 0.9, roughness: 1.0, flatShading: true });
+
+    // Dimensions (scaled down later to match world scale)
+    const bodyW = 4.0, bodyH = 4.6, bodyD = 2.2;
+    const headW = 2.2, headH = 2.2, headD = 2.0;
+    const armW = 1.3, armD = 1.3, armL = 5.0;
+    const handW = 1.5, handH = 0.9, handD = 1.5;
+    const legW = 1.2, legD = 1.2, legH = 3.2;
+    const footW = 1.6, footD = 1.8, footH = 0.8;
+    const legGap = 0.6;
+    const legX = (legW + legGap) * 0.5;
+    const hipsY = footH + legH;
+
+    // Torso
+    const torso = new THREE.Mesh(new THREE.BoxGeometry(bodyW, bodyH, bodyD), iron);
+    torso.position.y = hipsY + bodyH * 0.5;
+    torso.castShadow = false; torso.receiveShadow = true;
+    golem.add(torso);
+
+    // Head pivot
+    const headPivot = new THREE.Group();
+    headPivot.position.set(0, hipsY + bodyH, 0);
+    golem.add(headPivot);
+
+    const head = new THREE.Mesh(new THREE.BoxGeometry(headW, headH, headD), ironDark);
+    head.position.y = headH * 0.5;
+    head.castShadow = false; head.receiveShadow = true;
+    headPivot.add(head);
+
+    const nose = new THREE.Mesh(new THREE.BoxGeometry(0.6, 0.6, 1.0), woodish);
+    nose.position.set(0, 0.2, headD * 0.5 + 0.5);
+    head.add(nose);
+
+    const eyeGeom = new THREE.BoxGeometry(0.35, 0.35, 0.12);
+    const leftEye = new THREE.Mesh(eyeGeom, eyeMat);
+    const rightEye = new THREE.Mesh(eyeGeom, eyeMat);
+    leftEye.position.set(-0.45, 0.55, headD * 0.5 + 0.07);
+    rightEye.position.set(0.45, 0.55, headD * 0.5 + 0.07);
+    head.add(leftEye, rightEye);
+
+    // Shoulders
+    const shoulderY = hipsY + bodyH - 0.2;
+    const shoulderX = bodyW * 0.5 + armW * 0.5 - 0.1;
+
+    function buildArm(sign = 1) {
+      const pivot = new THREE.Group();
+      pivot.position.set(sign * shoulderX, shoulderY, 0);
+      golem.add(pivot);
+      const arm = new THREE.Mesh(new THREE.BoxGeometry(armW, armL, armD), iron);
+      arm.position.y = -armL * 0.5;
+      arm.castShadow = false; arm.receiveShadow = true;
+      pivot.add(arm);
+      const hand = new THREE.Mesh(new THREE.BoxGeometry(handW, handH, handD), ironDark);
+      hand.position.y = -armL * 0.5 - handH * 0.5;
+      arm.add(hand);
+      const creeper1 = new THREE.Mesh(new THREE.BoxGeometry(0.12, 1.3, 0.10), vine);
+      creeper1.position.set(sign * 0.35, -0.8, armD * 0.5 + 0.06);
+      arm.add(creeper1);
+      // Return pivots plus a handle to hand for projectile spawn anchor
+      return { pivot, arm, hand };
+    }
+
+    const leftArm = buildArm(-1);
+    const rightArm = buildArm(1);
+
+    // Rock spawn anchor at right hand
+    const projectileSpawn = new THREE.Object3D();
+    projectileSpawn.position.set(0, -armL * 0.5 - handH, 0);
+    rightArm.arm.add(projectileSpawn);
+
+    function buildLeg(sign = 1) {
+      const pivot = new THREE.Group();
+      pivot.position.set(sign * legX, hipsY, 0);
+      golem.add(pivot);
+      const leg = new THREE.Mesh(new THREE.BoxGeometry(legW, legH, legD), iron);
+      leg.position.y = -legH * 0.5;
+      leg.castShadow = false; leg.receiveShadow = true;
+      pivot.add(leg);
+      const foot = new THREE.Mesh(new THREE.BoxGeometry(footW, footH, footD), ironDark);
+      foot.position.y = -legH * 0.5 - footH * 0.5;
+      leg.add(foot);
+      return { pivot, leg };
+    }
+
+    const leftLeg = buildLeg(-1);
+    const rightLeg = buildLeg(1);
+
+    // A few vines on torso & leg
+    function addVine(target, x, y, z, h) {
+      const strip = new THREE.Mesh(new THREE.BoxGeometry(0.14, h, 0.12), vine);
+      strip.position.set(x, y, z);
+      strip.castShadow = false; strip.receiveShadow = true;
+      target.add(strip);
+    }
+    addVine(torso, 0.9,  0.3,  bodyD * 0.5 + 0.07, 2.2);
+    addVine(torso, -0.2, -0.7, bodyD * 0.5 + 0.07, 1.6);
+    addVine(leftLeg.leg, -0.3, -0.2, legD * 0.5 + 0.07, 1.8);
+
+    // Scale to world; triple the previous size
+    const scale = 0.66; // 3x bigger than before
+    golem.scale.setScalar(scale);
+
+    // Place in world
+    golem.position.set(x, getTerrainHeight(x, z), z);
+    G.scene.add(golem);
+
+    // Hit proxies: scale-compensated so they remain hittable in world units
+    const proxyHead = new THREE.Mesh(PROXY_HEAD, PROXY_MAT);
+    const proxyBody = new THREE.Mesh(PROXY_BODY, PROXY_MAT);
+    headPivot.add(proxyHead);
+    torso.add(proxyBody);
+    const inv = 1 / scale;
+    // Scale proxies up so hits match the larger body
+    const proxyScale = inv * 3.0;
+    proxyHead.scale.setScalar(proxyScale);
+    proxyBody.scale.setScalar(proxyScale);
+    proxyHead.userData = { enemy: null, hitZone: 'head' };
+    proxyBody.userData = { enemy: null, hitZone: 'body' };
+
+    const enemy = {
+      type: 'golem',
+      mesh: golem,
+      body: torso,
+      pos: golem.position,
+      radius: CFG.golem?.radius ?? 1.2,
+      hp: (CFG.golem?.hp ?? 260),
+      baseSpeed: (CFG.golem?.baseSpeed ?? 1.7) + (CFG.golem?.speedPerWave ?? 0.12) * (G.waves.current - 1),
+      damagePerSecond: CFG.golem?.dps ?? CFG.enemy.dps,
+      alive: true,
+      deathTimer: 0,
+      projectileSpawn,
+      shootCooldown: 0,
+      helmet: null,
+      helmetAttached: false,
+      // LOS throttling
+      losTimer: 0,
+      hasLOS: true,
+      hitProxies: [],
+      // Anim state
+      animT: 0,
+      headPivot,
+      armL: leftArm?.pivot,
+      armR: rightArm?.pivot,
+      legL: leftLeg?.pivot,
+      legR: rightLeg?.pivot,
+      // Throw state
+      throwing: false,
+      throwTimer: 0,
+      throwSpawned: false
+    };
+
+    golem.userData = { enemy };
+    torso.userData = { enemy, hitZone: 'body' };
+    head.userData = { enemy, hitZone: 'head' };
+    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();
 
@@ -616,7 +788,8 @@ export function updateEnemies(delta, onPlayerDeath) {
     }
 
     // Ranged conditions
-    if (dist < CFG.enemy.range && enemy.alive && enemy.type !== 'wolf') {
+    const rangedRange = (enemy.type === 'golem') ? (CFG.golem?.range ?? CFG.enemy.range) : CFG.enemy.range;
+    if (dist < rangedRange && enemy.alive && enemy.type !== 'wolf') {
       // Throttled line-of-sight check using fast approximations
       enemy.losTimer -= delta;
       if (enemy.losTimer <= 0) {
@@ -636,6 +809,13 @@ export function updateEnemies(delta, onPlayerDeath) {
           enemy.shootCooldown = 1 / CFG.enemy.rof;
           spawnEnemyFireball(START, dir, false);
           spawnMuzzleFlashAt(START, 0xff5a22);
+        } else if (enemy.type === 'golem') {
+          // Begin a throw sequence; spawn occurs at windup time via anim block
+          enemy.throwing = true;
+          enemy.throwTimer = 0;
+          enemy.throwSpawned = false;
+          // Longer interval between throws
+          enemy.shootCooldown = (CFG.golem?.throwInterval ?? 1.6);
         } else {
           // Archer orc: ballistic arrow
           const spread = CFG.enemy.bloom;
@@ -785,6 +965,63 @@ export function updateEnemies(delta, onPlayerDeath) {
         // reset
         enemy.muzzlePivot.position.z = enemy.muzzleBase || 1.5;
       }
+    } else if (enemy.type === 'golem') {
+      // Heavy, slower gait
+      enemy.animT += delta * Math.max(0.6, enemy.baseSpeed * 0.6);
+      const t = enemy.animT;
+      const swing = Math.sin(t * 1.2) * 0.32;
+      const counter = Math.sin(t * 1.2 + Math.PI) * 0.32;
+      if (!enemy.throwing) {
+        if (enemy.armL) enemy.armL.rotation.x = swing * 0.9;
+        if (enemy.armR) enemy.armR.rotation.x = counter * 0.9;
+      }
+      if (enemy.legL) enemy.legL.rotation.x = counter * 0.5;
+      if (enemy.legR) enemy.legR.rotation.x = swing * 0.5;
+      if (enemy.headPivot) enemy.headPivot.rotation.x = Math.sin(t * 2.0) * 0.05;
+      // Throw animation: windup then release
+      if (enemy.throwing && enemy.armR) {
+        const wind = CFG.golem?.throwWindup ?? 0.4;
+        enemy.throwTimer += delta;
+        const u = Math.min(1, enemy.throwTimer / Math.max(0.001, wind));
+        const back = -1.3; // windup angle
+        const fwd = 0.6;   // follow-through
+        if (enemy.throwTimer < wind) {
+          // Ease to windup back
+          const e = u * (2 - u);
+          enemy.armR.rotation.x = back * e;
+        } else {
+          // After windup, snap forward quickly
+          const k = Math.min(1, (enemy.throwTimer - wind) / 0.18);
+          enemy.armR.rotation.x = back + (fwd - back) * (k * (2 - k));
+        }
+
+        // Spawn rock at windup moment
+        if (!enemy.throwSpawned && enemy.throwTimer >= wind) {
+          const spread = (CFG.golem?.bloom ?? 0.01);
+          if (enemy.projectileSpawn) enemy.projectileSpawn.getWorldPosition(START); else START.set(enemy.pos.x, enemy.pos.y + 2.2, enemy.pos.z);
+          TARGET.set(G.player.pos.x, G.player.pos.y + 0.2, G.player.pos.z);
+          TARGET.x += (G.random() - 0.5) * spread * 20;
+          TARGET.y += (G.random() - 0.5) * spread * 8;
+          TARGET.z += (G.random() - 0.5) * spread * 20;
+          const vel = (function() {
+            // Reuse ballistic helper using golem settings
+            const speed = CFG.golem?.rockSpeed ?? CFG.enemy.arrowSpeed;
+            const grav = CFG.golem?.rockGravity ?? CFG.enemy.arrowGravity;
+            return (ballisticVelocity(START, TARGET, speed, grav, false));
+          })();
+          if (vel) {
+            spawnEnemyRock(START, vel, true);
+            spawnMuzzleFlashAt(START, 0xb0b0b0);
+          }
+          enemy.throwSpawned = true;
+        }
+        // End throw shortly after
+        if (enemy.throwTimer >= wind + 0.32) {
+          enemy.throwing = false;
+          enemy.throwTimer = 0;
+          enemy.throwSpawned = false;
+        }
+      }
     }
   }
 }

src/globals.js

@@ -105,7 +105,8 @@ export const G = {
     inBreak: false,
     spawnAnchor: null,
     shamansToSpawn: 0,
-    wolvesToSpawn: 0
+    wolvesToSpawn: 0,
+    golemsToSpawn: 0
   },
 
   random: null,

src/grenades.js

@@ -160,8 +160,12 @@ function explodeAt(position) {
         G.waves.aliveCount--;
         // Award score like a body kill
         G.player.score += 10;
-        // Modest heals
-        spawnHealthOrbs(e.pos, 1 + Math.floor(G.random() * 3));
+        // Heals: larger drop for golems
+        if (e.type === 'golem') {
+          spawnHealthOrbs(e.pos, 15 + Math.floor(G.random() * 6)); // 15..20
+        } else {
+          spawnHealthOrbs(e.pos, 1 + Math.floor(G.random() * 3));
+        }
       }
     }
   }

src/main.js

@@ -170,6 +170,8 @@ function startGame() {
   G.waves.breakTimer = 0;
   G.waves.inBreak = false;
   G.waves.wolvesToSpawn = 0;
+  G.waves.shamansToSpawn = 0;
+  G.waves.golemsToSpawn = 0;
 
   // Reset weapon
   G.weapon.ammo = CFG.gun.magSize;

src/pickups.js

@@ -12,7 +12,8 @@ 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) {
-  const n = Math.max(1, Math.min(5, Math.floor(count)));
+  // Allow larger drops (e.g., golem 15–20); cap to keep it reasonable
+  const n = Math.max(1, Math.min(30, Math.floor(count)));
   for (let i = 0; i < n; i++) {
     const group = new THREE.Group();
 

src/projectiles.js

@@ -27,6 +27,12 @@ const FIREBALL = (() => {
 const UP = new THREE.Vector3(0, 1, 0);
 const TMPv = new THREE.Vector3();
 const TMPq = new THREE.Quaternion();
+// Shared jagged rock geometry/material
+const ROCK = (() => {
+  const geo = new THREE.DodecahedronGeometry(0.6, 0);
+  const mat = new THREE.MeshStandardMaterial({ color: 0x9a9a9a, roughness: 1.0, metalness: 0.0 });
+  return { geo, mat };
+})();
 
 // Spawns a visible enemy arrow projectile
 export function spawnEnemyArrow(start, dirOrVel, asVelocity = false) {
@@ -112,14 +118,46 @@ export function spawnEnemyFireball(start, dirOrVel, asVelocity = false) {
   G.enemyProjectiles.push(projectile);
 }
 
+// Spawns a heavy arcing rock projectile
+export function spawnEnemyRock(start, dirOrVel, asVelocity = false) {
+  const speed = CFG.golem?.rockSpeed ?? 30;
+  const group = new THREE.Group();
+  const rock = new THREE.Mesh(ROCK.geo, ROCK.mat);
+  rock.castShadow = true; rock.receiveShadow = true;
+  group.add(rock);
+
+  // Orientation based on throw direction
+  const nd = dirOrVel.clone();
+  if (!asVelocity) nd.normalize();
+  TMPq.setFromUnitVectors(UP, nd.clone().normalize());
+  group.quaternion.copy(TMPq);
+
+  group.position.copy(start);
+  G.scene.add(group);
+
+  const vel = asVelocity
+    ? dirOrVel.clone()
+    : nd.normalize().multiplyScalar(speed);
+
+  const projectile = {
+    kind: 'rock',
+    mesh: group,
+    pos: group.position,
+    vel,
+    life: CFG.golem?.rockLife ?? 6
+  };
+  G.enemyProjectiles.push(projectile);
+}
+
 export function updateEnemyProjectiles(delta, onPlayerDeath) {
   const gravity = CFG.enemy.arrowGravity;
 
   for (let i = G.enemyProjectiles.length - 1; i >= 0; i--) {
     const p = G.enemyProjectiles[i];
 
-    // Integrate (gravity only affects arrows)
+    // Integrate gravity by projectile kind
     if (p.kind === 'arrow') p.vel.y -= gravity * delta;
+    else if (p.kind === 'rock') p.vel.y -= (CFG.golem?.rockGravity ?? gravity) * delta;
     p.pos.addScaledVector(p.vel, delta);
 
     // Re-orient to velocity
@@ -144,6 +182,7 @@ export function updateEnemyProjectiles(delta, onPlayerDeath) {
       TMPv.set(p.pos.x, gy + 0.02, p.pos.z);
       spawnImpact(TMPv, UP);
       if (p.kind === 'fireball') spawnMuzzleFlashAt(TMPv, 0xff5522);
+      if (p.kind === 'rock') spawnMuzzleFlashAt(TMPv, 0xb0b0b0);
       G.scene.remove(p.mesh);
       G.enemyProjectiles.splice(i, 1);
       continue;
@@ -156,10 +195,12 @@ export function updateEnemyProjectiles(delta, onPlayerDeath) {
       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
+      const pad = p.kind === 'rock' ? 0.6 : 0.2; // rocks are bulkier
+      const r = tree.radius + pad;
       if (dist2 < r * r && p.pos.y < 8) { // below canopy-ish
         spawnImpact(p.pos, UP);
         if (p.kind === 'fireball') spawnMuzzleFlashAt(p.pos, 0xff5522);
+        if (p.kind === 'rock') spawnMuzzleFlashAt(p.pos, 0xb0b0b0);
         G.scene.remove(p.mesh);
         G.enemyProjectiles.splice(i, 1);
         continue;
@@ -167,10 +208,18 @@ export function updateEnemyProjectiles(delta, onPlayerDeath) {
     }
 
     // Player collision (sphere)
-    const hitR = p.kind === 'arrow' ? CFG.enemy.arrowHitRadius : CFG.shaman.fireballHitRadius;
+    const hitR = (
+      p.kind === 'arrow' ? CFG.enemy.arrowHitRadius :
+      p.kind === 'fireball' ? CFG.shaman.fireballHitRadius :
+      CFG.golem?.rockHitRadius ?? 0.9
+    );
     const pr = hitR + G.player.radius * 0.6; // slightly generous
     if (p.pos.distanceTo(G.player.pos) < pr) {
-      const dmg = p.kind === 'arrow' ? CFG.enemy.arrowDamage : CFG.shaman.fireballDamage;
+      const dmg = (
+        p.kind === 'arrow' ? CFG.enemy.arrowDamage :
+        p.kind === 'fireball' ? CFG.shaman.fireballDamage :
+        CFG.golem?.rockDamage ?? 40
+      );
       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) {
@@ -180,6 +229,7 @@ export function updateEnemyProjectiles(delta, onPlayerDeath) {
       }
       spawnImpact(p.pos, UP);
       if (p.kind === 'fireball') spawnMuzzleFlashAt(p.pos, 0xff5522);
+      if (p.kind === 'rock') spawnMuzzleFlashAt(p.pos, 0xb0b0b0);
       G.scene.remove(p.mesh);
       G.enemyProjectiles.splice(i, 1);
       continue;

src/waves.js

@@ -15,6 +15,7 @@ export function startNextWave() {
   G.waves.nextSpawnTimer = 0;
   G.waves.shamansToSpawn = 1; // exactly 1 shaman per wave
   G.waves.wolvesToSpawn = 2;  // exactly 2 wolves per wave
+  G.waves.golemsToSpawn = 1;  // exactly 1 golem per wave
 
   // Choose a single spawn anchor for this wave (not near the center)
   const half = CFG.forestSize / 2;
@@ -48,7 +49,10 @@ export function updateWaves(delta) {
   if (G.waves.spawnQueue > 0 && G.waves.aliveCount < CFG.waves.maxAlive) {
     G.waves.nextSpawnTimer -= delta;
     if (G.waves.nextSpawnTimer <= 0) {
-      if (G.waves.shamansToSpawn > 0) {
+      if (G.waves.golemsToSpawn > 0) {
+        spawnEnemy('golem');
+        G.waves.golemsToSpawn--;
+      } else if (G.waves.shamansToSpawn > 0) {
         spawnEnemy('shaman');
         G.waves.shamansToSpawn--;
       } else if (G.waves.wolvesToSpawn > 0) {