Spaces:

victor
/

orcs-in-the-forest

Running

App Files Files Community

Codex CLI commited on 1 day ago

Commit

1390db3

0 Parent(s):

Initial commit: Orcs In The Forest

Browse files

Files changed (29) hide show

.gitignore +34 -0
README.md +27 -0
bun.lock +29 -0
index.html +198 -0
index.ts +1 -0
package.json +12 -0
src/audio.js +165 -0
src/casings.js +131 -0
src/clouds.js +183 -0
src/combat.js +132 -0
src/config.js +182 -0
src/daynight.js +123 -0
src/enemies.js +335 -0
src/events.js +101 -0
src/fx.js +137 -0
src/globals.js +97 -0
src/helmets.js +117 -0
src/hud.js +145 -0
src/lighting.js +101 -0
src/main.js +202 -0
src/mountains.js +133 -0
src/pickups.js +136 -0
src/player.js +73 -0
src/projectiles.js +123 -0
src/utils.js +11 -0
src/waves.js +60 -0
src/weapon.js +235 -0
src/world.js +844 -0
tsconfig.json +27 -0

.gitignore ADDED Viewed

	@@ -0,0 +1,34 @@

+# dependencies (bun install)
+node_modules
+# output
+out
+dist
+*.tgz
+# code coverage
+coverage
+*.lcov
+# logs
+logs
+_.log
+report.[0-9]_.[0-9]_.[0-9]_.[0-9]_.json
+# dotenv environment variable files
+.env
+.env.development.local
+.env.test.local
+.env.production.local
+.env.local
+# caches
+.eslintcache
+.cache
+*.tsbuildinfo
+# IntelliJ based IDEs
+.idea
+# Finder (MacOS) folder config
+.DS_Store

README.md ADDED Viewed

	@@ -0,0 +1,27 @@

+---
+title: Orcs In The Forest
+emoji: 🧌
+colorFrom: green
+colorTo: purple
+sdk: static
+pinned: false
+---
+# Orcs In The Forest
+This project was created using `bun init` in bun v1.2.4. [Bun](https://bun.sh) is a fast all-in-one JavaScript runtime.
+## Foliage (Grass/Bushes/Rocks/Flowers)
+Ground cover is procedurally generated and batched with `THREE.InstancedMesh` in chunked grids for performance. Wind sway for grass/flowers reuses the forest wind uniform and runs entirely in the vertex shader.
+- Config: edit `CFG.foliage` in `src/config.js` to tune density and chunk size.
+  - `chunkSize`: larger reduces draw calls (fewer chunks).
+  - `grassPerChunk`, `flowersPerChunk`, `bushesPerChunk`, `rocksPerChunk`: density per chunk.
+  - `windStrength`: vertex bend amount for grass/flowers.
+  - `densityNearClear`: density at the clearing edge; blends to 1 outward.
+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.

bun.lock ADDED Viewed

	@@ -0,0 +1,29 @@

+{
+  "lockfileVersion": 1,
+  "workspaces": {
+    "": {
+      "name": "shooter",
+      "devDependencies": {
+        "@types/bun": "latest",
+      },
+      "peerDependencies": {
+        "typescript": "^5",
+      },
+    },
+  },
+  "packages": {
+    "@types/bun": ["@types/[email protected]", "", { "dependencies": { "bun-types": "1.2.19" } }, "sha512-d9ZCmrH3CJ2uYKXQIUuZ/pUnTqIvLDS0SK7pFmbx8ma+ziH/FRMoAq5bYpRG7y+w1gl+HgyNZbtqgMq4W4e2Lg=="],
+    "@types/node": ["@types/[email protected]", "", { "dependencies": { "undici-types": "~7.10.0" } }, "sha512-DRh5K+ka5eJic8CjH7td8QpYEV6Zo10gfRkjHCO3weqZHWDtAaSTFtl4+VMqOJ4N5jcuhZ9/l+yy8rVgw7BQeQ=="],
+    "@types/react": ["@types/[email protected]", "", { "dependencies": { "csstype": "^3.0.2" } }, "sha512-WmdoynAX8Stew/36uTSVMcLJJ1KRh6L3IZRx1PZ7qJtBqT3dYTgyDTx8H1qoRghErydW7xw9mSJ3wS//tCRpFA=="],
+    "bun-types": ["[email protected]", "", { "dependencies": { "@types/node": "*" }, "peerDependencies": { "@types/react": "^19" } }, "sha512-uAOTaZSPuYsWIXRpj7o56Let0g/wjihKCkeRqUBhlLVM/Bt+Fj9xTo+LhC1OV1XDaGkz4hNC80et5xgy+9KTHQ=="],
+    "csstype": ["[email protected]", "", {}, "sha512-M1uQkMl8rQK/szD0LNhtqxIPLpimGm8sOBwU7lLnCpSbTyY3yeU1Vc7l4KT5zT4s/yOxHH5O7tIuuLOCnLADRw=="],
+    "typescript": ["[email protected]", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-CWBzXQrc/qOkhidw1OzBTQuYRbfyxDXJMVJ1XNwUHGROVmuaeiEm3OslpZ1RV96d7SKKjZKrSJu3+t/xlw3R9A=="],
+    "undici-types": ["[email protected]", "", {}, "sha512-t5Fy/nfn+14LuOc2KNYg75vZqClpAiqscVvMygNnlsHBFpSXdJaYtXMcdNLpl/Qvc3P2cB3s6lOV51nqsFq4ag=="],
+  }
+}

index.html ADDED Viewed

	@@ -0,0 +1,198 @@

+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <title>Orcs In The Forest</title>
+  <style>
+    body {
+      margin: 0;
+      overflow: hidden;
+      font-family: monospace;
+      background: #000;
+    }
+    canvas { display: block; }
+    :root {
+      --hud-bg: rgba(14, 20, 28, 0.55);
+      --hud-border: rgba(120, 200, 255, 0.55);
+      --hud-glow: 0 0 18px rgba(80, 180, 255, 0.35);
+      --accent: #34d399; /* green */
+      --accent2: #60a5fa; /* blue */
+      --text: #e8f0ff;
+      --muted: rgba(200, 230, 255, 0.65);
+    }
+    #hud {
+      position: absolute;
+      top: 0; left: 0; right: 0; bottom: 0;
+      pointer-events: none;
+      color: white;
+      text-shadow: 2px 2px 4px rgba(0,0,0,0.8);
+    }
+    #crosshair {
+      position: absolute;
+      top: 50%; left: 50%;
+      transform: translate(-50%, -50%);
+      width: 0; height: 0;
+    }
+    .crosshair-arm {
+      position: absolute;
+      background: rgba(255,255,255,0.85);
+      box-shadow: 0 0 6px rgba(255,255,255,0.5);
+    }
+    .arm-h { height: 2px; }
+    .arm-v { width: 2px; }
+    /* HUD Cards */
+    .hud-card {
+      position: absolute;
+      padding: 12px 14px;
+      background: var(--hud-bg);
+      border: 1px solid var(--hud-border);
+      border-radius: 10px;
+      box-shadow: var(--hud-glow);
+      backdrop-filter: blur(6px);
+      color: var(--text);
+      pointer-events: none;
+    }
+    .hud-title { font-size: 12px; letter-spacing: 1.5px; color: var(--muted); margin-bottom: 6px; }
+    .hud-value { font-size: 26px; font-weight: 700; color: #fff; }
+    .tl { top: 18px; left: 20px; }
+    .tr { top: 18px; right: 20px; }
+    .bl { bottom: 20px; left: 20px; }
+    .br { bottom: 20px; right: 20px; }
+    /* Health gauge */
+    #ui-health { width: 360px; padding: 14px 16px; }
+    #health-bar {
+      position: relative;
+      width: 100%; height: 18px;
+      background: linear-gradient(180deg, rgba(20,30,36,0.9), rgba(12,16,22,0.9));
+      border: 1px solid rgba(80, 120, 140, 0.55);
+      border-radius: 8px;
+      overflow: hidden;
+      box-shadow: inset 0 0 10px rgba(0,0,0,0.45);
+    }
+    #health-fill {
+      position: absolute; left: 0; top: 0; bottom: 0; width: 60%;
+      background: linear-gradient(90deg, rgba(34,197,94,0.85), rgba(16,185,129,0.95));
+      box-shadow: 0 0 12px rgba(34,197,94,0.55);
+    }
+    #health-stripes {
+      position: absolute; inset: 0;
+      background: repeating-linear-gradient(45deg, rgba(255,255,255,0.05) 0, rgba(255,255,255,0.05) 6px, transparent 6px, transparent 12px);
+      pointer-events: none;
+    }
+    #health-text { font-size: 16px; color: #eafff1; text-shadow: 0 0 6px rgba(34,197,94,0.6); }
+    #health-label { margin-bottom: 8px; display: flex; justify-content: space-between; align-items: baseline; }
+    #health-label .hud-title { margin: 0; }
+    /* Ammo */
+    #ui-ammo { min-width: 220px; text-align: right; }
+    #ammo { font-size: 40px; font-weight: 800; color: #e6f7ff; text-shadow: 0 0 8px rgba(96,165,250,0.6); }
+    #ammo:before { content: 'AMMO'; display: block; font-size: 12px; color: var(--muted); letter-spacing: 1.5px; margin-bottom: 6px; text-align: right; }
+    /* Score */
+    #ui-score { min-width: 160px; }
+    #score:before { content: 'SCORE'; display: block; font-size: 12px; color: var(--muted); letter-spacing: 1.5px; margin-bottom: 6px; }
+    #score { font-size: 28px; font-weight: 800; color: #fff; }
+    /* Top-right stats */
+    #ui-topright { display: grid; grid-template-columns: 1fr 1fr; gap: 12px; }
+    .mini-card { padding: 8px 10px; background: rgba(12,18,26,0.55); border: 1px solid rgba(120, 200, 255, 0.35); border-radius: 8px; }
+    .mini-card .label { font-size: 11px; color: var(--muted); letter-spacing: 1.2px; }
+    .mini-card .value { font-size: 22px; font-weight: 700; color: #fff; }
+    #overlay {
+      position: absolute;
+      top: 0; left: 0; right: 0; bottom: 0;
+      display: flex; align-items: center; justify-content: center;
+      background: rgba(0,0,0,0.7);
+      pointer-events: auto; cursor: pointer;
+    }
+    #overlay-content { text-align: center; color: white; font-size: 24px; }
+    #overlay-content h1 { margin: 20px 0; }
+    #overlay-content p { margin: 10px 0; font-size: 18px; }
+    .hidden { display: none !important; }
+    #wave-banner {
+      position: absolute;
+      top: 40%; left: 50%; transform: translate(-50%, -50%);
+      font-size: 48px; color: #ff0;
+      text-shadow: 3px 3px 6px rgba(0,0,0,0.9);
+      opacity: 0; transition: opacity 0.5s;
+    }
+    #wave-banner.show { opacity: 1; }
+    #damage-overlay {
+      position: absolute;
+      top: 0; left: 0; right: 0; bottom: 0;
+      pointer-events: none;
+      background: radial-gradient(ellipse at center, rgba(255,0,0,0.0) 40%, rgba(255,0,0,0.35) 80%, rgba(255,0,0,0.7) 100%);
+      opacity: 0;
+    }
+    #heal-overlay {
+      position: absolute;
+      top: 0; left: 0; right: 0; bottom: 0;
+      pointer-events: none;
+      background: radial-gradient(ellipse at center, rgba(0,255,128,0.0) 40%, rgba(0,255,128,0.28) 80%, rgba(0,255,128,0.55) 100%);
+      opacity: 0;
+    }
+  </style>
+</head>
+<body>
+  <div id="hud">
+    <!-- Score Top-Left -->
+    <div id="ui-score" class="hud-card tl">
+      <div class="hud-value" id="score">0</div>
+    </div>
+    <!-- Wave + Enemies Top-Right -->
+    <div id="ui-topright" class="hud-card tr">
+      <div class="mini-card">
+        <div class="label">WAVE</div>
+        <div class="value" id="wave">1</div>
+      </div>
+      <div class="mini-card">
+        <div class="label">ENEMIES</div>
+        <div class="value" id="enemies">0</div>
+      </div>
+    </div>
+    <!-- Health Bottom-Left -->
+    <div id="ui-health" class="hud-card bl">
+      <div id="health-label"><span class="hud-title">HEALTH</span><span id="health-text">100</span></div>
+      <div id="health-bar">
+        <div id="health-fill" style="width: 100%"></div>
+        <div id="health-stripes"></div>
+      </div>
+    </div>
+    <!-- Ammo Bottom-Right -->
+    <div id="ui-ammo" class="hud-card br">
+      <div class="hud-value" id="ammo">0/∞</div>
+    </div>
+    <div id="crosshair">
+      <div id="ch-left" class="crosshair-arm arm-h"></div>
+      <div id="ch-right" class="crosshair-arm arm-h"></div>
+      <div id="ch-top" class="crosshair-arm arm-v"></div>
+      <div id="ch-bottom" class="crosshair-arm arm-v"></div>
+    </div>
+    <div id="wave-banner"></div>
+    <div id="heal-overlay"></div>
+    <div id="damage-overlay"></div>
+  </div>
+  <div id="overlay">
+    <div id="overlay-content">
+      <h1>Orcs In The Forest</h1>
+      <p>Click to Start</p>
+      <p style="font-size: 14px;">Move: WASD | Look: Mouse | Fire: Click | Reload: R | Light: F | Pause: ESC</p>
+    </div>
+  </div>
+  <script type="importmap">
+  {
+    "imports": {
+      "three": "https://unpkg.com/[email protected]/build/three.module.js",
+      "three/addons/": "https://unpkg.com/[email protected]/examples/jsm/"
+    }
+  }
+  </script>
+  <script type="module" src="src/main.js"></script>
+</body>
+</html>

index.ts ADDED Viewed

	@@ -0,0 +1 @@


1	+ console.log("Hello via Bun!");

package.json ADDED Viewed

	@@ -0,0 +1,12 @@

+{
+  "name": "shooter",
+  "module": "index.ts",
+  "type": "module",
+  "private": true,
+  "devDependencies": {
+    "@types/bun": "latest"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  }
+}

src/audio.js ADDED Viewed

	@@ -0,0 +1,165 @@

+// Lightweight Web Audio synth for SFX
+import { CFG } from './config.js';
+let ctx = null;
+let master = null;
+function ensureContext() {
+  if (!ctx) {
+    const AC = window.AudioContext || window.webkitAudioContext;
+    ctx = new AC();
+    master = ctx.createGain();
+    master.gain.value = (CFG.audio && CFG.audio.master != null) ? CFG.audio.master : 0.6;
+    master.connect(ctx.destination);
+  }
+  if (ctx.state === 'suspended') ctx.resume();
+}
+export function initAudio() {
+  ensureContext();
+}
+export function resumeAudio() {
+  ensureContext();
+}
+// Simple gunshot: noise burst + filtered click + low thump
+export function playGunshot() {
+  ensureContext();
+  const t0 = ctx.currentTime;
+  // White noise burst
+  const noiseBuf = ctx.createBuffer(1, Math.floor(ctx.sampleRate * 0.12), ctx.sampleRate);
+  const data = noiseBuf.getChannelData(0);
+  for (let i = 0; i < data.length; i++) data[i] = (Math.random() * 2 - 1) * 0.9;
+  const noise = ctx.createBufferSource();
+  noise.buffer = noiseBuf;
+  const hp = ctx.createBiquadFilter();
+  hp.type = 'highpass';
+  hp.frequency.value = 800;
+  const lp = ctx.createBiquadFilter();
+  lp.type = 'lowpass';
+  lp.frequency.setValueAtTime(6000, t0);
+  lp.frequency.exponentialRampToValueAtTime(1200, t0 + 0.12);
+  const nGain = ctx.createGain();
+  nGain.gain.setValueAtTime(0.0, t0);
+  nGain.gain.linearRampToValueAtTime((CFG.audio?.gunshotVol ?? 0.9) * 0.7, t0 + 0.002);
+  nGain.gain.exponentialRampToValueAtTime(0.001, t0 + 0.12);
+  noise.connect(hp).connect(lp).connect(nGain).connect(master);
+  noise.start(t0);
+  noise.stop(t0 + 0.13);
+  // Low thump
+  const osc = ctx.createOscillator();
+  osc.type = 'sine';
+  osc.frequency.setValueAtTime(160, t0);
+  osc.frequency.exponentialRampToValueAtTime(60, t0 + 0.12);
+  const oGain = ctx.createGain();
+  oGain.gain.setValueAtTime(0.0, t0);
+  oGain.gain.linearRampToValueAtTime((CFG.audio?.gunshotVol ?? 0.9) * 0.3, t0 + 0.005);
+  oGain.gain.exponentialRampToValueAtTime(0.001, t0 + 0.14);
+  osc.connect(oGain).connect(master);
+  osc.start(t0);
+  osc.stop(t0 + 0.16);
+}
+// Headshot: bright, short bell with slight pitch down
+export function playHeadshot() {
+  ensureContext();
+  const t0 = ctx.currentTime;
+  const baseVol = (CFG.audio?.headshotVol ?? 0.8);
+  // Two detuned triangles
+  const makeVoice = (freq, detune) => {
+    const o = ctx.createOscillator();
+    o.type = 'triangle';
+    o.frequency.setValueAtTime(freq, t0);
+    o.detune.setValueAtTime(detune, t0);
+    o.frequency.exponentialRampToValueAtTime(freq * 0.75, t0 + 0.18);
+    const g = ctx.createGain();
+    g.gain.setValueAtTime(0.0, t0);
+    g.gain.linearRampToValueAtTime(baseVol * 0.45, t0 + 0.005);
+    g.gain.exponentialRampToValueAtTime(0.001, t0 + 0.22);
+    o.connect(g);
+    return { o, g };
+  };
+  const v1 = makeVoice(1100, 0);
+  const v2 = makeVoice(1100 * 1.5, 8);
+  const bp = ctx.createBiquadFilter();
+  bp.type = 'bandpass';
+  bp.frequency.setValueAtTime(1500, t0);
+  bp.Q.value = 3;
+  v1.g.connect(bp);
+  v2.g.connect(bp);
+  bp.connect(master);
+  v1.o.start(t0); v1.o.stop(t0 + 0.24);
+  v2.o.start(t0); v2.o.stop(t0 + 0.24);
+  // Tiny click to emphasize
+  const click = ctx.createBufferSource();
+  const buf = ctx.createBuffer(1, Math.floor(ctx.sampleRate * 0.01), ctx.sampleRate);
+  const ch = buf.getChannelData(0);
+  for (let i = 0; i < ch.length; i++) ch[i] = (Math.random() * 2 - 1) * (1 - i / ch.length);
+  click.buffer = buf;
+  const cGain = ctx.createGain();
+  cGain.gain.value = baseVol * 0.25;
+  click.connect(cGain).connect(master);
+  click.start(t0);
+}
+// FM metal ping helper
+function fmPing(t, { freq = 650, mod = 1200, index = 1.2, dur = 0.14, gain = 0.28, bpFreq = 1800, q = 8 }) {
+  const o = ctx.createOscillator(); o.type = 'sine';
+  const m = ctx.createOscillator(); m.type = 'sine';
+  const mg = ctx.createGain(); mg.gain.value = freq * index;
+  m.connect(mg).connect(o.frequency);
+  o.frequency.setValueAtTime(freq, t);
+  m.frequency.setValueAtTime(mod, t);
+  const bp = ctx.createBiquadFilter(); bp.type = 'bandpass'; bp.Q.value = q; bp.frequency.value = bpFreq;
+  const g = ctx.createGain();
+  g.gain.setValueAtTime(0.0001, t);
+  g.gain.linearRampToValueAtTime(gain * (CFG.audio?.reloadVol ?? 0.7), t + 0.006);
+  g.gain.exponentialRampToValueAtTime(0.0001, t + dur);
+  o.connect(bp).connect(g).connect(master);
+  o.start(t); m.start(t);
+  o.stop(t + dur + 0.02); m.stop(t + dur + 0.02);
+}
+function tick(t, len = 0.012, gain = 0.18) {
+  const src = ctx.createBufferSource();
+  const b = ctx.createBuffer(1, Math.floor(ctx.sampleRate * len), ctx.sampleRate);
+  const ch = b.getChannelData(0);
+  for (let i = 0; i < ch.length; i++) ch[i] = (Math.random() * 2 - 1) * (1 - i / ch.length);
+  src.buffer = b;
+  const hp = ctx.createBiquadFilter(); hp.type = 'highpass'; hp.frequency.value = 2000;
+  const g = ctx.createGain(); g.gain.value = gain * (CFG.audio?.reloadVol ?? 0.7);
+  src.connect(hp).connect(g).connect(master);
+  src.start(t); src.stop(t + len + 0.005);
+}
+// Start-of-reload metallic cue (short, crisp)
+export function playReloadStart() {
+  ensureContext();
+  const t0 = ctx.currentTime;
+  fmPing(t0 + 0.0, { freq: 900, mod: 1800, index: 1.4, dur: 0.10, gain: 0.22, bpFreq: 2200, q: 10 });
+  tick(t0 + 0.01, 0.01, 0.12);
+}
+// End-of-reload latch (deeper metallic clack)
+export function playReloadEnd() {
+  ensureContext();
+  const t0 = ctx.currentTime;
+  fmPing(t0, { freq: 520, mod: 900, index: 1.0, dur: 0.16, gain: 0.32, bpFreq: 1500, q: 7 });
+  fmPing(t0 + 0.02, { freq: 780, mod: 1400, index: 0.9, dur: 0.12, gain: 0.18, bpFreq: 1900, q: 9 });
+  tick(t0 + 0.005, 0.012, 0.2);
+}

src/casings.js ADDED Viewed

	@@ -0,0 +1,131 @@

+import * as THREE from 'three';
+import { G } from './globals.js';
+// Shared casing geometry/materials to avoid per-shot allocations
+const CASING = (() => {
+  const bodyGeo = new THREE.CylinderGeometry(0.018, 0.018, 0.12, 10);
+  const capGeo = new THREE.CylinderGeometry(0.018, 0.018, 0.01, 10);
+  const brass = new THREE.MeshStandardMaterial({ color: 0xb48a3a, metalness: 0.7, roughness: 0.35 });
+  const capMat = new THREE.MeshStandardMaterial({ color: 0x222222, metalness: 0.2, roughness: 0.7 });
+  return { bodyGeo, capGeo, brass, capMat };
+})();
+const MAX_CASINGS = 40;
+// Spawn a brass shell casing at the weapon's ejector anchor
+export function spawnShellCasing() {
+  if (!G.weapon || !G.weapon.ejector) return;
+  const anchor = G.weapon.ejector;
+  const pos = new THREE.Vector3();
+  const q = new THREE.Quaternion();
+  anchor.getWorldPosition(pos);
+  anchor.getWorldQuaternion(q);
+  // Visual: small brass cylinder + dark cap
+  const group = new THREE.Group();
+  // Cylinder aligned along X: use rotation
+  const body = new THREE.Mesh(CASING.bodyGeo, CASING.brass);
+  body.rotation.z = Math.PI / 2;
+  body.castShadow = false; body.receiveShadow = false;
+  group.add(body);
+  const cap = new THREE.Mesh(CASING.capGeo, CASING.capMat);
+  cap.position.x = 0.06;
+  cap.rotation.z = Math.PI / 2;
+  cap.castShadow = false; cap.receiveShadow = false;
+  group.add(cap);
+  group.position.copy(pos);
+  G.scene.add(group);
+  // Orientation basis from weapon
+  const right = new THREE.Vector3(1, 0, 0).applyQuaternion(q).normalize();
+  const up = new THREE.Vector3(0, 1, 0).applyQuaternion(q).normalize();
+  const fwd = new THREE.Vector3(0, 0, -1).applyQuaternion(q).normalize();
+  // Ejection velocity: mostly right, a bit up, slightly backward
+  const baseRight = 2.0 + G.random() * 1.2;
+  const baseUp = 1.6 + G.random() * 0.8;
+  const back = 0.6 + G.random() * 0.6;
+  const jitter = new THREE.Vector3((G.random() - 0.5) * 0.4, (G.random() - 0.5) * 0.4, (G.random() - 0.5) * 0.4);
+  const vel = new THREE.Vector3()
+    .addScaledVector(right, baseRight)
+    .addScaledVector(up, baseUp)
+    .addScaledVector(fwd, -back)
+    .add(jitter);
+  // Random angular velocity for spin
+  const angVel = new THREE.Vector3(
+    (G.random() - 0.5) * 20,
+    (G.random() - 0.5) * 30,
+    (G.random() - 0.5) * 20
+  );
+  // Keep list bounded to avoid unbounded accumulation
+  if (G.casings.length >= MAX_CASINGS) {
+    const old = G.casings.shift();
+    if (old) G.scene.remove(old.mesh);
+  }
+  G.casings.push({
+    mesh: group,
+    pos: group.position,
+    vel,
+    angVel,
+    life: 6,
+    grounded: false
+  });
+}
+export function updateCasings(delta) {
+  const gravity = 20;
+  const bounce = 0.25;
+  for (let i = G.casings.length - 1; i >= 0; i--) {
+    const c = G.casings[i];
+    // Integrate
+    c.vel.y -= gravity * delta;
+    c.pos.addScaledVector(c.vel, delta);
+    // Spin
+    if (c.angVel) {
+      c.mesh.rotateX(c.angVel.x * delta);
+      c.mesh.rotateY(c.angVel.y * delta);
+      c.mesh.rotateZ(c.angVel.z * delta);
+    }
+    // Ground collision (approximate at y ~ body radius)
+    const floor = 0.02;
+    if (c.pos.y <= floor) {
+      c.pos.y = floor;
+      if (Math.abs(c.vel.y) > 0.3) {
+        c.vel.y = -c.vel.y * bounce;
+      } else {
+        c.vel.y = 0;
+      }
+      // Horizontal friction
+      c.vel.x *= 0.75;
+      c.vel.z *= 0.75;
+      // Dampen spin
+      if (c.angVel) c.angVel.multiplyScalar(0.88);
+    }
+    // Lifetime fade and cleanup
+    c.life -= delta;
+    if (c.life <= 1.5) {
+      for (const child of c.mesh.children) {
+        const m = child.material;
+        if (m && m.opacity !== undefined) {
+          m.transparent = true;
+          m.opacity = Math.max(0, c.life / 1.5);
+        }
+      }
+    }
+    if (c.life <= 0) {
+      G.scene.remove(c.mesh);
+      G.casings.splice(i, 1);
+    }
+  }
+}

src/clouds.js ADDED Viewed

	@@ -0,0 +1,183 @@

+import * as THREE from 'three';
+import { G } from './globals.js';
+import { CLOUDS } from './config.js';
+const COLOR_N = new THREE.Color(CLOUDS.colorNight);
+const COLOR_D = new THREE.Color(CLOUDS.colorDay);
+const TMP_COLOR = new THREE.Color();
+// Lightweight value-noise + FBM for soft, natural cloud edges
+function hash2i(xi, yi, seed) {
+  let h = Math.imul(xi, 374761393) ^ Math.imul(yi, 668265263) ^ Math.imul(seed, 2147483647);
+  h = Math.imul(h ^ (h >>> 13), 1274126177);
+  h = (h ^ (h >>> 16)) >>> 0;
+  return h / 4294967296; // [0,1)
+}
+function smoothstep(a, b, t) {
+  if (t <= a) return 0;
+  if (t >= b) return 1;
+  t = (t - a) / (b - a);
+  return t * t * (3 - 2 * t);
+}
+function lerp(a, b, t) { return a + (b - a) * t; }
+function valueNoise2(x, y, seed) {
+  const xi = Math.floor(x);
+  const yi = Math.floor(y);
+  const xf = x - xi;
+  const yf = y - yi;
+  const sx = smoothstep(0, 1, xf);
+  const sy = smoothstep(0, 1, yf);
+  const v00 = hash2i(xi, yi, seed);
+  const v10 = hash2i(xi + 1, yi, seed);
+  const v01 = hash2i(xi, yi + 1, seed);
+  const v11 = hash2i(xi + 1, yi + 1, seed);
+  const ix0 = lerp(v00, v10, sx);
+  const ix1 = lerp(v01, v11, sx);
+  return lerp(ix0, ix1, sy) * 2 - 1; // [-1,1]
+}
+function fbm2(x, y, baseFreq, octaves, lacunarity, gain, seed) {
+  let sum = 0;
+  let amp = 1;
+  let freq = baseFreq;
+  for (let i = 0; i < octaves; i++) {
+    sum += amp * valueNoise2(x * freq, y * freq, seed + i * 1013);
+    freq *= lacunarity;
+    amp *= gain;
+  }
+  return sum; // ~[-ampSum, ampSum]
+}
+function makeCloudTexture(size = 256, puffCount = 10) {
+  const canvas = document.createElement('canvas');
+  canvas.width = canvas.height = size;
+  const ctx = canvas.getContext('2d');
+  if (!ctx) return null;
+  ctx.clearRect(0, 0, size, size);
+  // Draw several soft circles to form a cloud shape
+  const r = size / 2;
+  ctx.fillStyle = 'white';
+  ctx.globalCompositeOperation = 'source-over';
+  for (let i = 0; i < puffCount; i++) {
+    const pr = r * (0.42 + Math.random() * 0.38);
+    const px = r + (Math.random() * 2 - 1) * r * 0.48;
+    const py = r + (Math.random() * 2 - 1) * r * 0.22; // slightly flatter vertically
+    const grad = ctx.createRadialGradient(px, py, pr * 0.18, px, py, pr);
+    grad.addColorStop(0, 'rgba(255,255,255,0.95)');
+    grad.addColorStop(1, 'rgba(255,255,255,0.0)');
+    ctx.fillStyle = grad;
+    ctx.beginPath();
+    ctx.arc(px, py, pr, 0, Math.PI * 2);
+    ctx.fill();
+  }
+  // Apply subtle FBM noise to alpha for irregular, more realistic edges
+  const img = ctx.getImageData(0, 0, size, size);
+  const data = img.data;
+  const seed = 1337;
+  for (let y = 0; y < size; y++) {
+    for (let x = 0; x < size; x++) {
+      const idx = (y * size + x) * 4;
+      const a = data[idx + 3] / 255; // base alpha from puffs
+      if (a <= 0) continue;
+      // FBM noise in [0..1]
+      const nx = x / size;
+      const ny = y / size;
+      const n = fbm2(nx, ny, 8.0, 3, 2.0, 0.5, seed) * 0.5 + 0.5;
+      // Edge breakup and slight interior variation
+      let alpha = a * (0.78 + 0.35 * n);
+      // Gentle bottom shading (darker underside)
+      const shade = 0.90 + 0.10 * (1.0 - ny); // 1.0 at top -> 0.90 at bottom
+      data[idx]   = Math.min(255, data[idx] * shade);
+      data[idx+1] = Math.min(255, data[idx+1] * shade);
+      data[idx+2] = Math.min(255, data[idx+2] * shade);
+      // Contrast alpha for crisper silhouettes
+      alpha = Math.pow(alpha, 0.85);
+      // Hard clip tiny alphas to help alphaTest (reduces overdraw)
+      if (alpha < 0.02) alpha = 0;
+      data[idx + 3] = Math.round(alpha * 255);
+    }
+  }
+  ctx.putImageData(img, 0, 0);
+  const tex = new THREE.CanvasTexture(canvas);
+  tex.generateMipmaps = true;
+  tex.anisotropy = 2;
+  tex.minFilter = THREE.LinearMipmapLinearFilter;
+  tex.magFilter = THREE.LinearFilter;
+  return tex;
+}
+export function setupClouds() {
+  if (!CLOUDS.enabled) return;
+  // Create shared texture
+  const tex = makeCloudTexture(256, 12);
+  if (!tex) return;
+  // Wind vector
+  const ang = THREE.MathUtils.degToRad(CLOUDS.windDeg || 0);
+  const wind = new THREE.Vector3(Math.cos(ang), 0, Math.sin(ang));
+  for (let i = 0; i < CLOUDS.count; i++) {
+    const mat = new THREE.SpriteMaterial({
+      map: tex,
+      color: new THREE.Color(CLOUDS.colorDay),
+      transparent: true,
+      opacity: CLOUDS.opacityDay,
+      alphaTest: 0.03, // discard near-transparent pixels, reduces fill cost
+      depthTest: true,
+      depthWrite: false,
+      fog: false
+    });
+    const sp = new THREE.Sprite(mat);
+    // Randomize in-texture rotation for variety without extra draw cost
+    sp.material.rotation = Math.random() * Math.PI * 2;
+    const size = THREE.MathUtils.lerp(CLOUDS.sizeMin, CLOUDS.sizeMax, Math.random());
+    sp.scale.set(size, size * 0.6, 1); // a bit flattened
+    sp.castShadow = false; sp.receiveShadow = false;
+    // Position in ring
+    const t = Math.random() * Math.PI * 2;
+    const r = CLOUDS.radius * (0.6 + Math.random() * 0.4);
+    sp.position.set(Math.cos(t) * r, CLOUDS.height + (Math.random() - 0.5) * 10, Math.sin(t) * r);
+    sp.renderOrder = 0;
+    G.scene.add(sp);
+    const speed = CLOUDS.speed * (0.6 + Math.random() * 0.8);
+    G.clouds.push({ sprite: sp, speed, wind: wind.clone(), size });
+  }
+}
+export function updateClouds(delta) {
+  if (!CLOUDS.enabled || G.clouds.length === 0) return;
+  // Day factor for opacity/color blending
+  const dayF = 0.5 - 0.5 * Math.cos(2 * Math.PI * (G.timeOfDay || 0));
+  for (const c of G.clouds) {
+    // Drift
+    c.sprite.position.addScaledVector(c.wind, c.speed * delta);
+    // Wrap around ring bounds
+    const p = c.sprite.position;
+    const r = Math.hypot(p.x, p.z);
+    const minR = CLOUDS.radius * 0.5;
+    const maxR = CLOUDS.radius * 1.1;
+    if (r < minR || r > maxR) {
+      // Reposition opposite side keeping height
+      const ang = Math.atan2(p.z, p.x) + Math.PI;
+      p.x = Math.cos(ang) * CLOUDS.radius;
+      p.z = Math.sin(ang) * CLOUDS.radius;
+    }
+    // Blend opacity and color via day/night
+    const op = CLOUDS.opacityNight * (1 - dayF) + CLOUDS.opacityDay * dayF;
+    c.sprite.material.opacity = op;
+    TMP_COLOR.copy(COLOR_N).lerp(COLOR_D, dayF);
+    c.sprite.material.color.copy(TMP_COLOR);
+  }
+}

src/combat.js ADDED Viewed

	@@ -0,0 +1,132 @@

+import * as THREE from 'three';
+import { CFG } from './config.js';
+import { G } from './globals.js';
+import { updateHUD } from './hud.js';
+import { spawnTracer, spawnImpact, spawnMuzzleFlash } from './fx.js';
+import { spawnShellCasing } from './casings.js';
+import { popHelmet } from './helmets.js';
+import { beginReload } from './weapon.js';
+import { spawnHealthOrbs } from './pickups.js';
+import { playGunshot, playHeadshot } from './audio.js';
+// Reusable temps to reduce GC
+const TMP2 = new THREE.Vector2();
+const TMPv1 = new THREE.Vector3();
+const TMPv2 = new THREE.Vector3();
+const TMPn = new THREE.Vector3();
+const HIT_OBJECTS = [];
+const UP = new THREE.Vector3(0, 1, 0);
+export function performShooting(delta) {
+  G.shootCooldown -= delta;
+  if (G.input.shoot && G.shootCooldown <= 0 && G.state === 'playing') {
+    if (G.weapon.reloading) return;
+    if (G.weapon.ammo <= 0) {
+      G.shootCooldown = 0.2;
+      G.weapon.recoil += CFG.gun.recoilKick * 0.25;
+      return;
+    }
+    G.shootCooldown = 1 / CFG.gun.rof;
+    G.weapon.ammo--;
+    G.weapon.recoil += CFG.gun.recoilKick;
+    updateHUD();
+    // Increase dynamic spread per shot (clamped)
+    const inc = CFG.gun.spreadShotIncrease || 0;
+    const maxS = CFG.gun.spreadMax || 0.02;
+    G.weapon.spread = Math.min(maxS, G.weapon.spread + inc);
+    // View recoil: add a pitch up and small random yaw
+    const pitchKick = THREE.MathUtils.degToRad(CFG.gun.viewKickPitchDeg || 0);
+    const yawKick = THREE.MathUtils.degToRad((CFG.gun.viewKickYawDeg || 0) * (G.random() * 2 - 1));
+    G.weapon.viewPitch += pitchKick;
+    G.weapon.viewYaw += yawKick;
+    const spread = G.weapon.spread || (CFG.gun.bloom || 0);
+    const nx = (G.random() - 0.5) * spread * 2;
+    const ny = (G.random() - 0.5) * spread * 2;
+    TMP2.set(nx, ny);
+    G.raycaster.setFromCamera(TMP2, G.camera);
+    G.raycaster.far = CFG.gun.range;
+    // Build hit list without creating new arrays
+    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);
+    }
+    for (let i = 0; i < G.blockers.length; i++) HIT_OBJECTS.push(G.blockers[i]);
+    const hits = G.raycaster.intersectObjects(HIT_OBJECTS, true);
+    G.weapon.muzzle.getWorldPosition(TMPv1);
+    G.camera.getWorldDirection(TMPv2);
+    let end = TMPv2.clone().multiplyScalar(CFG.gun.range).add(G.camera.position);
+    let firstHit = null;
+    if (hits.length > 0) {
+      firstHit = hits[0];
+      end.copy(firstHit.point);
+      // Find enemy and hit zone by traversing up the hierarchy
+      function findEnemyAndZone(obj) {
+        let cur = obj;
+        while (cur) {
+          if (cur.userData && cur.userData.enemy) {
+            return { enemy: cur.userData.enemy, zone: cur.userData.hitZone || 'body' };
+          }
+          cur = cur.parent;
+        }
+        return { enemy: null, zone: null };
+      }
+      const { enemy, zone } = findEnemyAndZone(firstHit.object);
+      if (enemy && enemy.alive) {
+        const isHead = zone === 'head';
+        const dmg = CFG.gun.damage * (isHead ? CFG.gun.headshotMult : 1);
+        enemy.hp -= dmg;
+        if (isHead) playHeadshot();
+        // If headshot, pop the helmet off with a kick in shot direction
+        if (isHead && enemy.helmetAttached) {
+          const shotDir = new THREE.Vector3();
+          G.camera.getWorldDirection(shotDir);
+          popHelmet(enemy, shotDir, firstHit.point);
+        }
+        // Debug hit indicator removed to avoid per-shot allocations
+        if (enemy.hp <= 0) {
+          enemy.alive = false;
+          enemy.deathTimer = 0;
+          G.waves.aliveCount--;
+          G.player.score += isHead ? 15 : 10;
+          // Drop 1-5 green health orbs
+          const cnt = 1 + Math.floor(G.random() * 5);
+          spawnHealthOrbs(enemy.pos, cnt);
+        }
+      } else if (firstHit.object !== G.ground) {
+        const n = firstHit.face?.normal
+          ? TMPn.copy(firstHit.face.normal).transformDirection(firstHit.object.matrixWorld)
+          : UP;
+        spawnImpact(firstHit.point, n);
+      }
+    }
+    spawnTracer(TMPv1, end);
+    spawnMuzzleFlash();
+    spawnShellCasing();
+    playGunshot();
+  }
+  if (!G.weapon.reloading && G.weapon.ammo === 0 && (G.weapon.reserve > 0 || G.weapon.reserve === Infinity)) {
+    beginReload();
+  }
+}

src/config.js ADDED Viewed

	@@ -0,0 +1,182 @@

+// Game configuration constants
+export const CFG = {
+  forestSize: 300,
+  treeCount: 400,
+  clearRadius: 12,
+  // Ground cover (instanced) config
+  foliage: {
+    chunkSize: 30,        // world units per chunk (controls draw calls)
+    grassPerChunk: 220,   // avg blades per chunk (denser)
+    flowersPerChunk: 10,  // avg flower sprites per chunk
+    bushesPerChunk: 2,    // avg bushes per chunk
+    rocksPerChunk: 1,     // avg rocks per chunk
+    maxSlope: 0.98,       // skip very steep surfaces (0..1, 1 = flat)
+    windStrength: 0.45,   // vertex sway amount for grass/flowers
+    densityNearClear: 0.45, // density multiplier at the edge of the clearing
+    // Distance culling for instanced ground cover
+    grassViewDist: 95,    // draw grass within this radius from camera
+    flowerViewDist: 85,   // draw flowers within this radius from camera
+    seedOffset: 8888      // extra salt for deterministic placement
+  },
+  player: {
+    speed: 8,
+    sprintMult: 1.5,
+    radius: 0.8,
+    health: 100,
+    jumpVel: 5
+  },
+  flashlight: {
+    on: true,
+    distance: 150,
+    intensity: 8.0,
+    angle: 0.6
+  },
+  fogDensity: 0.008,
+  waves: {
+    baseCount: 6,
+    perWaveAdd: 4,
+    spawnEvery: 0.7,
+    spawnDecay: 0.03,
+    spawnMin: 0.25,
+    maxAlive: 30,
+    annulusMin: 28,
+    annulusMax: 45,
+    breakTime: 2.5
+  },
+  enemy: {
+    hp: 100,
+    radius: 0.9,
+    baseSpeed: 2.5,
+    speedPerWave: 0.25,
+    dps: 15,
+    // Ranged weapon settings
+    rof: 0.6,            // shots per second (archers)
+    range: 120,
+    shotDamage: 8,
+    bloom: 0.015,        // aim error
+    // Arrow projectile settings
+    arrowSpeed: 40,
+    arrowGravity: 20,
+    arrowDamage: 12,
+    arrowLife: 6,
+    arrowHitRadius: 0.6
+  },
+  gun: {
+    // Faster, closer to AK full-auto feel (~600 RPM is 10 RPS)
+    rof: 10.5,
+    damage: 34,
+    range: 120,
+    // Minimum hipfire spread (normalized device coords)
+    bloom: 0.004,
+    // CS-style dynamic spread tuning
+    spreadMin: 0.003,
+    spreadMax: 0.028,
+    spreadShotIncrease: 0.0030, // added per shot (faster bloom)
+    spreadDecay: 6.8,           // slightly slower recovery while spraying
+    spreadMoveMult: 2.2,        // walking
+    spreadSprintMult: 3.2,      // sprinting
+    spreadAirMult: 4.0,         // not grounded
+    magSize: 24,
+    reloadTime: 1.6,
+    recoilKick: 0.065,
+    recoilRecover: 9.0,
+    headshotMult: 2.0,
+    // View recoil (adds to camera; radians suggested)
+    viewKickPitchDeg: 1.2,     // a touch more kick
+    viewKickYawDeg: 0.5,       // slightly more horizontal wander
+    viewReturn: 9.0            // per second return to neutral
+  },
+  fx: {
+    tracerLife: 0.08,
+    impactLife: 0.25,
+    muzzleLife: 0.05
+  },
+  audio: {
+    master: 0.6,
+    gunshotVol: 0.9,
+    headshotVol: 0.8,
+    reloadVol: 0.7,
+    reloadStart: true,
+    reloadEnd: true
+  },
+  hud: {
+    damageMaxOpacity: 0.6,
+    damageFadeSpeed: 2.5, // per second
+    damagePulsePerHit: 0.5, // adds to flash on single hit
+    damagePulsePerHP: 0.01, // adds per HP of damage
+    // Heal overlay
+    healMaxOpacity: 0.5,
+    healFadeSpeed: 2.5, // per second
+    healPulsePerPickup: 0.45, // adds to flash per orb pickup
+    healPulsePerHP: 0.01 // adds per HP healed
+  },
+  seed: 1337
+};
+// Day/Night cycle configuration
+export const DAY_NIGHT = {
+  enabled: true,
+  lengthSec: 180, // full cycle duration
+  // Orbit
+  sunDistance: 200,   // distance of sun sprite from origin
+  moonDistance: 200,  // distance of moon sprite from origin
+  sunTiltDeg: -30,    // yaw tilt of the sun path (azimuth)
+  // Intensities
+  nightAmbient: 0.45,
+  dayAmbient: 0.65,
+  nightKey: 0.9,   // keep night brighter than before
+  dayKey: 1.5,
+  // Fog densities
+  nightFogDensity: 0.006,
+  dayFogDensity: 0.0035,
+  // Colors
+  colors: {
+    ambientSkyNight: 0x6a7f9a,
+    ambientSkyDay: 0xbfd4ff,
+    ambientGroundNight: 0x2a3544,
+    ambientGroundDay: 0x7a8c6e,
+    dirNight: 0x8baae0,
+    dirDay: 0xfff1cc,
+    // Sun color grading
+    sunSunrise: 0xffa04a, // warmer at horizon
+    sunNoon: 0xfff1cc,    // softer pale at zenith
+    fogNight: 0x101922,
+    fogDay: 0x9cc3ff,
+    bgNight: 0x121a24,
+    bgDay: 0x6ea7e0
+  }
+};
+// Simple clouds config
+export const CLOUDS = {
+  enabled: true,
+  count: 12,
+  height: 92,
+  radius: 200,
+  sizeMin: 28,
+  sizeMax: 48,
+  speed: 2.0,          // base drift speed
+  windDeg: 35,         // wind direction in degrees (0 = +X, 90 = +Z)
+  opacityDay: 0.55,
+  opacityNight: 0.25,
+  colorDay: 0xffffff,
+  colorNight: 0xa0b0c8
+};
+// Background mountains (purely visual)
+export const MOUNTAINS = {
+  enabled: true,
+  radius: 420,
+  segments: 96,
+  baseHeight: 20,
+  heightVar: 60,
+  yOffset: -30,
+  colorDay: 0x6e8ba6,
+  colorNight: 0x223140,
+  // Per-vertex gradient along height
+  colorBase: 0x1d2a35,
+  colorPeak: 0xd7e0ea,
+  // Bottom fade to avoid visible base demarcation
+  fadeEdge: 0.45, // 0..1, where it starts to become opaque
+  fadePow: 1.3
+};

src/daynight.js ADDED Viewed

	@@ -0,0 +1,123 @@

+import * as THREE from 'three';
+import { G } from './globals.js';
+import { DAY_NIGHT } from './config.js';
+const c = DAY_NIGHT.colors;
+const color = (hex) => new THREE.Color(hex);
+const SKY_N = color(c.ambientSkyNight);
+const SKY_D = color(c.ambientSkyDay);
+const GRD_N = color(c.ambientGroundNight);
+const GRD_D = color(c.ambientGroundDay);
+const DIR_N = color(c.dirNight);
+const DIR_D = color(c.dirDay);
+const SUN_R = color(c.sunSunrise || 0xffa04a);
+const SUN_N = color(c.sunNoon || 0xfff1cc);
+const FOG_N = color(c.fogNight);
+const FOG_D = color(c.fogDay);
+const BG_N = color(c.bgNight);
+const BG_D = color(c.bgDay);
+// Reusable colors to avoid allocs each frame
+const tmpA = new THREE.Color();
+const tmpB = new THREE.Color();
+function clamp01(x){ return Math.max(0, Math.min(1, x)); }
+// Returns [dayFactor, nightFactor]
+function dayNightFactors(t) {
+  // Cosine-based curve: 1 at noon, 0 at midnight
+  const day = 0.5 - 0.5 * Math.cos(2 * Math.PI * t);
+  const night = 1 - day;
+  return [day, night];
+}
+export function updateDayNight(delta) {
+  if (!DAY_NIGHT.enabled) return;
+  // Advance time
+  const len = Math.max(10, DAY_NIGHT.lengthSec);
+  G.timeOfDay = (G.timeOfDay + delta / len) % 1;
+  const [dayF, nightF] = dayNightFactors(G.timeOfDay);
+  // Intensities
+  const ambI = DAY_NIGHT.nightAmbient * nightF + DAY_NIGHT.dayAmbient * dayF;
+  const sunI = DAY_NIGHT.dayKey * dayF;
+  const moonI = DAY_NIGHT.nightKey * nightF;
+  const fogD = DAY_NIGHT.nightFogDensity * nightF + DAY_NIGHT.dayFogDensity * dayF;
+  // Colors
+  tmpA.copy(SKY_N).lerp(SKY_D, dayF);
+  if (G.ambientLight) {
+    G.ambientLight.intensity = ambI;
+    G.ambientLight.color.copy(tmpA);
+    tmpB.copy(GRD_N).lerp(GRD_D, dayF);
+    // HemisphereLight has groundColor
+    G.ambientLight.groundColor.copy(tmpB);
+  }
+  // Compute sun/moon directions along an arced path
+  // Noon at t=0.5, midnight at t=0.0, use phi in [-pi, pi]
+  const phi = (G.timeOfDay - 0.25) * Math.PI * 2; // -pi/2 at t=0, +pi/2 at t=0.5
+  const sunDir = new THREE.Vector3(0, Math.sin(phi), Math.cos(phi)); // YZ plane
+  // Apply yaw tilt
+  const tilt = THREE.MathUtils.degToRad(DAY_NIGHT.sunTiltDeg || 0);
+  sunDir.applyAxisAngle(new THREE.Vector3(0, 1, 0), tilt).normalize();
+  const moonDir = sunDir.clone().multiplyScalar(-1);
+  // Update sun light
+  if (G.sunLight) {
+    G.sunLight.intensity = sunI;
+    // Sun tint warms near horizon and whites near zenith
+    const elev = Math.max(0, sunDir.y);
+    const warmT = Math.pow(elev, 0.75);
+    tmpA.copy(SUN_R).lerp(SUN_N, warmT);
+    G.sunLight.color.copy(tmpA);
+    const dist = DAY_NIGHT.sunDistance || 200;
+    G.sunLight.position.copy(sunDir).multiplyScalar(dist);
+    if (G.sunLight.target) G.sunLight.target.position.set(0, 0, 0);
+    G.sunLight.visible = sunI > 0.01;
+  }
+  // Update moon light
+  if (G.moonLight) {
+    G.moonLight.intensity = moonI;
+    G.moonLight.color.copy(DIR_N);
+    const distM = DAY_NIGHT.moonDistance || 200;
+    G.moonLight.position.copy(moonDir).multiplyScalar(distM);
+    if (G.moonLight.target) G.moonLight.target.position.set(0, 0, 0);
+    G.moonLight.visible = moonI > 0.01;
+  }
+  // Sun/moon sprites
+  if (G.sunSprite) {
+    const d = DAY_NIGHT.sunDistance || 200;
+    G.sunSprite.position.copy(sunDir).multiplyScalar(d);
+    // Match sprite tint to sun light color and boost opacity with day
+    const elev = Math.max(0, sunDir.y);
+    const warmT = Math.pow(elev, 0.75);
+    tmpA.copy(SUN_R).lerp(SUN_N, warmT);
+    G.sunSprite.material.color.copy(tmpA);
+    G.sunSprite.material.opacity = 0.65 + 0.35 * dayF;
+    G.sunSprite.visible = sunDir.y > 0.02; // only above horizon
+  }
+  if (G.moonSprite) {
+    const d = DAY_NIGHT.moonDistance || 200;
+    G.moonSprite.position.copy(moonDir).multiplyScalar(d);
+    G.moonSprite.material.opacity = 0.5 + 0.3 * nightF;
+    G.moonSprite.visible = moonDir.y > 0.02; // only above horizon
+  }
+  tmpA.copy(FOG_N).lerp(FOG_D, dayF);
+  if (G.scene && G.scene.fog) {
+    G.scene.fog.color.copy(tmpA);
+    G.scene.fog.density = fogD;
+  }
+  tmpA.copy(BG_N).lerp(BG_D, dayF);
+  if (G.scene && G.scene.background) {
+    G.scene.background.copy(tmpA);
+  }
+}

src/enemies.js ADDED Viewed

	@@ -0,0 +1,335 @@

+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';
+// Reusable temps
+const TMPv1 = new THREE.Vector3();
+const TMPv2 = new THREE.Vector3();
+const TMPv3 = new THREE.Vector3();
+const ORIGIN = new THREE.Vector3();
+const TO_PLAYER = new THREE.Vector3();
+const START = new THREE.Vector3();
+const TARGET = new THREE.Vector3();
+// Shared materials for enemies
+const MAT = {
+  skin: new THREE.MeshStandardMaterial({ color: 0x5a8f3a, roughness: 0.9 }),
+  tunic: new THREE.MeshStandardMaterial({ color: 0x3b2f1c, roughness: 0.85 }),
+  pants: new THREE.MeshStandardMaterial({ color: 0x2b2b2b, roughness: 0.9 }),
+  metal: new THREE.MeshStandardMaterial({ color: 0x888888, metalness: 0.35, roughness: 0.4 }),
+  leather: new THREE.MeshStandardMaterial({ color: 0x6a3e1b, roughness: 0.8 }),
+  silver: new THREE.MeshStandardMaterial({ color: 0xcfd3d6, metalness: 0.95, roughness: 0.25 })
+};
+// Also share per-enemy odds-and-ends that were previously recreated
+const RIVET_MAT = new THREE.MeshStandardMaterial({ color: 0xb0b4b8, metalness: 0.8, roughness: 0.3 });
+const STRING_MAT = new THREE.LineBasicMaterial({ color: 0xffffff });
+function ballisticVelocity(start, target, speed, gravity, preferHigh = false) {
+  const disp = TMPv1.subVectors(target, start);
+  const dxz = Math.hypot(disp.x, disp.z);
+  if (dxz < 0.0001) return null;
+  const v2 = speed * speed;
+  const g = gravity;
+  const y = disp.y;
+  const under = v2 * v2 - g * (g * dxz * dxz + 2 * y * v2);
+  if (under < 0) return null; // no ballistic solution at this speed
+  const root = Math.sqrt(under);
+  const tan1 = (v2 + (preferHigh ? +root : -root)) / (g * dxz);
+  const cos = 1 / Math.sqrt(1 + tan1 * tan1);
+  const sin = tan1 * cos;
+  const vxz = speed * cos;
+  const vy = speed * sin;
+  const hdir = TMPv2.set(disp.x, 0, disp.z).normalize();
+  return hdir.multiplyScalar(vxz).add(TMPv3.set(0, vy, 0));
+}
+export function spawnEnemy() {
+  // Spawn near a single wave anchor, not around center
+  const halfSize = CFG.forestSize / 2;
+  const anchor = G.waves.spawnAnchor || new THREE.Vector3(
+    (G.random() - 0.5) * (CFG.forestSize - 40), 0, (G.random() - 0.5) * (CFG.forestSize - 40)
+  );
+  // jitter around anchor (avoid exact center of map)
+  let x = 0, z = 0;
+  {
+    let tries = 0;
+    while (tries++ < 6) {
+      const r = 8 + G.random() * 14;
+      const t = G.random() * Math.PI * 2;
+      x = anchor.x + Math.cos(t) * r;
+      z = anchor.z + Math.sin(t) * r;
+      if (Math.abs(x) <= halfSize && Math.abs(z) <= halfSize) break;
+    }
+    if (Math.abs(x) > halfSize || Math.abs(z) > halfSize) return;
+  }
+  // Create enemy mesh (orc with cute helmet + bow)
+  const enemyGroup = new THREE.Group();
+  const skin = MAT.skin;
+  const tunic = MAT.tunic;
+  const pants = MAT.pants;
+  const metal = MAT.metal;
+  const leather = MAT.leather;
+  const silver = MAT.silver;
+  // 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;
+  enemyGroup.add(torso);
+  // Silver armor: keep back plate + pauldrons; remove front plate for subtler look
+  const armorPieces = [];
+  {
+    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.userData = { enemy: null, hitZone: 'body' };
+    enemyGroup.add(backPlate); armorPieces.push(backPlate);
+    // Shoulder pauldrons (simple domes)
+    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' };
+    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' };
+    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' };
+    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' };
+    enemyGroup.add(buckle); armorPieces.push(buckle);
+    // Small rivets on back plate corners only
+    const rivetGeo = new THREE.SphereGeometry(0.04, 8, 6);
+    const rivets = [
+      new THREE.Vector3(-0.34, 1.64, 0.26),  new THREE.Vector3(0.34, 1.64, 0.26),
+      new THREE.Vector3(-0.34, 1.06, 0.26),  new THREE.Vector3(0.34, 1.06, 0.26)
+    ];
+    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' };
+      enemyGroup.add(r); armorPieces.push(r);
+    }
+  }
+  // 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;
+  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;
+  // 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);
+  // 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);
+  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);
+  // 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);
+  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);
+  // Bow (curved torus segment + string) held slightly forward on left side
+  const bowGroup = new THREE.Group();
+  const bow = new THREE.Mesh(
+    new THREE.TorusGeometry(0.45, 0.03, 8, 24, Math.PI * 0.9),
+    leather
+  );
+  bow.rotation.z = Math.PI / 2; // orient curve
+  bowGroup.add(bow);
+  const stringGeo = new THREE.BufferGeometry().setFromPoints([
+    new THREE.Vector3(0, -0.42, 0), new THREE.Vector3(0, 0.42, 0)
+  ]);
+  const string = new THREE.Line(stringGeo, STRING_MAT);
+  bowGroup.add(string);
+  bowGroup.position.set(-0.32, 1.35, -0.35);
+  enemyGroup.add(bowGroup);
+  // Arrow spawn point near top-tip of bow, facing forwards
+  const projectileSpawn = new THREE.Object3D();
+  projectileSpawn.position.set(-0.32, 1.35, -0.55);
+  enemyGroup.add(projectileSpawn);
+  enemyGroup.position.set(x, getTerrainHeight(x, z), z);
+  G.scene.add(enemyGroup);
+  // Tag hit zones for headshot logic
+  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' };
+  bow.userData = { enemy: null, hitZone: 'gear' };
+  const enemy = {
+    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,
+    helmetAttached: true
+  };
+  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;
+  bow.userData.enemy = enemy;
+  helmet.userData.enemy = enemy;
+  // Assign enemy to armor pieces so they count as body hits
+  for (const part of armorPieces) {
+    if (part && part.userData) part.userData.enemy = enemy;
+  }
+  G.enemies.push(enemy);
+  G.waves.aliveCount++;
+}
+export function updateEnemies(delta, onPlayerDeath) {
+  for (let i = G.enemies.length - 1; i >= 0; i--) {
+    const enemy = G.enemies[i];
+    if (!enemy.alive) {
+      // Spawn a quick dust puff at death position, then despawn
+      spawnDustAt(enemy.pos);
+      enemy.mesh.traverse((obj) => {
+        if (obj.isMesh && obj.geometry && obj.geometry.dispose) {
+          obj.geometry.dispose();
+        }
+      });
+      G.scene.remove(enemy.mesh);
+      G.enemies.splice(i, 1);
+      continue;
+    }
+    // Move towards player
+    const dir = G.tmpV1.copy(G.player.pos).sub(enemy.pos);
+    dir.y = 0;
+    const dist = dir.length();
+    if (dist > 0) {
+      dir.normalize();
+      const moveSpeed = enemy.baseSpeed * delta;
+      enemy.pos.add(dir.multiplyScalar(moveSpeed));
+      // Simple tree avoidance
+      for (const tree of G.treeColliders) {
+        const dx = enemy.pos.x - tree.x;
+        const dz = enemy.pos.z - tree.z;
+        const treeDist = Math.sqrt(dx * dx + dz * dz);
+        const minDist = enemy.radius + tree.radius;
+        if (treeDist < minDist && treeDist > 0) {
+          const pushX = (dx / treeDist) * (minDist - treeDist);
+          const pushZ = (dz / treeDist) * (minDist - treeDist);
+          enemy.pos.x += pushX;
+          enemy.pos.z += pushZ;
+        }
+      }
+    }
+    // Stick to terrain height
+    enemy.pos.y = getTerrainHeight(enemy.pos.x, enemy.pos.z);
+    // Attack player (ranged) and optional contact damage when very close
+    enemy.shootCooldown -= delta;
+    // 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);
+          }
+        }
+      }
+    }
+    // Contact damage if very close
+    if (dist < G.player.radius + enemy.radius) {
+      const dmg = enemy.damagePerSecond * delta * 0.5; // reduced to stack less with ranged
+      G.player.health -= dmg;
+      G.damageFlash = Math.min(1, G.damageFlash + dmg * CFG.hud.damagePulsePerHP);
+      if (G.player.health <= 0) {
+        G.player.health = 0;
+        G.player.alive = false;
+        if (onPlayerDeath) onPlayerDeath();
+      }
+    }
+    // Look at player
+    enemy.mesh.lookAt(G.player.pos.x, enemy.pos.y + 1.4, G.player.pos.z);
+  }
+}

src/events.js ADDED Viewed

	@@ -0,0 +1,101 @@

+import { G } from './globals.js';
+import { CFG } from './config.js';
+import { showOverlay } from './hud.js';
+import { initAudio, resumeAudio } from './audio.js';
+export function setupEvents({ startGame, restartGame, beginReload, updateWeaponAnchor }) {
+  const overlay = document.getElementById('overlay');
+  if (!overlay) return;
+  overlay.addEventListener('click', () => {
+    // Initialize audio on user gesture
+    initAudio();
+    if (G.state === 'menu') {
+      G.controls.lock();
+    } else if (G.state === 'paused') {
+      G.controls.lock();
+    }
+  });
+  G.controls.addEventListener('lock', () => {
+    if (G.state === 'menu') {
+      startGame();
+    } else if (G.state === 'paused') {
+      G.state = 'playing';
+      overlay.classList.add('hidden');
+    }
+  });
+  G.controls.addEventListener('unlock', () => {
+    if (G.state === 'playing') {
+      G.state = 'paused';
+      showOverlay('paused');
+    }
+  });
+  document.addEventListener('keydown', (e) => {
+    switch (e.code) {
+      case 'KeyW': G.input.w = true; break;
+      case 'KeyA': G.input.a = true; break;
+      case 'KeyS': G.input.s = true; break;
+      case 'KeyD': G.input.d = true; break;
+      case 'ShiftLeft': G.input.sprint = true; break;
+      case 'Space':
+        if (G.state === 'playing' && G.player.grounded) {
+          // Jump
+          G.player.yVel = CFG.player.jumpVel;
+          G.player.grounded = false;
+        }
+        break;
+      case 'KeyF':
+        if (G.state === 'playing' && G.flashlight) {
+          G.flashlight.visible = !G.flashlight.visible;
+        }
+        break;
+      case 'KeyP':
+      case 'Escape':
+        if (G.state === 'playing') {
+          G.controls.unlock();
+        }
+        break;
+      case 'KeyR':
+        if (G.state === 'playing') {
+          beginReload();
+        } else if (G.state === 'gameover') {
+          restartGame();
+        }
+        break;
+    }
+  });
+  document.addEventListener('keyup', (e) => {
+    switch (e.code) {
+      case 'KeyW': G.input.w = false; break;
+      case 'KeyA': G.input.a = false; break;
+      case 'KeyS': G.input.s = false; break;
+      case 'KeyD': G.input.d = false; break;
+      case 'ShiftLeft': G.input.sprint = false; break;
+    }
+  });
+  document.addEventListener('mousedown', (e) => {
+    if (e.button === 0 && G.state === 'playing') {
+      // Ensure audio context is running on interaction
+      resumeAudio();
+      G.input.shoot = true;
+    }
+  });
+  document.addEventListener('mouseup', (e) => {
+    if (e.button === 0) {
+      G.input.shoot = false;
+    }
+  });
+  window.addEventListener('resize', () => {
+    G.camera.aspect = window.innerWidth / window.innerHeight;
+    G.camera.updateProjectionMatrix();
+    G.renderer.setSize(window.innerWidth, window.innerHeight);
+    updateWeaponAnchor();
+  });
+}

src/fx.js ADDED Viewed

	@@ -0,0 +1,137 @@

+import * as THREE from 'three';
+import { CFG } from './config.js';
+import { G } from './globals.js';
+export function spawnTracer(from, to) {
+  const geo = new THREE.BufferGeometry().setFromPoints([from.clone(), to.clone()]);
+  const mat = new THREE.LineBasicMaterial({ color: 0xffffff, transparent: true, opacity: 0.85, depthTest: false });
+  const line = new THREE.Line(geo, mat);
+  line.renderOrder = 9;
+  G.scene.add(line);
+  G.fx.tracers.push({ mesh: line, life: CFG.fx.tracerLife });
+}
+export function spawnTracerColored(from, to, color = 0xff4444, opacity = 0.85) {
+  const geo = new THREE.BufferGeometry().setFromPoints([from.clone(), to.clone()]);
+  const mat = new THREE.LineBasicMaterial({ color, transparent: true, opacity, depthTest: false });
+  const line = new THREE.Line(geo, mat);
+  line.renderOrder = 9;
+  G.scene.add(line);
+  G.fx.tracers.push({ mesh: line, life: CFG.fx.tracerLife });
+}
+export function spawnImpact(point, normal) {
+  const plane = new THREE.Mesh(
+    new THREE.PlaneGeometry(0.15, 0.15),
+    new THREE.MeshBasicMaterial({ color: 0xffbb55, transparent: true, opacity: 0.9, depthTest: true })
+  );
+  plane.position.copy(point);
+  plane.lookAt(G.camera.position);
+  G.scene.add(plane);
+  G.fx.impacts.push({ mesh: plane, life: CFG.fx.impactLife });
+}
+export function spawnMuzzleFlash() {
+  if (!G.weapon.muzzle) return;
+  const quad = new THREE.Mesh(
+    new THREE.PlaneGeometry(0.2, 0.2),
+    new THREE.MeshBasicMaterial({ color: 0xffe070, transparent: true, opacity: 1.0, depthTest: false })
+  );
+  G.weapon.muzzle.getWorldPosition(quad.position);
+  quad.lookAt(G.camera.position);
+  quad.renderOrder = 11;
+  G.scene.add(quad);
+  const light = new THREE.PointLight(0xfff2b0, 7, 6, 2);
+  light.position.copy(quad.position);
+  G.scene.add(light);
+  G.fx.flashes.push({ mesh: quad, light, life: CFG.fx.muzzleLife });
+}
+export function spawnMuzzleFlashAt(worldPos, color = 0xffc060) {
+  const quad = new THREE.Mesh(
+    new THREE.PlaneGeometry(0.18, 0.18),
+    new THREE.MeshBasicMaterial({ color, transparent: true, opacity: 1.0, depthTest: false })
+  );
+  quad.position.copy(worldPos);
+  quad.lookAt(G.camera.position);
+  quad.renderOrder = 11;
+  G.scene.add(quad);
+  const light = new THREE.PointLight(color, 5.5, 5, 2);
+  light.position.copy(worldPos);
+  G.scene.add(light);
+  G.fx.flashes.push({ mesh: quad, light, life: CFG.fx.muzzleLife });
+}
+// Quick, subtle dust puff at a world position
+export function spawnDustAt(worldPos, color = 0xcdbf9e, size = 0.55, life = 0.14) {
+  const quad = new THREE.Mesh(
+    new THREE.PlaneGeometry(size, size),
+    new THREE.MeshBasicMaterial({ color, transparent: true, opacity: 0.85, depthTest: true })
+  );
+  quad.position.copy(worldPos);
+  quad.position.y += 0.15; // lift slightly off the ground
+  quad.lookAt(G.camera.position);
+  quad.renderOrder = 8;
+  G.scene.add(quad);
+  G.fx.dusts.push({ mesh: quad, life, maxLife: life });
+}
+export function updateFX(delta) {
+  for (let i = G.fx.tracers.length - 1; i >= 0; i--) {
+    const t = G.fx.tracers[i];
+    t.life -= delta;
+    t.mesh.material.opacity = Math.max(0, t.life / CFG.fx.tracerLife);
+    if (t.life <= 0) {
+      G.scene.remove(t.mesh);
+      t.mesh.geometry.dispose();
+      if (t.mesh.material && t.mesh.material.dispose) t.mesh.material.dispose();
+      G.fx.tracers.splice(i, 1);
+    }
+  }
+  for (let i = G.fx.impacts.length - 1; i >= 0; i--) {
+    const s = G.fx.impacts[i];
+    s.life -= delta;
+    s.mesh.material.opacity = Math.max(0, s.life / CFG.fx.impactLife);
+    s.mesh.scale.setScalar(1 + (1 - s.life / CFG.fx.impactLife) * 0.5);
+    if (s.life <= 0) {
+      G.scene.remove(s.mesh);
+      s.mesh.geometry.dispose();
+      if (s.mesh.material && s.mesh.material.dispose) s.mesh.material.dispose();
+      G.fx.impacts.splice(i, 1);
+    }
+  }
+  for (let i = G.fx.flashes.length - 1; i >= 0; i--) {
+    const m = G.fx.flashes[i];
+    m.life -= delta;
+    m.mesh.material.opacity = Math.max(0, m.life / CFG.fx.muzzleLife);
+    m.mesh.scale.setScalar(1 + (1 - m.life / CFG.fx.muzzleLife) * 0.6);
+    if (m.light) m.light.intensity = 3 + 4 * (m.life / CFG.fx.muzzleLife);
+    if (m.life <= 0) {
+      G.scene.remove(m.mesh);
+      if (m.light) G.scene.remove(m.light);
+      m.mesh.geometry.dispose();
+      if (m.mesh.material && m.mesh.material.dispose) m.mesh.material.dispose();
+      G.fx.flashes.splice(i, 1);
+    }
+  }
+  // Dust puffs: very short-lived billboards that expand and fade
+  for (let i = G.fx.dusts.length - 1; i >= 0; i--) {
+    const d = G.fx.dusts[i];
+    d.life -= delta;
+    const t = Math.max(0, d.life / d.maxLife);
+    d.mesh.material.opacity = t;
+    d.mesh.scale.setScalar(1 + (1 - t) * 0.8);
+    d.mesh.lookAt(G.camera.position);
+    if (d.life <= 0) {
+      G.scene.remove(d.mesh);
+      d.mesh.geometry.dispose();
+      if (d.mesh.material && d.mesh.material.dispose) d.mesh.material.dispose();
+      G.fx.dusts.splice(i, 1);
+    }
+  }
+}

src/globals.js ADDED Viewed

	@@ -0,0 +1,97 @@

+import * as THREE from 'three';
+// Centralized mutable game state shared across modules
+export const G = {
+  renderer: null,
+  scene: null,
+  camera: null,
+  controls: null,
+  clock: null,
+  state: 'menu',
+  ground: null,
+  flashlight: null,
+  sunLight: null,
+  moonLight: null,
+  sunSprite: null,
+  moonSprite: null,
+  ambientLight: null,
+  // Lightweight sky clouds
+  clouds: [],
+  // Foliage chunk refs for LOD/culling
+  foliage: { grass: [], flowers: [] },
+  mountains: null,
+  input: {
+    w: false,
+    a: false,
+    s: false,
+    d: false,
+    shoot: false,
+    sprint: false,
+    jump: false
+  },
+  player: null, // initialized in main
+  enemies: [],
+  treeColliders: [],
+  treeMeshes: [],
+  // Static blockers array for raycasting (ground + trees)
+  blockers: [],
+  shootCooldown: 0,
+  raycaster: new THREE.Raycaster(),
+  tmpV1: new THREE.Vector3(),
+  tmpV2: new THREE.Vector3(),
+  tmpV3: new THREE.Vector3(),
+  weapon: {
+    group: null,
+    muzzle: null,
+    basePos: new THREE.Vector3(),
+    baseRot: new THREE.Euler(0, 0, 0),
+    recoil: 0,
+    swayT: 0,
+    ammo: 0,
+    reserve: Infinity,
+    reloading: false,
+    reloadTimer: 0,
+    anchor: { depth: 0.92, right: 0.48, bottom: 0.42 },
+    // Dynamic aim spread (NDC units) and helpers
+    spread: 0,
+    targetSpread: 0,
+    // View recoil offsets applied to camera (radians)
+    viewPitch: 0,
+    viewYaw: 0,
+    appliedPitch: 0,
+    appliedYaw: 0
+  },
+  fx: { tracers: [], impacts: [], flashes: [], dusts: [] },
+  enemyProjectiles: [],
+  // Health orbs and other pickups
+  orbs: [],
+  // Ejected shell casings
+  casings: [],
+  // Detached props (helmets) with simple physics
+  helmets: [],
+  damageFlash: 0,
+  healFlash: 0,
+  waves: {
+    current: 1,
+    aliveCount: 0,
+    spawnQueue: 0,
+    nextSpawnTimer: 0,
+    breakTimer: 0,
+    inBreak: false,
+    spawnAnchor: null
+  },
+  random: null,
+  // Day/night cycle
+  timeOfDay: 0.25 // 0..1, where ~0.5 is noon
+};

src/helmets.js ADDED Viewed

	@@ -0,0 +1,117 @@

+import * as THREE from 'three';
+import { G } from './globals.js';
+import { getTerrainHeight } from './world.js';
+// Pop the enemy's helmet off and add simple physics so it drops to ground
+export function popHelmet(enemy, impulseDir = new THREE.Vector3(0, 1, 0), hitPoint = null) {
+  if (!enemy || !enemy.helmet || !enemy.helmetAttached) return;
+  const h = enemy.helmet;
+  // Get world transform before detaching
+  const worldPos = new THREE.Vector3();
+  const worldQuat = new THREE.Quaternion();
+  const worldScale = new THREE.Vector3();
+  h.updateMatrixWorld();
+  h.getWorldPosition(worldPos);
+  h.getWorldQuaternion(worldQuat);
+  h.getWorldScale(worldScale);
+  // Detach from enemy and add to scene root
+  if (h.parent) h.parent.remove(h);
+  h.position.copy(worldPos);
+  h.quaternion.copy(worldQuat);
+  h.scale.copy(worldScale);
+  G.scene.add(h);
+  // It should no longer count as enemy geometry for ray hits
+  if (h.userData) {
+    h.userData.enemy = null;
+    h.userData.hitZone = null;
+    h.userData.isHelmet = true;
+  }
+  // Initial velocity: away from shot direction with a fun hop up
+  const dir = impulseDir.clone().normalize();
+  const upBoost = 3 + G.random() * 1.5;
+  const sideJitter = new THREE.Vector3((G.random() - 0.5) * 1.5, 0, (G.random() - 0.5) * 1.5);
+  const vel = dir.multiplyScalar(2.2).add(new THREE.Vector3(0, upBoost, 0)).add(sideJitter);
+  // Angular velocity for comedic spin
+  const angVel = new THREE.Vector3(
+    (G.random() - 0.5) * 6,
+    (G.random() - 0.5) * 8,
+    (G.random() - 0.5) * 6
+  );
+  G.helmets.push({
+    mesh: h,
+    pos: h.position,
+    vel,
+    angVel,
+    life: 12, // fade after a while
+    grounded: false
+  });
+  enemy.helmetAttached = false;
+}
+export function updateHelmets(delta) {
+  const gravity = 14; // stronger than arrows for punchy drop
+  const bounce = 0.35;
+  for (let i = G.helmets.length - 1; i >= 0; i--) {
+    const h = G.helmets[i];
+    // Integrate
+    h.vel.y -= gravity * delta;
+    h.pos.addScaledVector(h.vel, delta);
+    // Simple rotation integration
+    if (h.angVel) {
+      h.mesh.rotateX(h.angVel.x * delta);
+      h.mesh.rotateY(h.angVel.y * delta);
+      h.mesh.rotateZ(h.angVel.z * delta);
+    }
+    // Ground collision and bounce against terrain
+    const groundY = getTerrainHeight(h.pos.x, h.pos.z);
+    if (h.pos.y <= groundY) {
+      if (!h.grounded) {
+        // First impact gets a stronger bounce
+        h.grounded = true;
+      }
+      h.pos.y = groundY;
+      if (Math.abs(h.vel.y) > 0.4) {
+        h.vel.y = -h.vel.y * bounce;
+      } else {
+        h.vel.y = 0;
+      }
+      // Friction on ground
+      h.vel.x *= 0.7;
+      h.vel.z *= 0.7;
+      // Damp spin as it settles
+      if (h.angVel) h.angVel.multiplyScalar(0.8);
+      if (Math.hypot(h.vel.x, h.vel.z) < 0.2 && Math.abs(h.vel.y) < 0.2) {
+        h.vel.set(0, 0, 0);
+        if (h.angVel) h.angVel.set(0, 0, 0);
+      }
+    }
+    // Lifetime fade/cleanup
+    h.life -= delta;
+    if (h.life <= 2) {
+      const m = h.mesh.material;
+      if (m && m.opacity !== undefined) {
+        m.transparent = true;
+        m.opacity = Math.max(0, h.life / 2);
+      }
+    }
+    if (h.life <= 0) {
+      // Dispose per-helmet geometries
+      h.mesh.traverse((obj) => { if (obj.isMesh && obj.geometry?.dispose) obj.geometry.dispose(); });
+      G.scene.remove(h.mesh);
+      G.helmets.splice(i, 1);
+    }
+  }
+}

src/hud.js ADDED Viewed

	@@ -0,0 +1,145 @@

+import { G } from './globals.js';
+import { CFG } from './config.js';
+// Cache HUD element refs and last values to minimize DOM churn
+const HUD = {
+  waveEl: /** @type {HTMLElement|null} */(document.getElementById('wave')),
+  scoreEl: /** @type {HTMLElement|null} */(document.getElementById('score')),
+  enemiesEl: /** @type {HTMLElement|null} */(document.getElementById('enemies')),
+  ammoEl: /** @type {HTMLElement|null} */(document.getElementById('ammo')),
+  healthText: /** @type {HTMLElement|null} */(document.getElementById('health-text')),
+  healthFill: /** @type {HTMLElement|null} */(document.getElementById('health-fill')),
+  ch: {
+    root: /** @type {HTMLElement|null} */(document.getElementById('crosshair')),
+    left: /** @type {HTMLElement|null} */(document.getElementById('ch-left')),
+    right: /** @type {HTMLElement|null} */(document.getElementById('ch-right')),
+    top: /** @type {HTMLElement|null} */(document.getElementById('ch-top')),
+    bottom: /** @type {HTMLElement|null} */(document.getElementById('ch-bottom')),
+    lastGap: -1,
+    lastLen: -1
+  },
+  last: {
+    hp: -1,
+    hpPct: -1,
+    wave: -1,
+    score: -1,
+    enemies: -1,
+    ammo: '',
+  }
+};
+export function updateHUD() {
+  const hp = Math.ceil(G.player.health);
+  const hpPct = Math.max(0, Math.min(1, G.player.health / CFG.player.health));
+  if (hp !== HUD.last.hp) {
+    HUD.last.hp = hp;
+    if (HUD.healthText) HUD.healthText.textContent = String(hp);
+  }
+  if (Math.abs(hpPct - HUD.last.hpPct) > 0.005) {
+    HUD.last.hpPct = hpPct;
+    if (HUD.healthFill) HUD.healthFill.style.width = ((hpPct * 100) | 0) + '%';
+  }
+  if (G.waves.current !== HUD.last.wave) {
+    HUD.last.wave = G.waves.current;
+    if (HUD.waveEl) HUD.waveEl.textContent = String(G.waves.current);
+  }
+  if (G.player.score !== HUD.last.score) {
+    HUD.last.score = G.player.score;
+    if (HUD.scoreEl) HUD.scoreEl.textContent = String(G.player.score);
+  }
+  if (G.waves.aliveCount !== HUD.last.enemies) {
+    HUD.last.enemies = G.waves.aliveCount;
+    if (HUD.enemiesEl) HUD.enemiesEl.textContent = String(G.waves.aliveCount);
+  }
+  const reserveText = G.weapon.reserve === Infinity ? '∞' : String(G.weapon.reserve);
+  const ammoText = `${G.weapon.ammo}/${reserveText}`;
+  if (ammoText !== HUD.last.ammo) {
+    HUD.last.ammo = ammoText;
+    if (HUD.ammoEl) HUD.ammoEl.textContent = ammoText;
+  }
+}
+export function showWaveBanner(text) {
+  const banner = document.getElementById('wave-banner');
+  if (!banner) return;
+  banner.textContent = text;
+  banner.classList.add('show');
+  setTimeout(() => banner.classList.remove('show'), 2000);
+}
+export function showOverlay(type) {
+  const overlay = document.getElementById('overlay');
+  const content = document.getElementById('overlay-content');
+  if (!overlay || !content) return;
+  overlay.classList.remove('hidden');
+  if (type === 'paused') {
+    content.innerHTML = `
+      <h1>Paused</h1>
+      <p>Click to Resume</p>
+    `;
+  } else if (type === 'gameover') {
+    content.innerHTML = `
+      <h1>You Died</h1>
+      <p>Score: ${G.player.score}</p>
+      <p>Wave: ${G.waves.current}</p>
+      <p>Press R to Restart</p>
+    `;
+  }
+}
+// Simple red damage overlay that fades over time
+export function updateDamageEffect(delta) {
+  const el = document.getElementById('damage-overlay');
+  if (!el) return;
+  // Fade
+  G.damageFlash = Math.max(0, G.damageFlash - CFG.hud.damageFadeSpeed * delta);
+  const opacity = Math.min(CFG.hud.damageMaxOpacity, G.damageFlash * CFG.hud.damageMaxOpacity);
+  el.style.opacity = String(opacity);
+}
+// Green heal overlay that fades over time
+export function updateHealEffect(delta) {
+  const el = document.getElementById('heal-overlay');
+  if (!el) return;
+  G.healFlash = Math.max(0, G.healFlash - CFG.hud.healFadeSpeed * delta);
+  const opacity = Math.min(CFG.hud.healMaxOpacity, G.healFlash * CFG.hud.healMaxOpacity);
+  el.style.opacity = String(opacity);
+}
+// Crosshair widening based on current spread
+export function updateCrosshair(delta) {
+  const { ch } = HUD;
+  if (!ch.root || !ch.left || !ch.right || !ch.top || !ch.bottom) return;
+  // Convert NDC spread to pixel gap (approximate using viewport width)
+  const ndc = Math.max(G.weapon.spread, CFG.gun.spreadMin || CFG.gun.bloom || 0);
+  const baseGap = 6; // px baseline gap
+  const gapPx = baseGap + ndc * 0.5 * window.innerWidth; // half-width maps NDC to px
+  const armLen = 10 + Math.min(20, ndc * window.innerWidth * 0.4); // grow a bit with spread
+  if (Math.abs(gapPx - ch.lastGap) < 0.5 && Math.abs(armLen - ch.lastLen) < 0.5) return;
+  ch.lastGap = gapPx;
+  ch.lastLen = armLen;
+  // Horizontal arms
+  ch.left.style.width = armLen + 'px';
+  ch.left.style.left = -(gapPx + armLen) + 'px';
+  ch.left.style.top = '-1px';
+  ch.right.style.width = armLen + 'px';
+  ch.right.style.left = gapPx + 'px';
+  ch.right.style.top = '-1px';
+  // Vertical arms
+  ch.top.style.height = armLen + 'px';
+  ch.top.style.top = -(gapPx + armLen) + 'px';
+  ch.top.style.left = '-1px';
+  ch.bottom.style.height = armLen + 'px';
+  ch.bottom.style.top = gapPx + 'px';
+  ch.bottom.style.left = '-1px';
+}

src/lighting.js ADDED Viewed

	@@ -0,0 +1,101 @@

+import * as THREE from 'three';
+import { CFG } from './config.js';
+import { G } from './globals.js';
+function makeRadialCircleTexture(size = 256, innerAlpha = 1, outerAlpha = 0) {
+  const canvas = document.createElement('canvas');
+  canvas.width = canvas.height = size;
+  const ctx = canvas.getContext('2d');
+  const r = size / 2;
+  ctx.clearRect(0, 0, size, size);
+  const grad = ctx.createRadialGradient(r, r, 0, r, r, r);
+  grad.addColorStop(0, `rgba(255,255,255,${innerAlpha})`);
+  grad.addColorStop(1, `rgba(255,255,255,${outerAlpha})`);
+  ctx.fillStyle = grad;
+  ctx.beginPath();
+  ctx.arc(r, r, r, 0, Math.PI * 2);
+  ctx.fill();
+  const tex = new THREE.CanvasTexture(canvas);
+  tex.generateMipmaps = false;
+  tex.minFilter = THREE.LinearFilter;
+  tex.magFilter = THREE.LinearFilter;
+  return tex;
+}
+export function setupLights() {
+  // Ambient
+  const ambientLight = new THREE.HemisphereLight(0x6a7f9a, 0x203050, 0.3);
+  G.scene.add(ambientLight);
+  G.ambientLight = ambientLight;
+  // Sun light (key during day)
+  const sun = new THREE.DirectionalLight(0xfff1cc, 1.2);
+  sun.position.set(0, 100, 0);
+  sun.castShadow = true;
+  sun.shadow.camera.left = -60;
+  sun.shadow.camera.right = 60;
+  sun.shadow.camera.top = 60;
+  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.target = new THREE.Object3D();
+  G.scene.add(sun);
+  G.scene.add(sun.target);
+  G.sunLight = sun;
+  // 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;
+  moon.target = new THREE.Object3D();
+  G.scene.add(moon);
+  G.scene.add(moon.target);
+  G.moonLight = moon;
+  // Simple sun sprite (billboard, round via radial alpha)
+  const sunTex = makeRadialCircleTexture(256, 1, 0);
+  const sunMat = new THREE.SpriteMaterial({ color: 0xfff1cc, map: sunTex, transparent: true, opacity: 0.95, depthTest: true, depthWrite: false, fog: false });
+  const sunSprite = new THREE.Sprite(sunMat);
+  sunSprite.scale.set(10, 10, 1);
+  sunSprite.renderOrder = 1;
+  G.scene.add(sunSprite);
+  G.sunSprite = sunSprite;
+  // Simple moon sprite
+  const moonTex = makeRadialCircleTexture(256, 1, 0);
+  const moonMat = new THREE.SpriteMaterial({ color: 0xaec7ff, map: moonTex, transparent: true, opacity: 0.8, depthTest: true, depthWrite: false, fog: false });
+  const moonSprite = new THREE.Sprite(moonMat);
+  moonSprite.scale.set(6, 6, 1);
+  moonSprite.renderOrder = 1;
+  G.scene.add(moonSprite);
+  G.moonSprite = moonSprite;
+  // Flashlight
+  const flashlight = new THREE.SpotLight(0xffffff, CFG.flashlight.intensity);
+  flashlight.angle = CFG.flashlight.angle;
+  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.shadow.camera.near = 0.1;
+  flashlight.shadow.camera.far = CFG.flashlight.distance;
+  flashlight.visible = CFG.flashlight.on;
+  G.camera.add(flashlight);
+  flashlight.position.set(0, 0, 0);
+  flashlight.target.position.set(0, 0, -1);
+  G.camera.add(flashlight.target);
+  G.scene.add(G.camera);
+  G.flashlight = flashlight;
+}

src/main.js ADDED Viewed

	@@ -0,0 +1,202 @@

+import * as THREE from 'three';
+import { PointerLockControls } from 'three/addons/controls/PointerLockControls.js';
+import { CFG } from './config.js';
+import { G } from './globals.js';
+import { makeRandom } from './utils.js';
+import { setupLights } from './lighting.js';
+import { setupGround, generateForest, generateGroundCover, getTerrainHeight, tickForest } from './world.js';
+import { setupWeapon, updateWeaponAnchor, beginReload, updateWeapon } from './weapon.js';
+import { setupEvents } from './events.js';
+import { updatePlayer } from './player.js';
+import { updateEnemies } from './enemies.js';
+import { startNextWave, updateWaves } from './waves.js';
+import { updateHUD, showOverlay, updateDamageEffect, updateHealEffect, updateCrosshair } from './hud.js';
+import { updateFX } from './fx.js';
+import { updateCasings } from './casings.js';
+import { updateEnemyProjectiles } from './projectiles.js';
+import { updateDayNight } from './daynight.js';
+import { performShooting } from './combat.js';
+import { updatePickups } from './pickups.js';
+import { updateHelmets } from './helmets.js';
+import { setupClouds, updateClouds } from './clouds.js';
+import { setupMountains, updateMountains } from './mountains.js';
+init();
+animate();
+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));
+  G.renderer.shadowMap.enabled = true;
+  G.renderer.shadowMap.type = THREE.PCFSoftShadowMap;
+  document.body.appendChild(G.renderer.domElement);
+  // Scene
+  G.scene = new THREE.Scene();
+  G.scene.background = new THREE.Color(0x0a1015);
+  G.scene.fog = new THREE.FogExp2(0x05070a, CFG.fogDensity);
+  // Camera
+  G.camera = new THREE.PerspectiveCamera(75, window.innerWidth / window.innerHeight, 0.1, 1000);
+  // Controls
+  G.controls = new PointerLockControls(G.camera, document.body);
+  // Clock
+  G.clock = new THREE.Clock();
+  // Seeded random
+  G.random = makeRandom(CFG.seed);
+  // Player
+  const startY = getTerrainHeight(0, 0) + 1.8;
+  G.player = {
+    pos: new THREE.Vector3(0, startY, 0),
+    vel: new THREE.Vector3(),
+    speed: CFG.player.speed,
+    radius: CFG.player.radius,
+    health: CFG.player.health,
+    alive: true,
+    score: 0,
+    yVel: 0,
+    grounded: true
+  };
+  G.weapon.ammo = CFG.gun.magSize;
+  G.weapon.reserve = Infinity;
+  // Add camera to scene
+  G.camera.position.copy(G.player.pos);
+  // Lights
+  setupLights();
+  // Ground and world
+  setupGround();
+  // Ground cover before or after trees — independent
+  generateGroundCover();
+  generateForest();
+  setupClouds();
+  setupMountains();
+  // Weapon
+  setupWeapon();
+  updateWeaponAnchor();
+  // Events
+  setupEvents({
+    startGame,
+    restartGame,
+    beginReload,
+    updateWeaponAnchor
+  });
+}
+function startGame() {
+  G.state = 'playing';
+  G.player.health = CFG.player.health;
+  G.player.score = 0;
+  G.player.alive = true;
+  G.player.pos.set(0, getTerrainHeight(0, 0) + 1.8, 0);
+  G.player.vel.set(0, 0, 0);
+  G.camera.position.copy(G.player.pos);
+  G.damageFlash = 0;
+  G.healFlash = 0;
+  // Clear enemies
+  for (const enemy of G.enemies) {
+    G.scene.remove(enemy.mesh);
+  }
+  G.enemies.length = 0;
+  // Clear enemy projectiles
+  for (const p of G.enemyProjectiles) {
+    G.scene.remove(p.mesh);
+  }
+  G.enemyProjectiles.length = 0;
+  // Clear pickups/orbs
+  for (const o of G.orbs) {
+    G.scene.remove(o.mesh);
+  }
+  G.orbs.length = 0;
+  // Clear any detached helmets
+  for (const h of G.helmets) {
+    G.scene.remove(h.mesh);
+  }
+  G.helmets.length = 0;
+  // Clear ejected casings
+  for (const c of G.casings) {
+    G.scene.remove(c.mesh);
+  }
+  G.casings.length = 0;
+  // Reset waves
+  G.waves.current = 1;
+  G.waves.aliveCount = 0;
+  G.waves.spawnQueue = 0;
+  G.waves.nextSpawnTimer = 0;
+  G.waves.breakTimer = 0;
+  G.waves.inBreak = false;
+  // Reset weapon
+  G.weapon.ammo = CFG.gun.magSize;
+  G.weapon.reloading = false;
+  G.weapon.reloadTimer = 0;
+  G.weapon.recoil = 0;
+  G.weapon.spread = CFG.gun.spreadMin ?? CFG.gun.bloom ?? 0;
+  G.weapon.targetSpread = G.weapon.spread;
+  G.weapon.viewPitch = 0;
+  G.weapon.viewYaw = 0;
+  G.weapon.appliedPitch = 0;
+  G.weapon.appliedYaw = 0;
+  const overlay = document.getElementById('overlay');
+  if (overlay) overlay.classList.add('hidden');
+  updateHUD();
+  // Initialize day/night visuals immediately
+  updateDayNight(0);
+  startNextWave();
+}
+function restartGame() {
+  G.controls.lock();
+}
+function gameOver() {
+  G.state = 'gameover';
+  G.controls.unlock();
+  showOverlay('gameover');
+}
+function animate() {
+  requestAnimationFrame(animate);
+  const delta = Math.min(G.clock.getDelta(), 0.1);
+  if (G.state === 'playing') {
+    updatePlayer(delta);
+    updateEnemies(delta, gameOver);
+    updateEnemyProjectiles(delta, gameOver);
+    updateWaves(delta);
+    performShooting(delta);
+    updateWeapon(delta);
+    updatePickups(delta);
+    updateHUD();
+    updateCrosshair(delta);
+    updateDamageEffect(delta);
+    updateHealEffect(delta);
+  }
+  updateDayNight(delta);
+  updateFX(delta);
+  updateHelmets(delta);
+  updateCasings(delta);
+  updateClouds(delta);
+  updateMountains(delta);
+  // Update subtle foliage wind sway using elapsedTime (avoid double-advancing clock)
+  tickForest(G.clock.elapsedTime);
+  G.renderer.render(G.scene, G.camera);
+}

src/mountains.js ADDED Viewed

	@@ -0,0 +1,133 @@

+import * as THREE from 'three';
+import { G } from './globals.js';
+import { MOUNTAINS } from './config.js';
+const COLOR_N = new THREE.Color(MOUNTAINS.colorNight);
+const COLOR_D = new THREE.Color(MOUNTAINS.colorDay);
+const TMP_COLOR = new THREE.Color();
+function dayFactor(t) {
+  return 0.5 - 0.5 * Math.cos(2 * Math.PI * t);
+}
+function buildMountainRing({ radius, segments, baseHeight, heightVar, yOffset }) {
+  const vertCount = segments * 2;
+  const positions = new Float32Array(vertCount * 3);
+  const colors = new Float32Array(vertCount * 3);
+  const aH = new Float32Array(vertCount); // 0 at bottom ring, 1 at peaks
+  const indices = new Uint16Array(segments * 6);
+  const colBottom = new THREE.Color(MOUNTAINS.colorBase);
+  const colTop = new THREE.Color(MOUNTAINS.colorPeak);
+  function ridge(a) {
+    const s1 = Math.sin(a * 3.0) * 0.7 + Math.sin(a * 7.0) * 0.3;
+    const s2 = Math.sin(a * 1.7 + 1.3) * 0.5 + Math.sin(a * 4.3 + 0.7) * 0.5;
+    const v = 0.5 * s1 + 0.5 * s2;
+    return baseHeight + heightVar * (0.5 + 0.5 * v);
+  }
+  for (let i = 0; i < segments; i++) {
+    const a0 = (i / segments) * Math.PI * 2;
+    const h = ridge(a0);
+    const x = Math.cos(a0) * radius;
+    const z = Math.sin(a0) * radius;
+    const iBot = i * 3;
+    positions[iBot + 0] = x;
+    positions[iBot + 1] = yOffset;
+    positions[iBot + 2] = z;
+    const iTop = (segments + i) * 3;
+    positions[iTop + 0] = x;
+    positions[iTop + 1] = yOffset + h;
+    positions[iTop + 2] = z;
+    colors[iBot + 0] = colBottom.r;
+    colors[iBot + 1] = colBottom.g;
+    colors[iBot + 2] = colBottom.b;
+    colors[iTop + 0] = colTop.r;
+    colors[iTop + 1] = colTop.g;
+    colors[iTop + 2] = colTop.b;
+    aH[i] = 0.0;                   // bottom vertex ratio
+    aH[segments + i] = 1.0;        // top vertex ratio
+  }
+  let idx = 0;
+  for (let i = 0; i < segments; i++) {
+    const n = (i + 1) % segments;
+    const b0 = i;
+    const b1 = n;
+    const t0 = segments + i;
+    const t1 = segments + n;
+    indices[idx++] = b0;
+    indices[idx++] = t0;
+    indices[idx++] = b1;
+    indices[idx++] = b1;
+    indices[idx++] = t0;
+    indices[idx++] = t1;
+  }
+  const geo = new THREE.BufferGeometry();
+  geo.setAttribute('position', new THREE.BufferAttribute(positions, 3));
+  geo.setAttribute('color', new THREE.BufferAttribute(colors, 3));
+  geo.setIndex(new THREE.BufferAttribute(indices, 1));
+  geo.setAttribute('aH', new THREE.BufferAttribute(aH, 1));
+  geo.computeBoundingSphere();
+  return geo;
+}
+export function setupMountains() {
+  if (!MOUNTAINS.enabled) return;
+  const geo = buildMountainRing({
+    radius: MOUNTAINS.radius,
+    segments: MOUNTAINS.segments,
+    baseHeight: MOUNTAINS.baseHeight,
+    heightVar: MOUNTAINS.heightVar,
+    yOffset: MOUNTAINS.yOffset
+  });
+  const mat = new THREE.MeshBasicMaterial({
+    color: new THREE.Color(MOUNTAINS.colorDay),
+    vertexColors: true,
+    fog: false,           // keep visible even in heavy fog
+    depthTest: true,
+    depthWrite: false,
+    side: THREE.DoubleSide, // ensure visible regardless of winding
+    transparent: true
+  });
+  mat.onBeforeCompile = (shader) => {
+    shader.uniforms.uFadeEdge = { value: MOUNTAINS.fadeEdge ?? 0.35 };
+    shader.uniforms.uFadePow = { value: MOUNTAINS.fadePow ?? 1.5 };
+    shader.vertexShader = (
+      'attribute float aH;\n' +
+      'varying float vH;\n' +
+      shader.vertexShader
+    ).replace(
+      '#include <begin_vertex>',
+      `#include <begin_vertex>\n vH = aH;`
+    );
+    shader.fragmentShader = (
+      'varying float vH;\n uniform float uFadeEdge; uniform float uFadePow;\n' +
+      shader.fragmentShader
+    ).replace(
+      '#include <dithering_fragment>',
+      `diffuseColor.a *= pow(smoothstep(uFadeEdge, 1.0, vH), uFadePow);\n#include <dithering_fragment>`
+    );
+  };
+  const mesh = new THREE.Mesh(geo, mat);
+  mesh.castShadow = false;
+  mesh.receiveShadow = false;
+  mesh.renderOrder = -10;
+  G.scene.add(mesh);
+  G.mountains = mesh;
+}
+export function updateMountains(delta) {
+  if (!MOUNTAINS.enabled || !G.mountains) return;
+  const p = G.player ? G.player.pos : G.camera.position;
+  G.mountains.position.set(p.x, 0, p.z);
+  const dayF = dayFactor(G.timeOfDay || 0);
+  TMP_COLOR.copy(COLOR_N).lerp(COLOR_D, dayF);
+  G.mountains.material.color.copy(TMP_COLOR);
+}

src/pickups.js ADDED Viewed

	@@ -0,0 +1,136 @@

+import * as THREE from 'three';
+import { G } from './globals.js';
+import { CFG } from './config.js';
+import { getTerrainHeight } from './world.js';
+// Share orb material to avoid per-orb material allocations
+const ORB_MAT = new THREE.MeshStandardMaterial({
+  color: 0x33ff66,
+  emissive: 0x1faa4e,
+  emissiveIntensity: 1.1,
+  roughness: 0.3,
+  metalness: 0.0
+});
+// 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)));
+  for (let i = 0; i < n; i++) {
+    const group = new THREE.Group();
+    // Slight radial scatter around center (tighter grouping)
+    const r = 0.12 + G.random() * 0.48; // was up to ~1.4
+    const t = G.random() * Math.PI * 2;
+    const startY = 0.9 + G.random() * 0.8; // spawn a bit in the air
+    group.position.set(
+      center.x + Math.cos(t) * r,
+      startY,
+      center.z + Math.sin(t) * r
+    );
+    const sphere = new THREE.Mesh(new THREE.SphereGeometry(0.12, 14, 12), ORB_MAT);
+    sphere.castShadow = true;
+    sphere.receiveShadow = false;
+    group.add(sphere);
+    // Soft green point light for glow
+    const light = new THREE.PointLight(0x33ff66, 0.9, 6, 2);
+    light.position.set(0, 0.1, 0);
+    group.add(light);
+    G.scene.add(group);
+    // Initial outward + upward velocity (reduced to keep grouping tighter)
+    const dir = new THREE.Vector3(Math.cos(t), 0, Math.sin(t));
+    const speed = 0.8 + G.random() * 1.4; // was up to ~4.8
+    const vel = dir.multiplyScalar(speed);
+    vel.y = 2.2 + G.random() * 1.6; // was up to ~5.5
+    const orb = {
+      mesh: group,
+      light,
+      pos: group.position,
+      radius: 0.7, // pickup radius
+      heal: 1,
+      bobT: G.random() * Math.PI * 2,
+      vel,
+      state: 'air', // 'air' | 'settled'
+      settleTimer: 0,
+      baseY: 0.2
+    };
+    G.orbs.push(orb);
+  }
+}
+export function updatePickups(delta) {
+  for (let i = G.orbs.length - 1; i >= 0; i--) {
+    const o = G.orbs[i];
+    // Simple physics: integrate while in air, bounce on ground, then settle to bob
+    if (o.state !== 'settled') {
+      // Gravity
+      if (o.vel) o.vel.y -= 18 * delta;
+      // Integrate
+      if (o.vel) o.pos.addScaledVector(o.vel, delta);
+      // Ground collision (sphere radius ~0.12)
+      const ground = getTerrainHeight(o.pos.x, o.pos.z);
+      const floor = ground + 0.12;
+      if (o.pos.y <= floor) {
+        o.pos.y = floor;
+        if (o.vel) {
+          const bounce = 0.35;
+          const friction = 10.0; // stronger horizontal damping for tighter spread
+          if (Math.abs(o.vel.y) > 0.6) {
+            o.vel.y = -o.vel.y * bounce;
+          } else {
+            o.vel.y = 0;
+          }
+          // Horizontal friction
+          const fr = Math.max(0, 1 - friction * delta);
+          o.vel.x *= fr;
+          o.vel.z *= fr;
+          // Settle detection
+          const horizSpeed = Math.hypot(o.vel.x, o.vel.z);
+          if (horizSpeed < 0.15 && Math.abs(o.vel.y) < 0.05) {
+            o.settleTimer += delta;
+            if (o.settleTimer > 0.15) {
+              o.state = 'settled';
+              o.baseY = ground + 0.2;
+              // Snap to a clean base height
+              o.pos.y = o.baseY;
+            }
+          } else {
+            o.settleTimer = 0;
+          }
+        }
+      }
+    }
+    // Visuals: rotation and glow pulse
+    o.bobT += delta * 2.0;
+    o.mesh.rotation.y += delta * 1.5;
+    if (o.light) o.light.intensity = 0.7 + 0.4 * (0.5 + 0.5 * Math.sin(o.bobT * 2.0));
+    // If settled, apply gentle bob around baseY
+    if (o.state === 'settled') {
+      o.pos.y = o.baseY + Math.sin(o.bobT) * 0.06;
+    }
+    // Pickup check (2D distance on ground plane)
+    const dx = o.pos.x - G.player.pos.x;
+    const dz = o.pos.z - G.player.pos.z;
+    const dist = Math.hypot(dx, dz);
+    const minDist = o.radius + G.player.radius;
+    if (dist <= minDist && G.player.alive && G.state === 'playing') {
+      G.player.health = Math.min(CFG.player.health, G.player.health + o.heal);
+      // Pulse green heal overlay
+      G.healFlash = Math.min(1, G.healFlash + CFG.hud.healPulsePerPickup + o.heal * CFG.hud.healPulsePerHP);
+      // Dispose unique geometries (materials are shared)
+      o.mesh.traverse((obj) => { if (obj.isMesh && obj.geometry?.dispose) obj.geometry.dispose(); });
+      G.scene.remove(o.mesh);
+      G.orbs.splice(i, 1);
+    }
+  }
+}

src/player.js ADDED Viewed

	@@ -0,0 +1,73 @@

+import * as THREE from 'three';
+import { CFG } from './config.js';
+import { G } from './globals.js';
+import { getTerrainHeight } from './world.js';
+const MOVE = new THREE.Vector3();
+const FWD = new THREE.Vector3();
+const RIGHT = new THREE.Vector3();
+const NEXT = new THREE.Vector3();
+export function updatePlayer(delta) {
+  if (!G.player.alive) return;
+  // Movement
+  MOVE.set(0, 0, 0);
+  G.camera.getWorldDirection(FWD);
+  FWD.y = 0;
+  FWD.normalize();
+  RIGHT.crossVectors(FWD, G.camera.up);
+  if (G.input.w) MOVE.add(FWD);
+  if (G.input.s) MOVE.sub(FWD);
+  if (G.input.a) MOVE.sub(RIGHT);
+  if (G.input.d) MOVE.add(RIGHT);
+  if (MOVE.length() > 0) {
+    MOVE.normalize();
+    const speed = G.player.speed * (G.input.sprint ? CFG.player.sprintMult : 1);
+    MOVE.multiplyScalar(speed * delta);
+  }
+  // Apply movement with collision
+  NEXT.copy(G.player.pos).add(MOVE);
+  // Tree collisions
+  for (const tree of G.treeColliders) {
+    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);
+      NEXT.x += pushX;
+      NEXT.z += pushZ;
+    }
+  }
+  // Bounds
+  const halfSize = CFG.forestSize / 2 - G.player.radius;
+  NEXT.x = Math.max(-halfSize, Math.min(halfSize, NEXT.x));
+  NEXT.z = Math.max(-halfSize, Math.min(halfSize, NEXT.z));
+  // Gravity
+  G.player.yVel -= 15 * delta; // gravity
+  NEXT.y += G.player.yVel * delta;
+  // Grounded against terrain height
+  const groundEye = getTerrainHeight(NEXT.x, NEXT.z) + 1.8;
+  if (NEXT.y <= groundEye) {
+    NEXT.y = groundEye;
+    G.player.yVel = 0;
+    G.player.grounded = true;
+  } else {
+    G.player.grounded = false;
+  }
+  G.player.pos.copy(NEXT);
+  G.camera.position.copy(G.player.pos);
+}

src/projectiles.js ADDED Viewed

	@@ -0,0 +1,123 @@

+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';
+// Shared arrow geometry/material to avoid per-shot allocations
+const ARROW = (() => {
+  const shaftGeo = new THREE.CylinderGeometry(0.03, 0.03, 0.9, 6);
+  const headGeo = new THREE.ConeGeometry(0.08, 0.2, 8);
+  const shaftMat = new THREE.MeshStandardMaterial({ color: 0xdeb887, roughness: 0.8 });
+  const headMat = new THREE.MeshStandardMaterial({ color: 0x9e9e9e, metalness: 0.2, roughness: 0.5 });
+  return { shaftGeo, headGeo, shaftMat, headMat };
+})();
+const UP = new THREE.Vector3(0, 1, 0);
+const TMPv = new THREE.Vector3();
+const TMPq = new THREE.Quaternion();
+// Spawns a visible enemy arrow projectile
+export function spawnEnemyArrow(start, dirOrVel, asVelocity = false) {
+  const speed = CFG.enemy.arrowSpeed;
+  // Arrow visual: shaft + head as a small cone (shared geos/materials)
+  const group = new THREE.Group();
+  const shaft = new THREE.Mesh(ARROW.shaftGeo, ARROW.shaftMat);
+  shaft.position.y = 0; // centered
+  shaft.castShadow = true; shaft.receiveShadow = true;
+  group.add(shaft);
+  const head = new THREE.Mesh(ARROW.headGeo, ARROW.headMat);
+  head.position.y = 0.55;
+  head.castShadow = true; head.receiveShadow = true;
+  group.add(head);
+  // Orient to direction (geometry points +Y by default)
+  const dir = TMPv.copy(dirOrVel).normalize();
+  TMPq.setFromUnitVectors(UP, dir);
+  group.quaternion.copy(TMPq);
+  group.position.copy(start);
+  G.scene.add(group);
+  const vel = asVelocity
+    ? dirOrVel.clone()
+    : TMPv.copy(dirOrVel).normalize().multiplyScalar(speed);
+  const projectile = {
+    mesh: group,
+    pos: group.position,
+    vel,
+    life: CFG.enemy.arrowLife
+  };
+  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;
+    p.pos.addScaledVector(p.vel, delta);
+    // Re-orient to velocity
+    const vdir = TMPv.copy(p.vel).normalize();
+    TMPq.setFromUnitVectors(UP, vdir);
+    p.mesh.quaternion.copy(TMPq);
+    p.life -= delta;
+    // Ground hit against terrain
+    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);
+      G.scene.remove(p.mesh);
+      G.enemyProjectiles.splice(i, 1);
+      continue;
+    }
+    // Tree collision (2D cylinder test)
+    for (const tree of G.treeColliders) {
+      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);
+        G.scene.remove(p.mesh);
+        G.enemyProjectiles.splice(i, 1);
+        continue;
+      }
+    }
+    // Player collision (sphere)
+    const pr = hitR + G.player.radius * 0.6; // slightly generous
+    if (p.pos.distanceTo(G.player.pos) < pr) {
+      const dmg = CFG.enemy.arrowDamage;
+      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) {
+        G.player.health = 0;
+        G.player.alive = false;
+        if (onPlayerDeath) onPlayerDeath();
+      }
+      spawnImpact(p.pos, UP);
+      G.scene.remove(p.mesh);
+      G.enemyProjectiles.splice(i, 1);
+      continue;
+    }
+    // Timeout
+    if (p.life <= 0) {
+      G.scene.remove(p.mesh);
+      G.enemyProjectiles.splice(i, 1);
+      continue;
+    }
+  }
+}

src/utils.js ADDED Viewed

	@@ -0,0 +1,11 @@

+// Seeded pseudo-random number generator (mulberry32)
+export function makeRandom(seed) {
+  let a = seed >>> 0;
+  return function random() {
+    let t = (a += 0x6D2B79F5);
+    t = Math.imul(t ^ (t >>> 15), t | 1);
+    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+  };
+}

src/waves.js ADDED Viewed

	@@ -0,0 +1,60 @@

+import * as THREE from 'three';
+import { CFG } from './config.js';
+import { G } from './globals.js';
+import { getTerrainHeight } from './world.js';
+import { showWaveBanner } from './hud.js';
+import { spawnEnemy } from './enemies.js';
+export function startNextWave() {
+  const waveCount = Math.min(
+    CFG.waves.baseCount + CFG.waves.perWaveAdd * (G.waves.current - 1),
+    CFG.waves.maxAlive
+  );
+  G.waves.spawnQueue = waveCount;
+  G.waves.nextSpawnTimer = 0;
+  // Choose a single spawn anchor for this wave (not near the center)
+  const half = CFG.forestSize / 2;
+  const margin = 24;
+  const minR = Math.max(CFG.waves.annulusMin, 40);
+  const maxR = Math.min(CFG.waves.annulusMax * 2.2, half - margin);
+  const angle = G.random() * Math.PI * 2;
+  const r = minR + G.random() * (maxR - minR);
+  const ax = Math.cos(angle) * r;
+  const az = Math.sin(angle) * r;
+  G.waves.spawnAnchor = new THREE.Vector3(ax, getTerrainHeight(ax, az), az);
+  showWaveBanner(`Wave ${G.waves.current}`);
+}
+export function updateWaves(delta) {
+  if (G.waves.inBreak) {
+    G.waves.breakTimer -= delta;
+    if (G.waves.breakTimer <= 0) {
+      G.waves.inBreak = false;
+      G.waves.current++;
+      startNextWave();
+    }
+    return;
+  }
+  // Spawn enemies
+  if (G.waves.spawnQueue > 0 && G.waves.aliveCount < CFG.waves.maxAlive) {
+    G.waves.nextSpawnTimer -= delta;
+    if (G.waves.nextSpawnTimer <= 0) {
+      spawnEnemy();
+      G.waves.spawnQueue--;
+      const spawnRate = Math.max(
+        CFG.waves.spawnMin,
+        CFG.waves.spawnEvery - CFG.waves.spawnDecay * (G.waves.current - 1)
+      );
+      G.waves.nextSpawnTimer = spawnRate;
+    }
+  }
+  // Check wave complete
+  if (G.waves.spawnQueue === 0 && G.waves.aliveCount === 0) {
+    G.waves.inBreak = true;
+    G.waves.breakTimer = CFG.waves.breakTime;
+  }
+}

src/weapon.js ADDED Viewed

	@@ -0,0 +1,235 @@

+import * as THREE from 'three';
+import { CFG } from './config.js';
+import { G } from './globals.js';
+import { updateHUD } from './hud.js';
+import { playReloadStart, playReloadEnd } from './audio.js';
+function computeWeaponBasePos() {
+  const d = G.weapon.anchor.depth;
+  const halfH = Math.tan(THREE.MathUtils.degToRad(G.camera.fov * 0.5)) * d;
+  const halfW = halfH * G.camera.aspect;
+  const x = halfW - G.weapon.anchor.right;
+  const y = -halfH + G.weapon.anchor.bottom;
+  return new THREE.Vector3(x, y, -d);
+}
+export function updateWeaponAnchor() {
+  G.weapon.basePos.copy(computeWeaponBasePos());
+  if (G.weapon.group) {
+    G.weapon.group.position.copy(G.weapon.basePos);
+    G.weapon.group.rotation.copy(G.weapon.baseRot);
+  }
+}
+export function setupWeapon() {
+  const makeVM = (color, metal = 0.4, rough = 0.6) => {
+    const m = new THREE.MeshStandardMaterial({ color, metalness: metal, roughness: rough });
+    m.fog = false;
+    m.depthTest = false;
+    return m;
+  };
+  const steel = makeVM(0x2a2d30, 0.8, 0.35);
+  const polymer = makeVM(0x1b1f23, 0.1, 0.8);
+  const tan = makeVM(0x7b6a4d, 0.2, 0.7);
+  const g = new THREE.Group();
+  g.renderOrder = 10;
+  g.castShadow = false;
+  g.receiveShadow = false;
+  const handguardL = 0.62;
+  const receiverL = 0.40;
+  const barrelL = 0.60;
+  const muzzleL = 0.10;
+  const stockL = 0.34;
+  const receiver = new THREE.Mesh(new THREE.BoxGeometry(0.12, 0.18, receiverL), steel);
+  receiver.position.set(0.00, 0.00, -0.42);
+  g.add(receiver);
+  const lower = new THREE.Mesh(new THREE.BoxGeometry(0.10, 0.10, 0.22), steel);
+  lower.position.set(0.00, -0.10, -0.36);
+  g.add(lower);
+  const grip = new THREE.Mesh(new THREE.BoxGeometry(0.10, 0.22, 0.08), polymer);
+  grip.position.set(-0.06, -0.19, -0.28);
+  grip.rotation.x = -0.6;
+  g.add(grip);
+  const mag = new THREE.Mesh(new THREE.BoxGeometry(0.10, 0.22, 0.14), polymer);
+  mag.position.set(0.02, -0.16, -0.44);
+  mag.rotation.x = 0.35;
+  g.add(mag);
+  const stock = new THREE.Mesh(new THREE.BoxGeometry(0.12, 0.15, stockL), tan);
+  stock.position.set(-0.02, 0.01, +0.02);
+  g.add(stock);
+  const butt = new THREE.Mesh(new THREE.BoxGeometry(0.12, 0.16, 0.06), polymer);
+  butt.position.set(-0.02, 0.01, +0.22);
+  g.add(butt);
+  const handguard = new THREE.Mesh(new THREE.BoxGeometry(0.10, 0.12, handguardL), tan);
+  handguard.position.set(0.00, 0.00, -0.90);
+  g.add(handguard);
+  const rail = new THREE.Group();
+  const lugW = 0.035, lugH = 0.01, lugD = 0.03;
+  const lugCount = 12;
+  for (let i = 0; i < lugCount; i++) {
+    const lug = new THREE.Mesh(new THREE.BoxGeometry(lugW, lugH, lugD), steel);
+    lug.position.set(0, 0.10, -0.55 - i * 0.03);
+    rail.add(lug);
+  }
+  g.add(rail);
+  const base = new THREE.Mesh(new THREE.BoxGeometry(0.05, 0.05, 0.08), steel);
+  base.position.set(0.00, 0.09, -0.62);
+  g.add(base);
+  const hood = new THREE.Mesh(new THREE.CylinderGeometry(0.035, 0.035, 0.08, 12), steel);
+  hood.rotation.x = Math.PI / 2;
+  hood.position.set(0.00, 0.09, -0.70);
+  g.add(hood);
+  const lens = new THREE.Mesh(
+    new THREE.CircleGeometry(0.028, 16),
+    new THREE.MeshStandardMaterial({ color: 0x66aaff, emissive: 0x112244, metalness: 0.2, roughness: 0.1 })
+  );
+  lens.position.set(0.00, 0.09, -0.66);
+  lens.rotation.x = Math.PI / 2;
+  lens.material.fog = false;
+  lens.material.depthTest = false;
+  g.add(lens);
+  const barrel = new THREE.Mesh(new THREE.CylinderGeometry(0.016, 0.016, barrelL, 12), steel);
+  barrel.rotation.x = Math.PI / 2;
+  barrel.position.set(0.00, 0.00, -1.25);
+  g.add(barrel);
+  const muzzle = new THREE.Mesh(new THREE.CylinderGeometry(0.028, 0.028, muzzleL, 10), steel);
+  muzzle.rotation.x = Math.PI / 2;
+  muzzle.position.set(0.00, 0.00, -1.58);
+  g.add(muzzle);
+  const frontPost = new THREE.Mesh(new THREE.BoxGeometry(0.01, 0.02, 0.02), steel);
+  frontPost.position.set(0.00, 0.06, -1.55);
+  g.add(frontPost);
+  const muzzleAnchor = new THREE.Object3D();
+  muzzleAnchor.position.set(0.00, 0.00, -1.63);
+  g.add(muzzleAnchor);
+  // Ejector anchor (right side of receiver)
+  const ejectorAnchor = new THREE.Object3D();
+  ejectorAnchor.position.set(0.09, 0.06, -0.42);
+  g.add(ejectorAnchor);
+  G.weapon.group = g;
+  G.weapon.muzzle = muzzleAnchor;
+  G.weapon.ejector = ejectorAnchor;
+  G.camera.add(g);
+  g.scale.setScalar(1.55);
+  updateWeaponAnchor();
+}
+export function beginReload() {
+  if (G.weapon.reloading) return;
+  if (G.weapon.ammo >= CFG.gun.magSize) return;
+  G.weapon.reloading = true;
+  G.weapon.reloadTimer = CFG.gun.reloadTime;
+  if (CFG.audio.reloadStart) playReloadStart();
+}
+export function updateWeapon(delta) {
+  if (!G.weapon.group) return;
+  const moving = G.input.w || G.input.a || G.input.s || G.input.d;
+  const sprinting = moving && G.input.sprint;
+  // Reduce sway/bob intensity and slightly lower frequencies
+  G.weapon.swayT += delta * (sprinting ? 9 : (moving ? 7 : 2.5));
+  const bobAmp = sprinting ? 0.008 : (moving ? 0.006 : 0.0035);
+  const swayAmp = sprinting ? 0.0045 : (moving ? 0.0035 : 0.002);
+  const bobX = Math.sin(G.weapon.swayT * 1.8) * bobAmp;
+  const bobY = Math.cos(G.weapon.swayT * 3.6) * bobAmp * 0.6;
+  const swayZRot = Math.sin(G.weapon.swayT * 1.4) * swayAmp;
+  G.weapon.recoil = Math.max(0, G.weapon.recoil - CFG.gun.recoilRecover * delta);
+  // ----- Dynamic spread update (CS-style) -----
+  const base = CFG.gun.spreadMin ?? CFG.gun.bloom ?? 0;
+  const moveMult = moving ? (sprinting ? (CFG.gun.spreadSprintMult || 1) : (CFG.gun.spreadMoveMult || 1)) : 1;
+  const airMult = G.player.grounded ? 1 : (CFG.gun.spreadAirMult || 1);
+  const target = Math.min(CFG.gun.spreadMax || 0.02, base * moveMult * airMult);
+  G.weapon.targetSpread = target;
+  const decay = CFG.gun.spreadDecay || 6.0;
+  // Exponential approach to target
+  const k = 1 - Math.exp(-decay * delta);
+  G.weapon.spread += (target - G.weapon.spread) * k;
+  let reloadTilt = 0;
+  if (G.weapon.reloading) {
+    G.weapon.reloadTimer -= delta;
+    reloadTilt = 0.4 * Math.sin(Math.min(1, 1 - G.weapon.reloadTimer / CFG.gun.reloadTime) * Math.PI);
+    if (G.weapon.reloadTimer <= 0) {
+      const needed = CFG.gun.magSize - G.weapon.ammo;
+      if (G.weapon.reserve === Infinity) {
+        G.weapon.ammo += needed;
+      } else {
+        const taken = Math.min(needed, G.weapon.reserve);
+        G.weapon.ammo += taken;
+        G.weapon.reserve -= taken;
+      }
+      G.weapon.reloading = false;
+      if (CFG.audio.reloadEnd) playReloadEnd();
+      updateHUD();
+    }
+  }
+  G.weapon.group.position.set(
+    G.weapon.basePos.x + bobX,
+    G.weapon.basePos.y + bobY,
+    G.weapon.basePos.z - G.weapon.recoil
+  );
+  // Aim barrel at crosshair
+  const muzzleWorld = G.tmpV1;
+  G.weapon.muzzle.getWorldPosition(muzzleWorld);
+  const muzzleCam = G.tmpV2.copy(muzzleWorld);
+  G.camera.worldToLocal(muzzleCam);
+  const aimPointCam = G.tmpV3.set(0, 0, -10);
+  const aimDirCam = aimPointCam.sub(muzzleCam).normalize();
+  // Reuse quaternions to reduce GC
+  const FWD = G.tmpFwd || (G.tmpFwd = new THREE.Vector3(0, 0, -1));
+  const QAIM = G.tmpQAim || (G.tmpQAim = new THREE.Quaternion());
+  const QROLL = G.tmpQRoll || (G.tmpQRoll = new THREE.Quaternion());
+  const QREL = G.tmpQRel || (G.tmpQRel = new THREE.Quaternion());
+  QAIM.setFromUnitVectors(FWD, aimDirCam);
+  const styleRoll = THREE.MathUtils.degToRad(-3);
+  QROLL.setFromAxisAngle(FWD, swayZRot + styleRoll + reloadTilt);
+  QREL.setFromAxisAngle(new THREE.Vector3(1, 0, 0), reloadTilt * 0.2);
+  G.weapon.group.quaternion.copy(QAIM).multiply(QROLL).multiply(QREL);
+  // ----- Apply view recoil to camera (non-destructive) -----
+  // Smoothly return view kick to zero
+  const ret = CFG.gun.viewReturn || 9.0;
+  const rk = 1 - Math.exp(-ret * delta);
+  G.weapon.viewPitch -= G.weapon.viewPitch * rk;
+  G.weapon.viewYaw -= G.weapon.viewYaw * rk;
+  // Apply the delta since last frame to the camera so it cancels on return
+  const dPitch = G.weapon.viewPitch - G.weapon.appliedPitch;
+  const dYaw = G.weapon.viewYaw - G.weapon.appliedYaw;
+  // Pitch up (negative X rotation) feels like CS, invert sign accordingly
+  G.camera.rotation.x -= dPitch;
+  G.camera.rotation.y += dYaw;
+  G.weapon.appliedPitch = G.weapon.viewPitch;
+  G.weapon.appliedYaw = G.weapon.viewYaw;
+}

src/world.js ADDED Viewed

	@@ -0,0 +1,844 @@

+import * as THREE from 'three';
+import { CFG } from './config.js';
+import { G } from './globals.js';
+// --- Shared materials, geometries, and wind uniforms for trees ---
+// We keep these module-scoped so all trees can share them efficiently.
+const FOLIAGE_WIND = { uTime: { value: 0 }, uStrength: { value: 0.35 } };
+const TRUNK_MAT = new THREE.MeshStandardMaterial({
+  color: 0x6b4f32,
+  roughness: 0.9,
+  metalness: 0.0
+});
+// Foliage material with simple vertex sway, inspired by reference project
+const FOLIAGE_MAT = new THREE.MeshStandardMaterial({
+  color: 0x2f6b3d,
+  roughness: 0.8,
+  metalness: 0.0
+});
+FOLIAGE_MAT.onBeforeCompile = (shader) => {
+  shader.uniforms.uTime = FOLIAGE_WIND.uTime;
+  shader.uniforms.uStrength = FOLIAGE_WIND.uStrength;
+  shader.vertexShader = (
+    'uniform float uTime;\n' +
+    'uniform float uStrength;\n' +
+    shader.vertexShader
+  ).replace(
+    '#include <begin_vertex>',
+    `#include <begin_vertex>
+     float sway = sin(uTime * 1.7 + position.y * 0.35) * 0.5 +
+                  sin(uTime * 0.9 + position.y * 0.7) * 0.5;
+     transformed.x += sway * uStrength * (0.4 + position.y * 0.06);
+     transformed.z += cos(uTime * 1.1 + position.y * 0.42) * uStrength * (0.3 + position.y * 0.05);`
+  );
+};
+FOLIAGE_MAT.needsUpdate = true;
+// Reusable base geometries (scaled per-tree)
+// Trunk: slight taper, height 10, translated so base at y=0
+const GEO_TRUNK = new THREE.CylinderGeometry(0.7, 1.2, 10, 8, 1, false);
+GEO_TRUNK.translate(0, 5, 0);
+// Foliage stack (positions expect trunk height ~10)
+const GEO_CONE1 = new THREE.ConeGeometry(6, 10, 8); GEO_CONE1.translate(0, 14, 0);
+const GEO_CONE2 = new THREE.ConeGeometry(5, 9, 8);  GEO_CONE2.translate(0, 20, 0);
+const GEO_CONE3 = new THREE.ConeGeometry(4, 8, 8);  GEO_CONE3.translate(0, 25, 0);
+const GEO_SPH   = new THREE.SphereGeometry(3.5, 8, 6); GEO_SPH.translate(0, 28.5, 0);
+// Allow main loop to advance wind time
+export function tickForest(timeSec) {
+  FOLIAGE_WIND.uTime.value = timeSec;
+  // Distance-based chunk culling for grass/flowers (cheap per-frame visibility)
+  const cam = G.camera;
+  if (!cam || !G.foliage) return;
+  const px = cam.position.x;
+  const pz = cam.position.z;
+  const gv = CFG.foliage;
+  const g2 = gv.grassViewDist * gv.grassViewDist;
+  const f2 = gv.flowerViewDist * gv.flowerViewDist;
+  for (let i = 0; i < G.foliage.grass.length; i++) {
+    const m = G.foliage.grass[i];
+    const dx = (m.position.x) - px;
+    const dz = (m.position.z) - pz;
+    m.visible = (dx * dx + dz * dz) <= g2;
+  }
+  for (let i = 0; i < G.foliage.flowers.length; i++) {
+    const m = G.foliage.flowers[i];
+    const dx = (m.position.x) - px;
+    const dz = (m.position.z) - pz;
+    m.visible = (dx * dx + dz * dz) <= f2;
+  }
+}
+// --- Ground cover (grass, flowers, bushes, rocks) ---
+// Shared materials
+const GRASS_MAT = new THREE.MeshStandardMaterial({
+  color: 0xffffff,
+  roughness: 0.95,
+  metalness: 0.0,
+  vertexColors: true,
+  side: THREE.DoubleSide
+});
+GRASS_MAT.onBeforeCompile = (shader) => {
+  shader.uniforms.uTime = FOLIAGE_WIND.uTime;
+  shader.uniforms.uStrength = FOLIAGE_WIND.uStrength;
+  shader.vertexShader = (
+    'uniform float uTime;\n' +
+    'uniform float uStrength;\n' +
+    shader.vertexShader
+  ).replace(
+    '#include <begin_vertex>',
+    `#include <begin_vertex>
+     #ifdef USE_INSTANCING
+       // derive a per-instance pseudo-random from translation
+       float iRand = fract(sin(instanceMatrix[3].x*12.9898 + instanceMatrix[3].z*78.233) * 43758.5453);
+     #else
+       float iRand = 0.5;
+     #endif
+     float h = clamp(position.y, 0.0, 1.0);
+     float sway = (sin(uTime*2.2 + iRand*6.2831) * 0.6 + cos(uTime*1.3 + iRand*11.0) * 0.4);
+     float bend = uStrength * h * h; // bend increases towards tip
+     transformed.x += sway * bend * 0.25;
+     transformed.z += sway * bend * 0.18;`
+  );
+};
+GRASS_MAT.needsUpdate = true;
+const FLOWER_MAT = new THREE.MeshStandardMaterial({
+  color: 0xffffff,
+  roughness: 0.9,
+  metalness: 0.0,
+  vertexColors: true,
+  side: THREE.DoubleSide
+});
+FLOWER_MAT.onBeforeCompile = (shader) => {
+  shader.uniforms.uTime = FOLIAGE_WIND.uTime;
+  shader.uniforms.uStrength = FOLIAGE_WIND.uStrength;
+  shader.vertexShader = (
+    'uniform float uTime;\n' +
+    'uniform float uStrength;\n' +
+    shader.vertexShader
+  ).replace(
+    '#include <begin_vertex>',
+    `#include <begin_vertex>
+     #ifdef USE_INSTANCING
+       float iRand = fract(sin(instanceMatrix[3].x*19.123 + instanceMatrix[3].z*47.321) * 15731.123);
+     #else
+       float iRand = 0.5;
+     #endif
+     float h = clamp(position.y, 0.0, 1.0);
+     float sway = sin(uTime*2.6 + iRand*8.0);
+     float bend = uStrength * h;
+     transformed.x += sway * bend * 0.18;
+     transformed.z += sway * bend * 0.14;`
+  );
+};
+FLOWER_MAT.needsUpdate = true;
+const BUSH_MAT = new THREE.MeshStandardMaterial({
+  color: 0x2b6a37,
+  roughness: 0.95,
+  metalness: 0.0,
+  flatShading: false
+});
+const ROCK_MAT = new THREE.MeshStandardMaterial({
+  color: 0x7b7066,
+  roughness: 1.0,
+  metalness: 0.0,
+  flatShading: true
+});
+// Base geometries (kept small, cloned per-chunk to inject bounding spheres)
+function makeCrossBladeGeometry(width = 0.5, height = 1.2) {
+  // Two crossed quads around Y axis
+  const hw = width * 0.5;
+  const h = height;
+  const positions = [
+    // quad A (X axis)
+    -hw, 0, 0,   hw, 0, 0,   hw, h, 0,
+    -hw, 0, 0,   hw, h, 0,  -hw, h, 0,
+    // quad B (Z axis)
+     0, 0, -hw,   0, 0, hw,   0, h, hw,
+     0, 0, -hw,   0, h, hw,   0, h, -hw,
+  ];
+  const colors = [];
+  for (let i = 0; i < 12; i++) {
+    const y = positions[i*3 + 1];
+    const t = y / h; // 0 at base -> 1 at tip
+    const r = THREE.MathUtils.lerp(0.13, 0.25, t);
+    const g = THREE.MathUtils.lerp(0.28, 0.55, t);
+    const b = THREE.MathUtils.lerp(0.12, 0.22, t);
+    colors.push(r, g, b);
+  }
+  const geo = new THREE.BufferGeometry();
+  geo.setAttribute('position', new THREE.Float32BufferAttribute(positions, 3));
+  geo.setAttribute('color', new THREE.Float32BufferAttribute(colors, 3));
+  geo.computeVertexNormals();
+  return geo;
+}
+const BASE_GEOM = {
+  // Smaller blades and petals relative to trees
+  grass: makeCrossBladeGeometry(0.22, 0.45),
+  flower: makeCrossBladeGeometry(0.18, 0.32),
+  bush: new THREE.SphereGeometry(0.8, 8, 6),
+  rock: new THREE.IcosahedronGeometry(0.7, 0)
+};
+// Deterministic per-chunk RNG
+function lcg(seed) {
+  let s = (seed >>> 0) || 1;
+  return () => (s = (1664525 * s + 1013904223) >>> 0) / 4294967296;
+}
+export function generateGroundCover() {
+  const S = CFG.foliage;
+  FOLIAGE_WIND.uStrength.value = S.windStrength;
+  const half = CFG.forestSize / 2;
+  const chunk = Math.max(8, S.chunkSize | 0);
+  const chunksX = Math.ceil(CFG.forestSize / chunk);
+  const chunksZ = Math.ceil(CFG.forestSize / chunk);
+  const halfChunk = chunk * 0.5;
+  const seed = (CFG.seed | 0) ^ (S.seedOffset | 0);
+  // Helper to set a safe bounding sphere for a chunk-sized instanced mesh
+  function setChunkBounds(mesh) {
+    const g = mesh.geometry;
+    const r = Math.sqrt(halfChunk*halfChunk*2 + 25); // generous Y span
+    g.boundingSphere = new THREE.Sphere(new THREE.Vector3(0, 0, 0), r);
+  }
+  // Skip center clearing smoothly
+  function densityAt(x, z) {
+    const r = Math.hypot(x, z);
+    const edge = CFG.clearRadius;
+    const k = THREE.MathUtils.clamp((r - edge) / (edge * 1.2), 0, 1);
+    return THREE.MathUtils.lerp(S.densityNearClear, 1, k);
+  }
+  // Reset chunk refs
+  if (!G.foliage) G.foliage = { grass: [], flowers: [] };
+  G.foliage.grass.length = 0;
+  G.foliage.flowers.length = 0;
+  // Per-chunk generation
+  for (let iz = 0; iz < chunksZ; iz++) {
+    for (let ix = 0; ix < chunksX; ix++) {
+      const cx = -half + ix * chunk + halfChunk;
+      const cz = -half + iz * chunk + halfChunk;
+      // Keep within world bounds
+      if (Math.abs(cx) > half || Math.abs(cz) > half) continue;
+      // Density scaler by clearing and macro noise for patchiness
+      const den = densityAt(cx, cz);
+      const patch = (fbm(cx, cz, 1 / 60, 3, 2, 0.5, seed) * 0.5 + 0.5);
+      const grassCount = Math.max(0, Math.round(S.grassPerChunk * den * (0.6 + 0.8 * patch)));
+      const flowerCount = Math.max(0, Math.round(S.flowersPerChunk * den * (0.6 + 0.8 * (1 - patch))));
+      const bushesCount = Math.max(0, Math.round(S.bushesPerChunk * den * (0.7 + 0.6 * patch)));
+      const rocksCount = Math.max(0, Math.round(S.rocksPerChunk * den * (0.7 + 0.6 * (1 - patch))));
+      // No work for empty chunks
+      if (!grassCount && !flowerCount && !bushesCount && !rocksCount) continue;
+      const rng = lcg(((ix + 1) * 73856093) ^ ((iz + 1) * 19349663) ^ seed);
+      // Grass
+      if (grassCount > 0) {
+        const geom = BASE_GEOM.grass.clone();
+        const mesh = new THREE.InstancedMesh(geom, GRASS_MAT, grassCount);
+        mesh.instanceMatrix.setUsage(THREE.StaticDrawUsage);
+        mesh.castShadow = false;
+        mesh.receiveShadow = false;
+        mesh.position.set(cx, 0, cz);
+        setChunkBounds(mesh);
+        const m = new THREE.Matrix4();
+        const pos = new THREE.Vector3();
+        const quat = new THREE.Quaternion();
+        const scl = new THREE.Vector3();
+        const color = new THREE.Color();
+        for (let i = 0; i < grassCount; i++) {
+          const dx = (rng() - 0.5) * chunk;
+          const dz = (rng() - 0.5) * chunk;
+          const wx = cx + dx;
+          const wz = cz + dz;
+          const wy = getTerrainHeight(wx, wz);
+          // Simple placement; allow gentle slopes without extra checks
+          const yaw = rng() * Math.PI * 2;
+          quat.setFromEuler(new THREE.Euler(0, yaw, 0));
+          // 1.5x larger than current small baseline
+          const scale = (0.6 + rng() * 0.35) * 1.5;
+          scl.set(scale, scale, scale);
+          pos.set(dx, wy, dz);
+          m.compose(pos, quat, scl);
+          mesh.setMatrixAt(i, m);
+          // instance color variation
+          color.setRGB(THREE.MathUtils.lerp(0.18, 0.26, rng()), THREE.MathUtils.lerp(0.45, 0.62, rng()), THREE.MathUtils.lerp(0.16, 0.24, rng()));
+          mesh.setColorAt(i, color);
+        }
+        mesh.instanceMatrix.needsUpdate = true;
+        if (mesh.instanceColor) mesh.instanceColor.needsUpdate = true;
+        G.scene.add(mesh);
+        G.foliage.grass.push(mesh);
+      }
+      // Flowers
+      if (flowerCount > 0) {
+        const geom = BASE_GEOM.flower.clone();
+        const mesh = new THREE.InstancedMesh(geom, FLOWER_MAT, flowerCount);
+        mesh.instanceMatrix.setUsage(THREE.StaticDrawUsage);
+        mesh.castShadow = false;
+        mesh.receiveShadow = false;
+        mesh.position.set(cx, 0, cz);
+        setChunkBounds(mesh);
+        const m = new THREE.Matrix4();
+        const pos = new THREE.Vector3();
+        const quat = new THREE.Quaternion();
+        const scl = new THREE.Vector3();
+        const color = new THREE.Color();
+        for (let i = 0; i < flowerCount; i++) {
+          const dx = (rng() - 0.5) * chunk;
+          const dz = (rng() - 0.5) * chunk;
+          const wx = cx + dx;
+          const wz = cz + dz;
+          const wy = getTerrainHeight(wx, wz) + 0.02;
+          const yaw = rng() * Math.PI * 2;
+          quat.setFromEuler(new THREE.Euler(0, yaw, 0));
+          // Flowers 1.5x larger than current small baseline
+          const scale = (0.7 + rng() * 0.3) * 1.5;
+          scl.set(scale, scale, scale);
+          pos.set(dx, wy, dz);
+          m.compose(pos, quat, scl);
+          mesh.setMatrixAt(i, m);
+          // bright palette variations
+          const palettes = [
+            new THREE.Color(0xff6fb3), // pink
+            new THREE.Color(0xffda66), // yellow
+            new THREE.Color(0x8be37c), // mint
+            new THREE.Color(0x6fc3ff), // sky
+            new THREE.Color(0xff8a6f)  // peach
+          ];
+          const base = palettes[Math.floor(rng() * palettes.length)];
+          color.copy(base).multiplyScalar(0.9 + rng()*0.2);
+          mesh.setColorAt(i, color);
+        }
+        mesh.instanceMatrix.needsUpdate = true;
+        if (mesh.instanceColor) mesh.instanceColor.needsUpdate = true;
+        G.scene.add(mesh);
+        G.foliage.flowers.push(mesh);
+      }
+      // Bushes
+      if (bushesCount > 0) {
+        const geom = BASE_GEOM.bush.clone();
+        const mesh = new THREE.InstancedMesh(geom, BUSH_MAT, bushesCount);
+        mesh.instanceMatrix.setUsage(THREE.StaticDrawUsage);
+        mesh.castShadow = false;
+        mesh.receiveShadow = true;
+        mesh.position.set(cx, 0, cz);
+        setChunkBounds(mesh);
+        const m = new THREE.Matrix4();
+        const pos = new THREE.Vector3();
+        const quat = new THREE.Quaternion();
+        const scl = new THREE.Vector3();
+        for (let i = 0; i < bushesCount; i++) {
+          const dx = (rng() - 0.5) * chunk;
+          const dz = (rng() - 0.5) * chunk;
+          const wx = cx + dx;
+          const wz = cz + dz;
+          const wy = getTerrainHeight(wx, wz) + 0.2;
+          quat.identity();
+          const s = 0.7 + rng() * 0.8;
+          scl.set(s, s, s);
+          pos.set(dx, wy, dz);
+          m.compose(pos, quat, scl);
+          mesh.setMatrixAt(i, m);
+        }
+        mesh.instanceMatrix.needsUpdate = true;
+        G.scene.add(mesh);
+      }
+      // Rocks
+      if (rocksCount > 0) {
+        const geom = BASE_GEOM.rock.clone();
+        const mesh = new THREE.InstancedMesh(geom, ROCK_MAT, rocksCount);
+        mesh.instanceMatrix.setUsage(THREE.StaticDrawUsage);
+        mesh.castShadow = true;
+        mesh.receiveShadow = true;
+        mesh.position.set(cx, 0, cz);
+        setChunkBounds(mesh);
+        const m = new THREE.Matrix4();
+        const pos = new THREE.Vector3();
+        const quat = new THREE.Quaternion();
+        const scl = new THREE.Vector3();
+        const color = new THREE.Color();
+        for (let i = 0; i < rocksCount; i++) {
+          const dx = (rng() - 0.5) * chunk;
+          const dz = (rng() - 0.5) * chunk;
+          const wx = cx + dx;
+          const wz = cz + dz;
+          const wy = getTerrainHeight(wx, wz) + 0.05;
+          const yaw = rng() * Math.PI * 2;
+          quat.setFromEuler(new THREE.Euler(0, yaw, 0));
+          const s = 0.4 + rng() * 0.9;
+          scl.set(s * (0.8 + rng()*0.4), s, s * (0.8 + rng()*0.4));
+          pos.set(dx, wy, dz);
+          m.compose(pos, quat, scl);
+          mesh.setMatrixAt(i, m);
+          // slight per-rock color tint
+          color.setHSL(0.07, 0.08, THREE.MathUtils.lerp(0.32, 0.46, rng()));
+          if (mesh.instanceColor) mesh.setColorAt(i, color);
+        }
+        mesh.instanceMatrix.needsUpdate = true;
+        if (mesh.instanceColor) mesh.instanceColor.needsUpdate = true;
+        G.scene.add(mesh);
+      }
+    }
+  }
+}
+// --- Procedural terrain helpers ---
+// Hash-based 2D value noise for deterministic hills (pure 32-bit integer math)
+function hash2i(xi, yi, seed) {
+  let h = Math.imul(xi, 374761393) ^ Math.imul(yi, 668265263) ^ Math.imul(seed, 2147483647);
+  h = Math.imul(h ^ (h >>> 13), 1274126177);
+  h = (h ^ (h >>> 16)) >>> 0;
+  return h / 4294967296; // [0,1)
+}
+function smoothstep(a, b, t) {
+  if (t <= a) return 0;
+  if (t >= b) return 1;
+  t = (t - a) / (b - a);
+  return t * t * (3 - 2 * t);
+}
+function lerp(a, b, t) { return a + (b - a) * t; }
+function valueNoise2(x, z, seed) {
+  const xi = Math.floor(x);
+  const zi = Math.floor(z);
+  const xf = x - xi;
+  const zf = z - zi;
+  const s = smoothstep(0, 1, xf);
+  const t = smoothstep(0, 1, zf);
+  const v00 = hash2i(xi, zi, seed);
+  const v10 = hash2i(xi + 1, zi, seed);
+  const v01 = hash2i(xi, zi + 1, seed);
+  const v11 = hash2i(xi + 1, zi + 1, seed);
+  const x1 = lerp(v00, v10, s);
+  const x2 = lerp(v01, v11, s);
+  return lerp(x1, x2, t) * 2 - 1; // [-1,1]
+}
+function fbm(x, z, baseFreq, octaves, lacunarity, gain, seed) {
+  let sum = 0;
+  let amp = 1;
+  let freq = baseFreq;
+  for (let i = 0; i < octaves; i++) {
+    sum += amp * valueNoise2(x * freq, z * freq, seed);
+    freq *= lacunarity;
+    amp *= gain;
+  }
+  return sum;
+}
+// Exported height sampler so other systems can stick to the ground
+export function getTerrainHeight(x, z) {
+  const seed = (CFG.seed | 0) ^ 0x9e3779b9;
+  // Gentle rolling hills with subtle detail
+  const h1 = fbm(x, z, 1 / 90, 4, 2, 0.5, seed);
+  const h2 = fbm(x, z, 1 / 28, 3, 2, 0.5, seed + 1337);
+  const h3 = fbm(x, z, 1 / 9, 2, 2, 0.5, seed + 4242);
+  let h = h1 * 3.6 + h2 * 1.7 + h3 * 0.6; // total amplitude ~ up to ~6-7
+  // Soften near the center to keep spawn area playable
+  const r = Math.hypot(x, z);
+  const mask = smoothstep(CFG.clearRadius * 0.8, CFG.clearRadius * 1.8, r);
+  h *= mask;
+  return h;
+}
+// --- Procedural ground textures (albedo + normal) ---
+function generateGroundTextures(size = 1024) {
+  const seed = (CFG.seed | 0) ^ 0x51f9ac4d;
+  const canvas = document.createElement('canvas');
+  canvas.width = size; canvas.height = size;
+  const ctx = canvas.getContext('2d', { willReadFrequently: true });
+  const nCanvas = document.createElement('canvas');
+  nCanvas.width = size; nCanvas.height = size;
+  const nctx = nCanvas.getContext('2d');
+  // Choose a periodic cell count that divides nicely for octaves
+  // Bigger = less obvious repeats; must keep perf reasonable
+  const cells = 64; // base lattice cells across the tile
+  // Periodic hash: wrap lattice coordinates to make the noise tile
+  function hash2Periodic(xi, yi, period, s) {
+    const px = ((xi % period) + period) % period;
+    const py = ((yi % period) + period) % period;
+    return hash2i(px, py, s);
+  }
+  function valueNoise2Periodic(x, z, period, s) {
+    const xi = Math.floor(x);
+    const zi = Math.floor(z);
+    const xf = x - xi;
+    const zf = z - zi;
+    const sx = smoothstep(0, 1, xf);
+    const sz = smoothstep(0, 1, zf);
+    const v00 = hash2Periodic(xi, zi, period, s);
+    const v10 = hash2Periodic(xi + 1, zi, period, s);
+    const v01 = hash2Periodic(xi, zi + 1, period, s);
+    const v11 = hash2Periodic(xi + 1, zi + 1, period, s);
+    const x1 = lerp(v00, v10, sx);
+    const x2 = lerp(v01, v11, sx);
+    return lerp(x1, x2, sz) * 2 - 1;
+  }
+  function fbmPeriodic(x, z, octaves, s) {
+    let sum = 0;
+    let amp = 0.5;
+    let freq = 1;
+    for (let i = 0; i < octaves; i++) {
+      const period = cells * freq;
+      sum += amp * valueNoise2Periodic(x * freq, z * freq, period, s + i * 1013);
+      freq *= 2;
+      amp *= 0.5;
+    }
+    return sum; // roughly [-1,1]
+  }
+  // Precompute a height-ish field for normal derivation (two-pass)
+  const H = new Float32Array(size * size);
+  const idx = (x, y) => y * size + x;
+  for (let y = 0; y < size; y++) {
+    for (let x = 0; x < size; x++) {
+      // Map pixel -> tile domain [0, cells]
+      const u = (x / size) * cells;
+      const v = (y / size) * cells;
+      const nLow = fbmPeriodic(u * 0.75, v * 0.75, 3, seed);
+      const nHi = fbmPeriodic(u * 3.0, v * 3.0, 2, seed + 999);
+      // Height proxy for normals: mix broad and fine details
+      const h = 0.6 * (nLow * 0.5 + 0.5) + 0.4 * (nHi * 0.5 + 0.5);
+      H[idx(x, y)] = h;
+    }
+  }
+  const img = ctx.createImageData(size, size);
+  const data = img.data;
+  const nimg = nctx.createImageData(size, size);
+  const ndata = nimg.data;
+  // Palettes
+  const grassDark = [0x20, 0x5a, 0x2b]; // #205a2b deep green
+  const grassLight = [0x4c, 0x9a, 0x3b]; // #4c9a3b lively green
+  const dryGrass = [0x88, 0xa0, 0x55]; // #88a055 sun-kissed
+  const dirtDark = [0x4f, 0x39, 0x2c]; // #4f392c rich soil
+  const dirtLight = [0x73, 0x5a, 0x48]; // #735a48 lighter soil
+  function mixColor(a, b, t) {
+    return [
+      Math.round(lerp(a[0], b[0], t)),
+      Math.round(lerp(a[1], b[1], t)),
+      Math.round(lerp(a[2], b[2], t))
+    ];
+  }
+  // Second pass: color + normal
+  const strength = 2.2; // normal intensity
+  for (let y = 0; y < size; y++) {
+    for (let x = 0; x < size; x++) {
+      const u = (x / size) * cells;
+      const v = (y / size) * cells;
+      // Patchiness control
+      const broad = fbmPeriodic(u * 0.8, v * 0.8, 3, seed + 17) * 0.5 + 0.5;
+      const detail = fbmPeriodic(u * 3.2, v * 3.2, 2, seed + 23) * 0.5 + 0.5;
+      let grassness = smoothstep(0.38, 0.62, broad);
+      grassness = lerp(grassness, grassness * (0.7 + 0.3 * detail), 0.5);
+      // Choose palette and mix for variation
+      const grassMid = mixColor(grassDark, grassLight, 0.6);
+      const grassCol = mixColor(grassMid, dryGrass, 0.25 + 0.35 * detail);
+      const dirtCol = mixColor(dirtDark, dirtLight, 0.35 + 0.4 * detail);
+      const col = mixColor(dirtCol, grassCol, grassness);
+      const p = idx(x, y) * 4;
+      data[p + 0] = col[0];
+      data[p + 1] = col[1];
+      data[p + 2] = col[2];
+      data[p + 3] = 255;
+      // Normal from height field with wrapping
+      const xL = (x - 1 + size) % size, xR = (x + 1) % size;
+      const yT = (y - 1 + size) % size, yB = (y + 1) % size;
+      const hL = H[idx(xL, y)], hR = H[idx(xR, y)];
+      const hT = H[idx(x, yT)], hB = H[idx(x, yB)];
+      const dx = (hR - hL) * strength;
+      const dy = (hB - hT) * strength;
+      let nx = -dx, ny = -dy, nz = 1.0;
+      const invLen = 1 / Math.hypot(nx, ny, nz);
+      nx *= invLen; ny *= invLen; nz *= invLen;
+      ndata[p + 0] = Math.round((nx * 0.5 + 0.5) * 255);
+      ndata[p + 1] = Math.round((ny * 0.5 + 0.5) * 255);
+      ndata[p + 2] = Math.round((nz * 0.5 + 0.5) * 255);
+      ndata[p + 3] = 255;
+    }
+  }
+  ctx.putImageData(img, 0, 0);
+  nctx.putImageData(nimg, 0, 0);
+  const map = new THREE.CanvasTexture(canvas);
+  map.colorSpace = THREE.SRGBColorSpace;
+  map.generateMipmaps = true;
+  map.minFilter = THREE.LinearMipmapLinearFilter;
+  map.magFilter = THREE.LinearFilter;
+  map.wrapS = map.wrapT = THREE.RepeatWrapping;
+  const normalMap = new THREE.CanvasTexture(nCanvas);
+  normalMap.generateMipmaps = true;
+  normalMap.minFilter = THREE.LinearMipmapLinearFilter;
+  normalMap.magFilter = THREE.LinearFilter;
+  normalMap.wrapS = normalMap.wrapT = THREE.RepeatWrapping;
+  // Anisotropy if available
+  try {
+    const maxAniso = G.renderer && G.renderer.capabilities ? G.renderer.capabilities.getMaxAnisotropy() : 0;
+    if (maxAniso && maxAniso > 0) {
+      map.anisotropy = Math.min(8, maxAniso);
+      normalMap.anisotropy = Math.min(8, maxAniso);
+    }
+  } catch (_) {}
+  return { map, normalMap };
+}
+export function setupGround() {
+  const segs = 160; // enough resolution for smooth hills
+  const geometry = new THREE.PlaneGeometry(CFG.forestSize, CFG.forestSize, segs, segs);
+  geometry.rotateX(-Math.PI / 2);
+  // Displace vertices along Y using our height function
+  const pos = geometry.attributes.position;
+  const colors = new Float32Array(pos.count * 3);
+  let minY = Infinity, maxY = -Infinity;
+  for (let i = 0; i < pos.count; i++) {
+    const x = pos.getX(i);
+    const z = pos.getZ(i);
+    const y = getTerrainHeight(x, z);
+    pos.setY(i, y);
+    if (y < minY) minY = y;
+    if (y > maxY) maxY = y;
+  }
+  pos.needsUpdate = true;
+  geometry.computeVertexNormals();
+  // Macro vertex colors based on slope (normal.y) and height
+  const nrm = geometry.attributes.normal;
+  for (let i = 0; i < pos.count; i++) {
+    const x = pos.getX(i);
+    const z = pos.getZ(i);
+    const y = pos.getY(i);
+    const ny = nrm.getY(i);
+    const r = Math.hypot(x, z);
+    const clear = 1.0 - smoothstep(CFG.clearRadius * 0.7, CFG.clearRadius * 1.4, r);
+    const flat = smoothstep(0.6, 0.96, ny); // flat areas -> grass
+    const hNorm = (y - minY) / Math.max(1e-5, (maxY - minY));
+    // Grass tint varies with height; dirt tint more constant
+    const grassDark = new THREE.Color(0x1f4f28);
+    const grassLight = new THREE.Color(0x3f8f3a);
+    const dirtDark = new THREE.Color(0x4a3a2e);
+    const dirtLight = new THREE.Color(0x6a5040);
+    const grassTint = grassDark.clone().lerp(grassLight, 0.35 + 0.45 * hNorm);
+    const dirtTint = dirtDark.clone().lerp(dirtLight, 0.35);
+    // Reduce grass in the central clearing for readability
+    const grassness = THREE.MathUtils.clamp(flat * (1.0 - 0.65 * clear), 0, 1);
+    const tint = dirtTint.clone().lerp(grassTint, grassness);
+    colors[i * 3 + 0] = tint.r;
+    colors[i * 3 + 1] = tint.g;
+    colors[i * 3 + 2] = tint.b;
+  }
+  geometry.setAttribute('color', new THREE.BufferAttribute(colors, 3));
+  // High-frequency detail textures (tileable) + macro vertex tint
+  const { map, normalMap } = generateGroundTextures(1024);
+  // Repeat detail across the forest (fewer repeats = larger features)
+  // Previously: forestSize / 4 (very fine, looked too uniform)
+  const repeats = Math.max(12, Math.round(CFG.forestSize / 12));
+  map.repeat.set(repeats, repeats);
+  normalMap.repeat.set(repeats, repeats);
+  const material = new THREE.MeshStandardMaterial({
+    color: 0xffffff,
+    map,
+    normalMap,
+    roughness: 0.95,
+    metalness: 0.0,
+    vertexColors: true
+  });
+  // Add a subtle world-space macro variation to break tiling repetition
+  material.onBeforeCompile = (shader) => {
+    shader.uniforms.uMacroScale = { value: 0.035 }; // frequency in world units
+    shader.uniforms.uMacroStrength = { value: 0.28 }; // mix into base color
+    shader.vertexShader = (
+      'varying vec3 vWorldPos;\n' +
+      shader.vertexShader
+    ).replace(
+      '#include <worldpos_vertex>',
+      `#include <worldpos_vertex>
+       vWorldPos = worldPosition.xyz;`
+    );
+    // Cheap 2D value-noise FBM in fragment to modulate albedo in world space
+    const NOISE_CHUNK = `
+      varying vec3 vWorldPos;
+      uniform float uMacroScale;
+      uniform float uMacroStrength;
+      float hash12(vec2 p){
+        vec3 p3 = fract(vec3(p.xyx) * 0.1031);
+        p3 += dot(p3, p3.yzx + 33.33);
+        return fract((p3.x + p3.y) * p3.z);
+      }
+      float vnoise(vec2 p){
+        vec2 i = floor(p);
+        vec2 f = fract(p);
+        float a = hash12(i);
+        float b = hash12(i + vec2(1.0, 0.0));
+        float c = hash12(i + vec2(0.0, 1.0));
+        float d = hash12(i + vec2(1.0, 1.0));
+        vec2 u = f*f*(3.0-2.0*f);
+        return mix(a, b, u.x) + (c - a) * u.y * (1.0 - u.x) + (d - b) * u.x * u.y;
+      }
+      float fbm2(vec2 p){
+        float t = 0.0;
+        float amp = 0.5;
+        for(int i=0;i<4;i++){
+          t += amp * vnoise(p);
+          p *= 2.0;
+          amp *= 0.5;
+        }
+        return t;
+      }
+    `;
+    shader.fragmentShader = (
+      NOISE_CHUNK + shader.fragmentShader
+    ).replace(
+      '#include <map_fragment>',
+      `#include <map_fragment>
+       // World-space macro color variation to reduce visible tiling
+       vec2 st = vWorldPos.xz * uMacroScale;
+       float macro = fbm2(st);
+       macro = macro * 0.5 + 0.5; // [0,1]
+       float m = mix(0.82, 1.18, macro);
+       diffuseColor.rgb *= mix(1.0, m, uMacroStrength);`
+    );
+  };
+  const ground = new THREE.Mesh(geometry, material);
+  ground.receiveShadow = true;
+  G.scene.add(ground);
+  G.ground = ground;
+  // Keep blockers in sync if trees already exist
+  if (G.treeMeshes && Array.isArray(G.treeMeshes)) {
+    G.blockers = [ground, ...G.treeMeshes];
+  }
+}
+export function generateForest() {
+  const clearRadiusSq = CFG.clearRadius * CFG.clearRadius;
+  const halfSize = CFG.forestSize / 2;
+  let placed = 0;
+  const maxAttempts = CFG.treeCount * 3;
+  let attempts = 0;
+  G.treeColliders.length = 0;
+  G.treeMeshes.length = 0;
+  while (placed < CFG.treeCount && attempts < maxAttempts) {
+    attempts++;
+    const x = (G.random() - 0.5) * CFG.forestSize;
+    const z = (G.random() - 0.5) * CFG.forestSize;
+    // Check clearing
+    if (x * x + z * z < clearRadiusSq) continue;
+    // Check distance to other trees
+    let tooClose = false;
+    for (const collider of G.treeColliders) {
+      const dx = x - collider.x;
+      const dz = z - collider.z;
+      if (dx * dx + dz * dz < Math.pow(collider.radius * 2, 2)) {
+        tooClose = true;
+        break;
+      }
+    }
+    if (tooClose) continue;
+    // Create a layered pine-like tree with shared materials and wind-swaying foliage
+    const tree = new THREE.Group();
+    // Random uniform scale for size variety
+    const s = 0.75 + G.random() * 0.8; // ~0.75..1.55
+    // Trunk (reuses base geometry, scaled)
+    const trunk = new THREE.Mesh(GEO_TRUNK, TRUNK_MAT);
+    trunk.scale.set(s, s, s);
+    trunk.castShadow = true;
+    trunk.receiveShadow = true;
+    tree.add(trunk);
+    // Foliage: three cones + a small spherical crown
+    const foliage1 = new THREE.Mesh(GEO_CONE1, FOLIAGE_MAT);
+    const foliage2 = new THREE.Mesh(GEO_CONE2, FOLIAGE_MAT);
+    const foliage3 = new THREE.Mesh(GEO_CONE3, FOLIAGE_MAT);
+    const crown    = new THREE.Mesh(GEO_SPH,   FOLIAGE_MAT);
+    const fScale = s * (0.9 + G.random() * 0.15); // slight variance per tree
+    foliage1.scale.set(fScale, fScale, fScale);
+    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;
+    foliage1.receiveShadow = foliage2.receiveShadow = foliage3.receiveShadow = crown.receiveShadow = true;
+    tree.add(foliage1, foliage2, foliage3, crown);
+    // Random rotation for natural look
+    tree.rotation.y = G.random() * Math.PI * 2;
+    const y = getTerrainHeight(x, z);
+    tree.position.set(x, y, z);
+    G.scene.add(tree);
+    G.treeMeshes.push(tree);
+    // Add collider roughly matching trunk base radius
+    const trunkBaseRadius = 1.2 * s;
+    G.treeColliders.push({ x, z, radius: trunkBaseRadius });
+    placed++;
+  }
+  // Update blockers list once trees are generated
+  if (G.ground) {
+    G.blockers = [G.ground, ...G.treeMeshes];
+  } else {
+    G.blockers = [...G.treeMeshes];
+  }
+}

tsconfig.json ADDED Viewed

	@@ -0,0 +1,27 @@

+{
+  "compilerOptions": {
+    // Enable latest features
+    "lib": ["ESNext", "DOM"],
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "allowJs": true,
+    // Bundler mode
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+    // Best practices
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+    // Some stricter flags (disabled by default)
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noPropertyAccessFromIndexSignature": false
+  }
+}