Spaces:
Running
Running
| // Turfbreak core: seeded city maps of Port Varo (a made-up harbour city), weapons, perks, killstreaks, 3D collision | |
| // (feet height, step-up, mantling onto cover), 3D line of sight and hitscan rays, and the navigation grid. Pure functions only (no DOM, no three.js), so the same file runs in the | |
| // browser, in Node tests and in the trailer recorder. Every map is point-symmetric, so both crews get the same layout. | |
| // (c) 2026 CyberMax. All rights reserved. | |
| export const VERSION = 2; // 2 = first-person (3D bodies, heights, headshots) | |
| export const LAUNCH_DAY = Date.UTC(2026, 9, 16) / 864e5; // 16 Oct 2026 = Contract #1 | |
| // ---------------------------------------------------------------- random | |
| export function rng(seed) { | |
| let a = seed >>> 0; | |
| const f = () => { a = (a + 0x6D2B79F5) >>> 0; let t = a; t = Math.imul(t ^ (t >>> 15), t | 1); t ^= t + Math.imul(t ^ (t >>> 7), t | 61); return ((t ^ (t >>> 14)) >>> 0) / 4294967296; }; | |
| f.range = (lo, hi) => lo + (hi - lo) * f(); | |
| f.int = (lo, hi) => Math.floor(lo + (hi - lo + 1) * f()); | |
| f.pick = (arr) => arr[Math.floor(f() * arr.length)]; | |
| f.chance = (p) => f() < p; | |
| return f; | |
| } | |
| export function hashStr(s) { let h = 2166136261 >>> 0; for (let i = 0; i < s.length; i++) { h ^= s.charCodeAt(i); h = Math.imul(h, 16777619) >>> 0; } return h >>> 0; } | |
| export const dayNumber = (now = Date.now()) => Math.floor(now / 864e5) - LAUNCH_DAY + 1; | |
| // ---------------------------------------------------------------- crews, weapons, perks, streaks | |
| export const TEAMS = [ | |
| { id: 0, name: 'ASHEN', color: '#FF8A1F', glow: '#FFB25C', dark: '#3A1C08' }, | |
| { id: 1, name: 'COLDWIRE', color: '#2EE6FF', glow: '#8AF4FF', dark: '#06303A' }, | |
| ]; | |
| // Fictional weapons. dmg per bullet, cd = seconds between shots, spread in radians, range in metres. | |
| // First-person fields: hs = headshot multiplier, zoom = aim-down-sights magnification, recoil = upward kick per shot | |
| // (radians, applied to the view by the game), bloom = spread added per shot (decays), sight = 'dot' | 'scope' | 'iron'. | |
| export const WEAPONS = { | |
| vk9: { id: 'vk9', name: 'VK-9 CARBINE', short: 'VK-9', kind: 'Carbine', dmg: 19, cd: 0.105, pellets: 1, spread: 0.035, range: 34, mag: 30, reload: 1.6, speed: 1, auto: true, kick: 0.25, adsT: 0.16, desc: 'Full-auto all-rounder', hs: 1.6, zoom: 1.35, recoil: 0.011, bloom: 0.006, sight: 'dot' }, | |
| wasp: { id: 'wasp', name: 'WASP SMG', short: 'WASP', kind: 'SMG', dmg: 13, cd: 0.068, pellets: 1, spread: 0.06, range: 22, mag: 36, reload: 1.35, speed: 1.08, auto: true, kick: 0.18, adsT: 0.13, desc: 'Fast hands, fast feet', hs: 1.5, zoom: 1.25, recoil: 0.008, bloom: 0.005, sight: 'iron' }, | |
| breach: { id: 'breach', name: 'BREACH-12', short: 'BREACH', kind: 'Shotgun', dmg: 14, cd: 0.78, pellets: 8, spread: 0.11, range: 13, mag: 6, reload: 2.1, speed: 1, auto: true, kick: 0.9, adsT: 0.18, desc: 'Owns every doorway', hs: 1.25, zoom: 1.15, recoil: 0.05, bloom: 0, sight: 'iron' }, | |
| lancer: { id: 'lancer', name: 'LANCER DMR', short: 'LANCER', kind: 'Marksman', dmg: 48, cd: 0.4, pellets: 1, spread: 0.01, range: 50, mag: 10, reload: 2.0, speed: 0.95, auto: true, kick: 0.55, adsT: 0.22, desc: 'Three taps from across the street', hs: 2.1, zoom: 2.6, recoil: 0.035, bloom: 0.012, sight: 'scope' }, | |
| }; | |
| /** Everyone also carries the sidearm (slot 2). Not a loadout pick, so it is kept out of WEAPON_IDS. */ | |
| export const SIDEARM = { id: 'p9', name: 'TALLY P9 SIDEARM', short: 'P9', kind: 'Sidearm', dmg: 24, cd: 0.17, pellets: 1, spread: 0.03, range: 26, mag: 12, reload: 1.15, speed: 1.06, auto: false, kick: 0.3, adsT: 0.12, desc: 'Backup that never jams', hs: 1.8, zoom: 1.2, recoil: 0.02, bloom: 0.008, sight: 'iron' }; | |
| export const ARMS = { ...WEAPONS, p9: SIDEARM }; | |
| export const WEAPON_IDS = Object.keys(WEAPONS); | |
| export const PERKS = { | |
| plated: { id: 'plated', name: 'PLATED', desc: '+30 armour' }, | |
| ghost: { id: 'ghost', name: 'GHOST', desc: 'Hidden from drones, silent dash' }, | |
| quick: { id: 'quick', name: 'QUICKHANDS', desc: 'Faster reload and dash' }, | |
| }; | |
| export const PERK_IDS = Object.keys(PERKS); | |
| export const STREAKS = [ | |
| { at: 3, id: 'recon', name: 'RECON DRONE', desc: 'Every enemy on your map for 12 s' }, | |
| { at: 5, id: 'sentry', name: 'SENTRY', desc: 'An auto-turret holds your ground' }, | |
| { at: 7, id: 'skyfall', name: 'SKYFALL STRIKE', desc: 'A line of strikes down your aim' }, | |
| ]; | |
| // ---------------------------------------------------------------- maps | |
| export const MAPS = { | |
| row: { id: 'row', name: 'NEON ROW', area: 'Port Varo · Market District', fog: '#0B1020' }, | |
| docks: { id: 'docks', name: 'VARO DOCKS', area: 'Port Varo · Container Terminal', fog: '#08131A' }, | |
| yard: { id: 'yard', name: 'SIGNAL YARD', area: 'Port Varo · Rail Depot', fog: '#120D14' }, | |
| }; | |
| export const MAP_IDS = Object.keys(MAPS); | |
| export const BOUND = { x: 46, z: 50 }; | |
| // Bodies in metres (feet at y): eye height, hit cylinder top and head sphere, standing and crouched. | |
| export const BODY = { r: 0.4, eye: 1.62, eyeC: 1.04, top: 1.42, topC: 0.86, head: 1.6, headC: 0.98, headR: 0.18, step: 0.45, mantle: 0.9 }; | |
| const COLS = [-30, 0, 30], ROWS = [-30, 0, 30], HALF = 9; | |
| /** One obstacle: axis-aligned box centred at (x,z), size w (x) by d (z), height h. */ | |
| const box = (x, z, w, d, h, kind, extra = {}) => ({ x, z, w, d, h, kind, ...extra }); | |
| const mirror = (o) => ({ ...o, x: -o.x, z: -o.z, mir: true, rot: o.rot != null ? o.rot + Math.PI : o.rot }); | |
| function overlaps(a, b, pad = 0) { return Math.abs(a.x - b.x) * 2 < a.w + b.w + pad * 2 && Math.abs(a.z - b.z) * 2 < a.d + b.d + pad * 2; } | |
| /** | |
| * Build a map. Same (id, seed) -> same map everywhere. Returns obstacles (collision + render), zones, spawns, lamps, | |
| * signs and decor (render only), plus a nav grid for the bots. | |
| */ | |
| export function genMap(id = 'row', seed = 1) { | |
| const R = rng(seed ^ hashStr(id)); | |
| const half = []; // obstacles for the south half (z > 0) and the east middle (z == 0 row, x > 0), mirrored after | |
| const decorH = []; const signsH = []; const lampsH = []; | |
| const zones = [{ id: 'A', x: -30, z: 0, r: 5.2 }, { id: 'B', x: 0, z: 0, r: 5.2 }, { id: 'C', x: 30, z: 0, r: 5.2 }]; | |
| const keepClear = [...zones.map((z) => ({ x: z.x, z: z.z, w: z.r * 2 + 1.2, d: z.r * 2 + 1.2 })), { x: 0, z: 45, w: 60, d: 6 }]; | |
| const free = (o, pad = 0.6) => !keepClear.some((k) => overlaps(o, k, 0)) && !half.some((h) => overlaps(o, h, pad)); | |
| const add = (o, pad) => { if (free(o, pad)) { half.push(o); return true; } return false; }; | |
| // perimeter: tall buildings around the playable area (backdrop + walls) | |
| // the camera always looks north, so the south edge is a low harbour wall and the other three sides are a tall skyline | |
| const per = [], perN = []; | |
| for (let x = -54; x <= 54; x += 12) { per.push(box(x, BOUND.z + 6, 12, 12, 2.4, 'wall')); perN.push(box(x, -BOUND.z - 6, 12, 12, R.range(14, 30), 'bldg', { facade: R.int(0, 3) })); } | |
| for (let z = -42; z <= 42; z += 12) { const h = R.range(14, 30); perN.push(box(BOUND.x + 6, z, 12, 12, h, 'bldg', { facade: R.int(0, 3) }), box(-BOUND.x - 6, -z, 12, 12, h, 'bldg', { facade: R.int(0, 3) })); } | |
| const blockFill = { | |
| row(cx, cz) { // city block: two or three buildings with an alley through | |
| const vertical = R.chance(0.5); const gap = R.range(2.6, 3.4); const off = R.range(-3, 3); | |
| if (vertical) { | |
| const wl = HALF + off - gap / 2, wr = HALF - off - gap / 2; | |
| add(box(cx - HALF + wl / 2, cz, wl, HALF * 2, R.range(5, 15), 'bldg', { facade: R.int(0, 3), sign: true }), 0); | |
| add(box(cx + HALF - wr / 2, cz, wr, HALF * 2, R.range(5, 15), 'bldg', { facade: R.int(0, 3), sign: true }), 0); | |
| } else { | |
| const dl = HALF + off - gap / 2, dr = HALF - off - gap / 2; | |
| add(box(cx, cz - HALF + dl / 2, HALF * 2, dl, R.range(5, 15), 'bldg', { facade: R.int(0, 3), sign: true }), 0); | |
| add(box(cx, cz + HALF - dr / 2, HALF * 2, dr, R.range(5, 15), 'bldg', { facade: R.int(0, 3), sign: true }), 0); | |
| } | |
| }, | |
| docks(cx, cz) { // container stacks with lanes | |
| for (let i = -1; i <= 1; i++) for (let j = -1; j <= 1; j += 2) { | |
| if (R.chance(0.18)) continue; | |
| const h = R.chance(0.45) ? 5.2 : 2.6; | |
| add(box(cx + i * 6.2, cz + j * 4.6, 2.5, 6.1, h, 'container', { tint: R.int(0, 5) }), 0.2); | |
| } | |
| }, | |
| yard(cx, cz) { // parked rail cars along x with a platform | |
| add(box(cx, cz - 5, 17, 3.1, 3.6, 'train', { tint: R.int(0, 3) }), 0.3); | |
| if (R.chance(0.7)) add(box(cx + R.range(-2, 2), cz + 1.5, 13, 3.1, 3.6, 'train', { tint: R.int(0, 3) }), 0.3); | |
| add(box(cx, cz + 6.5, 16, 2.4, 1.0, 'platform'), 0.3); | |
| }, | |
| }; | |
| const fill = blockFill[id] || blockFill.row; | |
| // south row blocks (z = +30) and the east middle block's flanks | |
| for (const cx of COLS) fill(cx, 30); | |
| // middle row: the lots (A at -30, C at 30) and the plaza (B). Only the east side is generated; mirror makes the west. | |
| const lotCover = (cx, cz) => { | |
| const kinds = id === 'docks' ? ['container', 'crate', 'barrier'] : id === 'yard' ? ['crate', 'barrier', 'pillar'] : ['car', 'barrier', 'dumpster']; | |
| for (let k = 0; k < 7; k++) { | |
| const kind = R.pick(kinds); const a = R.range(0, Math.PI * 2); const r = R.range(6.2, 8.6); | |
| const x = cx + Math.cos(a) * r, z = cz + Math.sin(a) * r; | |
| const along = R.chance(0.5); | |
| const dims = { car: [2.0, 4.4, 1.5], barrier: [3.2, 0.7, 1.2], dumpster: [2.0, 1.4, 1.5], container: [2.5, 6.1, 2.6], crate: [1.4, 1.4, 1.4], pillar: [1.2, 1.2, 4] }[kind]; | |
| add(box(x, z, along ? dims[0] : dims[1], along ? dims[1] : dims[0], dims[2], kind, { tint: R.int(0, 5) }), 0.9); | |
| } | |
| }; | |
| lotCover(30, 0); | |
| // plaza: low cover around zone B (generated for the half x > 0, mirrored) | |
| for (const [x, z, w, d, h, kind] of [[7.6, -3.4, 1.0, 3.8, 1.2, 'planter'], [3.6, 7.4, 3.4, 1.0, 1.2, 'planter'], [8.4, 6.8, 2.2, 2.2, 2.4, 'kiosk']]) add(box(x, z, w, d, h, kind), 0.2); | |
| // street furniture between blocks (south half): cars at the curb, barriers, crates, dumpsters | |
| for (let k = 0; k < 26; k++) { | |
| const vertical = R.chance(0.5); | |
| let x, z; | |
| if (vertical) { x = R.pick([-15, 15, 41.5]) + R.range(-3.2, 3.2); z = R.range(2, 46); } else { z = R.pick([15, 44]) + R.range(-3, 3); x = R.range(-44, 44); } | |
| const kind = id === 'docks' ? R.pick(['container', 'crate', 'crate', 'barrier']) : id === 'yard' ? R.pick(['crate', 'barrier', 'barrier', 'pillar']) : R.pick(['car', 'car', 'barrier', 'dumpster', 'crate']); | |
| const dims = { car: [2.0, 4.4, 1.5], barrier: [3.2, 0.7, 1.2], dumpster: [2.0, 1.4, 1.5], container: [2.5, 6.1, 2.6], crate: [1.4, 1.4, 1.4], pillar: [1.2, 1.2, 4] }[kind]; | |
| const along = vertical ? kind !== 'barrier' : kind === 'barrier'; | |
| add(box(x, z, along ? dims[0] : dims[1], along ? dims[1] : dims[0], dims[2], kind, { tint: R.int(0, 5) }), 1.6); | |
| } | |
| // climbing steps: a crate against some containers and kiosks, so their tops are reachable (jump + mantle) | |
| for (const o of half.slice()) { | |
| if (!['container', 'kiosk'].includes(o.kind) || o.h > 3 || !R.chance(0.65)) continue; | |
| const side = R.int(0, 3); const along = side % 2 === 0; // 0/2: +-z ends, 1/3: +-x sides | |
| const off = along ? (R() - 0.5) * Math.max(0, o.w - 1.4) : (R() - 0.5) * Math.max(0, o.d - 1.4); | |
| const sx = side === 1 ? 1 : side === 3 ? -1 : 0, sz = side === 0 ? 1 : side === 2 ? -1 : 0; | |
| const c = box(o.x + sx * (o.w / 2 + 0.71) + (along ? off : 0), o.z + sz * (o.d / 2 + 0.71) + (along ? 0 : off), 1.4, 1.4, 1.4, 'crate', { tint: R.int(0, 5), step: true }); | |
| if (keepClear.some((k) => overlaps(c, k, 0)) || half.some((h) => h !== o && overlaps(c, h, 0.9)) || overlaps(c, o, -0.01)) continue; | |
| if (Math.abs(c.x) > BOUND.x - 1 || Math.abs(c.z) > BOUND.z - 1) continue; | |
| half.push(c); | |
| } | |
| // street lamps and neon signs (render only) | |
| for (const x of [-15, 15]) for (const z of [8, 24, 40]) lampsH.push({ x: x + (x < 0 ? -4.2 : 4.2), z }); | |
| for (const z of [15]) for (const x of [-36, -6, 24]) lampsH.push({ x, z: z + 4.8 }); | |
| for (const o of half) if (o.kind === 'bldg' && o.sign && R.chance(0.85)) signsH.push({ on: o, side: R.int(0, 3), word: R.int(0, 9), hue: R.int(0, 4), y: Math.min(o.h - 1.2, R.range(2.6, 4.2)) }); | |
| for (let k = 0; k < 18; k++) decorH.push({ kind: R.pick(['puddle', 'puddle', 'puddle', 'vent', 'cone', 'trash']), x: R.range(-44, 44), z: R.range(1, 48), s: R.range(0.6, 1.8), a: R.range(0, 6.28) }); | |
| // mirror everything through the centre | |
| const lamps = [...lampsH, ...lampsH.map((l) => ({ x: -l.x, z: -l.z }))]; | |
| // lamp posts are solid too (thin poles: they stop bodies and bullets; never used as cover by bots) | |
| const obstacles = [...half, ...half.map(mirror), ...per, ...perN, ...lamps.map((l) => box(l.x, l.z, 0.24, 0.24, 5.4, 'lamp'))]; | |
| const signs = [...signsH, ...signsH.map((s) => ({ ...s, on: mirror(s.on), side: (s.side + 2) % 4 }))]; | |
| const decor = [...decorH, ...decorH.map((d) => ({ ...d, x: -d.x, z: -d.z }))].filter((d) => !obstacles.some((o) => inBox(o, d.x, d.z, 0.8))); | |
| const spawns = [[-22, -8, 8, 22, 0].map((x) => ({ x, z: 45.5, yaw: -Math.PI / 2 })), [22, 8, -8, -22, 0].map((x) => ({ x, z: -45.5, yaw: Math.PI / 2 }))]; | |
| const map = { id, name: (MAPS[id] || MAPS.row).name, seed, obstacles, zones, spawns, lamps, signs, decor }; | |
| map.nav = navGrid(map); | |
| return map; | |
| } | |
| // ---------------------------------------------------------------- geometry | |
| export function inBox(o, x, z, pad = 0) { return Math.abs(x - o.x) <= o.w / 2 + pad && Math.abs(z - o.z) <= o.d / 2 + pad; } | |
| /** Push a circle (x, z, r) out of every obstacle and keep it inside the bounds. Returns [x, z]. */ | |
| export function collide(map, x, z, r = 0.45) { | |
| for (let pass = 0; pass < 2; pass++) { | |
| for (const o of map.obstacles) { | |
| const hx = o.w / 2 + r, hz = o.d / 2 + r; const dx = x - o.x, dz = z - o.z; | |
| if (Math.abs(dx) >= hx || Math.abs(dz) >= hz) continue; | |
| const px = hx - Math.abs(dx), pz = hz - Math.abs(dz); | |
| if (px < pz) x += Math.sign(dx || 1) * px; else z += Math.sign(dz || 1) * pz; | |
| } | |
| } | |
| x = Math.max(-BOUND.x + r, Math.min(BOUND.x - r, x)); z = Math.max(-BOUND.z + r, Math.min(BOUND.z - r, z)); | |
| return [x, z]; | |
| } | |
| /** Ray from (ax,az) towards (bx,bz): distance fraction 0..1 to the first obstacle hit, or 1 when clear. */ | |
| export function rayHit(map, ax, az, bx, bz, minH = 0.9) { | |
| const dx = bx - ax, dz = bz - az; let best = 1; | |
| for (const o of map.obstacles) { | |
| if (o.h < minH) continue; | |
| const x0 = o.x - o.w / 2, x1 = o.x + o.w / 2, z0 = o.z - o.d / 2, z1 = o.z + o.d / 2; | |
| let t0 = 0, t1 = best; | |
| if (Math.abs(dx) < 1e-9) { if (ax < x0 || ax > x1) continue; } else { let a = (x0 - ax) / dx, b = (x1 - ax) / dx; if (a > b) [a, b] = [b, a]; t0 = Math.max(t0, a); t1 = Math.min(t1, b); if (t0 > t1) continue; } | |
| if (Math.abs(dz) < 1e-9) { if (az < z0 || az > z1) continue; } else { let a = (z0 - az) / dz, b = (z1 - az) / dz; if (a > b) [a, b] = [b, a]; t0 = Math.max(t0, a); t1 = Math.min(t1, b); if (t0 > t1) continue; } | |
| if (t0 < best) best = t0; | |
| } | |
| return best; | |
| } | |
| export const los = (map, ax, az, bx, bz) => rayHit(map, ax, az, bx, bz) >= 0.999; | |
| /** Distance along a ray (unit dir dx,dz from x,z) to a circle at (cx,cz) radius r, or -1. */ | |
| export function rayCircle(x, z, dx, dz, cx, cz, r) { | |
| const ox = cx - x, oz = cz - z; const t = ox * dx + oz * dz; if (t < 0) return -1; | |
| const d2 = ox * ox + oz * oz - t * t; if (d2 > r * r) return -1; | |
| return t - Math.sqrt(r * r - d2); | |
| } | |
| // ---------------------------------------------------------------- 3D: heights, climbing, rays | |
| /** Highest standable top under a body circle whose feet are at `feet` (tops up to a step above count). */ | |
| export function groundAt(map, x, z, feet = 0, r = BODY.r * 0.8) { | |
| let g = 0; | |
| for (const o of map.obstacles) { | |
| if (o.h > feet + BODY.step || o.h <= g) continue; | |
| if (Math.abs(x - o.x) < o.w / 2 + r && Math.abs(z - o.z) < o.d / 2 + r) g = o.h; | |
| } | |
| return g; | |
| } | |
| /** | |
| * collide() in 3D: boxes whose top is below feet + step are walked over (stood on), not pushed against. | |
| * The body is a circle against each box (closest point), so it slides along walls and rounds corners and thin | |
| * poles instead of snagging on them; a centre that ends up inside a box leaves by the shortest way out. | |
| */ | |
| export function collide3(map, x, z, feet = 0, r = 0.45) { | |
| for (let pass = 0; pass < 3; pass++) { | |
| let moved = false; | |
| for (const o of map.obstacles) { | |
| if (o.h <= feet + BODY.step) continue; | |
| const hw = o.w / 2, hd = o.d / 2; const dx = x - o.x, dz = z - o.z; | |
| if (Math.abs(dx) >= hw + r || Math.abs(dz) >= hd + r) continue; | |
| if (Math.abs(dx) <= hw && Math.abs(dz) <= hd) { // centre inside: shortest axis out | |
| const px = hw + r - Math.abs(dx), pz = hd + r - Math.abs(dz); | |
| if (px < pz) x += Math.sign(dx || 1) * px; else z += Math.sign(dz || 1) * pz; moved = true; continue; | |
| } | |
| const cx = Math.max(-hw, Math.min(hw, dx)), cz = Math.max(-hd, Math.min(hd, dz)); const ex = dx - cx, ez = dz - cz; | |
| const d2 = ex * ex + ez * ez; if (d2 >= r * r) continue; | |
| const d = Math.sqrt(d2) || 1e-6; const push = r - d; x += (ex / d) * push; z += (ez / d) * push; moved = true; | |
| } | |
| if (!moved) break; | |
| } | |
| x = Math.max(-BOUND.x + r, Math.min(BOUND.x - r, x)); z = Math.max(-BOUND.z + r, Math.min(BOUND.z - r, z)); | |
| return [x, z]; | |
| } | |
| /** A box the body (at x,z, feet) is pressing against that it can mantle onto (top within reach), or null. */ | |
| export function mantleTarget(map, x, z, feet, r = 0.5) { | |
| let best = null; | |
| for (const o of map.obstacles) { | |
| if (o.h <= feet + BODY.step || o.h > feet + BODY.mantle || o.kind === 'bldg' || o.kind === 'wall') continue; | |
| if (Math.abs(x - o.x) < o.w / 2 + r && Math.abs(z - o.z) < o.d / 2 + r && (!best || o.h > best.h)) best = o; | |
| } | |
| return best; | |
| } | |
| /** | |
| * 3D ray from A towards B against every box (y from 0 to h) and the ground: { f: fraction 0..1 of the first hit | |
| * (1 = clear), nx, ny, nz: surface normal there }. | |
| */ | |
| export function rayHit3(map, ax, ay, az, bx, by, bz) { | |
| const dx = bx - ax, dy = by - ay, dz = bz - az; let best = 1, n = [0, 0, 0]; | |
| if (dy < -1e-9) { const t = -ay / dy; if (t >= 0 && t < best) { best = t; n = [0, 1, 0]; } } | |
| for (const o of map.obstacles) { | |
| const lo = [o.x - o.w / 2, 0, o.z - o.d / 2], hi = [o.x + o.w / 2, o.h, o.z + o.d / 2]; const p = [ax, ay, az], d = [dx, dy, dz]; | |
| let t0 = 0, t1 = best, axis = -1, sgn = 0, miss = false; | |
| for (let k = 0; k < 3; k++) { | |
| if (Math.abs(d[k]) < 1e-9) { if (p[k] < lo[k] || p[k] > hi[k]) { miss = true; break; } continue; } | |
| let a = (lo[k] - p[k]) / d[k], b = (hi[k] - p[k]) / d[k], s = -1; | |
| if (a > b) { [a, b] = [b, a]; s = 1; } | |
| if (a > t0) { t0 = a; axis = k; sgn = s; } | |
| if (b < t1) t1 = b; | |
| if (t0 > t1) { miss = true; break; } | |
| } | |
| if (miss || axis < 0 || t0 >= best) continue; | |
| best = t0; n = [0, 0, 0]; n[axis] = sgn; | |
| } | |
| return { f: best, nx: n[0], ny: n[1], nz: n[2] }; | |
| } | |
| export const los3 = (map, ax, ay, az, bx, by, bz) => rayHit3(map, ax, ay, az, bx, by, bz).f >= 0.999; | |
| /** Unit view direction for yaw (around y, 0 = +x) and pitch (up positive). */ | |
| export const dir3 = (yaw, pitch) => { const c = Math.cos(pitch); return [Math.cos(yaw) * c, Math.sin(pitch), Math.sin(yaw) * c]; }; | |
| /** | |
| * Ray (origin o, unit dir d) against a standing body (feet at fx,fy,fz; crouch 0..1): distance to the first hit, or -1, | |
| * and whether it is the head. Body = vertical cylinder, head = sphere on top. | |
| */ | |
| export function rayBody(o, d, fx, fy, fz, crouch = 0) { | |
| const top = fy + BODY.top + (BODY.topC - BODY.top) * crouch; const hy = fy + BODY.head + (BODY.headC - BODY.head) * crouch; | |
| let tBody = -1; | |
| { // cylinder (x,z circle), clipped to [fy, top] | |
| const ox = o[0] - fx, oz = o[2] - fz; const a = d[0] * d[0] + d[2] * d[2]; const b = 2 * (ox * d[0] + oz * d[2]); const c = ox * ox + oz * oz - BODY.r * BODY.r; | |
| let lo = -Infinity, hi = Infinity; | |
| if (a > 1e-12) { const D = b * b - 4 * a * c; if (D >= 0) { const s = Math.sqrt(D); lo = (-b - s) / (2 * a); hi = (-b + s) / (2 * a); } else { lo = 1; hi = 0; } } else if (c > 0) { lo = 1; hi = 0; } | |
| if (Math.abs(d[1]) > 1e-12) { let y0 = (fy - o[1]) / d[1], y1 = (top - o[1]) / d[1]; if (y0 > y1) [y0, y1] = [y1, y0]; lo = Math.max(lo, y0); hi = Math.min(hi, y1); } else if (o[1] < fy || o[1] > top) { lo = 1; hi = 0; } | |
| if (lo <= hi && hi >= 0) tBody = Math.max(0, lo); | |
| } | |
| let tHead = -1; | |
| { const ox = o[0] - fx, oy = o[1] - hy, oz = o[2] - fz; const b = ox * d[0] + oy * d[1] + oz * d[2]; const c = ox * ox + oy * oy + oz * oz - BODY.headR * BODY.headR; const D = b * b - c; if (D >= 0) { const t = -b - Math.sqrt(D); if (t >= 0) tHead = t; } } | |
| if (tHead >= 0 && (tBody < 0 || tHead <= tBody + 0.05)) return { t: tHead, head: true }; | |
| return tBody >= 0 ? { t: tBody, head: false } : null; | |
| } | |
| // ---------------------------------------------------------------- navigation (grid BFS, 1 m cells) | |
| export function navGrid(map) { | |
| const W = BOUND.x * 2, H = BOUND.z * 2; const block = new Uint8Array(W * H); | |
| for (let j = 0; j < H; j++) for (let i = 0; i < W; i++) { | |
| const x = i - BOUND.x + 0.5, z = j - BOUND.z + 0.5; | |
| if (map.obstacles.some((o) => inBox(o, x, z, 0.55))) block[j * W + i] = 1; | |
| } | |
| return { W, H, block, cache: new Map() }; | |
| } | |
| const cellOf = (nav, x, z) => { const i = Math.max(0, Math.min(nav.W - 1, Math.floor(x + BOUND.x))); const j = Math.max(0, Math.min(nav.H - 1, Math.floor(z + BOUND.z))); return j * nav.W + i; }; | |
| /** Distance field (in steps) to the target point; cached per target cell. */ | |
| export function field(nav, tx, tz) { | |
| const t = cellOf(nav, tx, tz); let f = nav.cache.get(t); if (f) return f; | |
| const { W, H, block } = nav; f = new Int32Array(W * H).fill(-1); const q = new Int32Array(W * H); let qh = 0, qt = 0; | |
| f[t] = 0; q[qt++] = t; | |
| while (qh < qt) { | |
| const c = q[qh++]; const ci = c % W, cj = (c - ci) / W; const d = f[c] + 1; | |
| if (ci > 0 && f[c - 1] < 0 && !block[c - 1]) { f[c - 1] = d; q[qt++] = c - 1; } | |
| if (ci < W - 1 && f[c + 1] < 0 && !block[c + 1]) { f[c + 1] = d; q[qt++] = c + 1; } | |
| if (cj > 0 && f[c - W] < 0 && !block[c - W]) { f[c - W] = d; q[qt++] = c - W; } | |
| if (cj < H - 1 && f[c + W] < 0 && !block[c + W]) { f[c + W] = d; q[qt++] = c + W; } | |
| } | |
| if (nav.cache.size > 64) nav.cache.clear(); | |
| nav.cache.set(t, f); return f; | |
| } | |
| /** Unit direction that walks down the distance field from (x, z) towards its target; [0,0] when there. */ | |
| export function steer(nav, f, x, z) { | |
| const c = cellOf(nav, x, z); const { W } = nav; const here = f[c]; | |
| if (here === 0) return [0, 0]; | |
| let best = here < 0 ? 1e9 : here, bx = 0, bz = 0; | |
| const ci = c % W, cj = (c - ci) / W; | |
| for (let dj = -2; dj <= 2; dj++) for (let di = -2; di <= 2; di++) { | |
| if (!di && !dj) continue; const i = ci + di, j = cj + dj; if (i < 0 || j < 0 || i >= W || j >= nav.H) continue; | |
| const v = f[j * W + i]; if (v < 0) continue; | |
| const s = v + Math.hypot(di, dj) * 0.01; | |
| if (s < best) { best = s; bx = di; bz = dj; } | |
| } | |
| const l = Math.hypot(bx, bz) || 1; return [bx / l, bz / l]; | |
| } | |
| export function reachable(map, ax, az, bx, bz) { const f = field(map.nav, bx, bz); return f[cellOf(map.nav, ax, az)] >= 0; } | |
| // ---------------------------------------------------------------- the daily contract | |
| const CONTRACTS = [ | |
| { id: 'kills12', text: 'Win with 12+ eliminations', test: (r) => r.win && r.kills >= 12 }, | |
| { id: 'caps4', text: 'Capture 4 zones', test: (r) => r.caps >= 4 }, | |
| { id: 'streak5', text: 'Call in a Sentry (5 in a row)', test: (r) => r.bestStreak >= 5 }, | |
| { id: 'score3k', text: 'Score 3,000 points', test: (r) => r.score >= 3000 }, | |
| { id: 'kd2', text: 'Finish with 2.0 K/D or better', test: (r) => r.kills >= 4 && r.kills >= r.deaths * 2 }, | |
| { id: 'win', text: 'Win the match', test: (r) => r.win }, | |
| { id: 'lancer8', text: 'Win with the Lancer and 8+ eliminations', test: (r) => r.win && r.weapon === 'lancer' && r.kills >= 8 }, | |
| { id: 'breach8', text: '8 eliminations with the Breach-12', test: (r) => r.weapon === 'breach' && r.kills >= 8 }, | |
| ]; | |
| export function contract(day) { | |
| const R = rng(hashStr(`contract-${day}`)); | |
| const map = MAP_IDS[((day % MAP_IDS.length) + MAP_IDS.length) % MAP_IDS.length]; | |
| const c = CONTRACTS[Math.floor(R() * CONTRACTS.length)]; | |
| return { day, map, seed: hashStr(`turf-${day}`), id: c.id, text: c.text, test: c.test }; | |
| } | |
| export const fmt = (n) => Math.round(n).toLocaleString('en-US'); | |