// Simple driveable car. Box chassis, four wheels, basic physics. // Player interacts with the car -> transferControl routes input to car.onInput. // Car radio playlist — single source of truth in scripts/lib/playlist.js. // car.js drives the audio entity; ui.js reads names + durations for the // progress display. Add new uploads in the lib file. const { PLAYLIST } = require("lib/playlist.js"); const { explodeCar } = require("lib/car-explosion.js"); const WHEEL_R = 0.35; const HW = 0.85; // chassis half-width — wheel X const FZ = -1.3; // front axle Z const RZ = 1.3; // rear axle Z const SUSP_REST = 0.35; // Heavier damping (compression/relaxation) so the suspension doesn't pump at // high speed. maxSuspensionForce raised so brief load spikes don't bottom out. const SUSP = { radius: WHEEL_R, suspensionRestLength: SUSP_REST, suspensionStiffness: 45, suspensionCompression: 7, suspensionRelaxation: 8, frictionSlip: 9, maxSuspensionForce: 14000, }; const WHEELS = [ { position: { x: -HW, y: 0, z: FZ }, ...SUSP }, { position: { x: HW, y: 0, z: FZ }, ...SUSP }, { position: { x: -HW, y: 0, z: RZ }, ...SUSP }, { position: { x: HW, y: 0, z: RZ }, ...SUSP }, ]; const DRIVE_FORCE = 540; const BRAKE_FORCE = 18; const ENGINE_BRAKE = 3; const STEER_MAX = (Math.PI / 7) * 1.5; // quick rack at low speed const STEER_MIN = (Math.PI / 14) * 1.5; // tight rack at top speed const STEER_SPEED_FACTOR = 0.06; const STEER_LERP = 0.22; // per-tick alpha — lower = smoother const DRIFT_MIN_SPEED = 5; // m/s before handbrake actually drifts const DRIFT_FRICTION = 1.6; // rear friction during drift (default ~9) const DRIFT_BRAKE = 2.5; // light brake on rear during drift const SKID_MAX = 80; // cap total skid marks before recycling — keep small to stay light const SKID_MIN_SEG = 0.6; // min meters between stamps; long marks not pixel-spam // --- Burger kitchen --------------------------------------------------------- // Level 0 = stock. Each cook-time upgrade shaves 0.25s off the cook. // Each recipe upgrade shaves 0.5 meat off the ratio. Both lock at level 10. const COOK_TIME_BASE = 3; // seconds — fresh kitchen const COOK_TIME_STEP = 0.2; const COOK_TIME_MAX_LEVEL = 10; // 10 × 0.2 = 2.0s reduction → floor 1.0s const RECIPE_BASE = 10; // meat per burger const RECIPE_STEP = 0.5; const RECIPE_MAX_LEVEL = 10; // 10 × 0.5 = 5 meat reduction → floor 5 // Hull armor — 5% damage reduction per level, cap at 10 = 50% reduction. const HULL_STEP = 0.05; const HULL_MAX_LEVEL = 10; // Butcher — +0.5 average meat per level. 9 levels. // Every even level locks in a guaranteed +1 bonus chunk on kill. // Odd levels add 50% chance for the NEXT chunk. // L1: 50% chance +1. L2: +1 guaranteed. L9: +4 guaranteed, 50% chance +5. // Base kill drops 3 chunks; max butcher averages 7.5 chunks per kill. const BUTCHER_MAX_LEVEL = 9; function butcherGuaranteedFor(level) { const L = Math.max(0, Math.min(BUTCHER_MAX_LEVEL, level | 0)); return Math.floor(L / 2); } function butcherChanceFor(level) { const L = Math.max(0, Math.min(BUTCHER_MAX_LEVEL, level | 0)); return (L % 2) * 0.5; } // Tip jar — +5% chance per level for DOUBLE cash on a sale. Max 10 = 50%. const TIP_STEP = 0.05; const TIP_MAX_LEVEL = 10; // Garage costs — all upgrades start at $10 and double every level. function cookTimeFor(level) { return Math.max(COOK_TIME_BASE - COOK_TIME_STEP * COOK_TIME_MAX_LEVEL, COOK_TIME_BASE - COOK_TIME_STEP * (level | 0)); } function recipeFor(level) { return Math.max(RECIPE_BASE - RECIPE_STEP * RECIPE_MAX_LEVEL, RECIPE_BASE - RECIPE_STEP * (level | 0)); } function hullReductionFor(level) { return Math.min(HULL_STEP * HULL_MAX_LEVEL, HULL_STEP * (level | 0)); } function tipChanceFor(level) { return Math.min(TIP_STEP * TIP_MAX_LEVEL, TIP_STEP * (level | 0)); } function cookTimeCost(level) { return 5 * Math.pow(2, level | 0); } function recipeCost(level) { return 5 * Math.pow(2, level | 0); } function hullCost(level) { return 5 * Math.pow(2, level | 0); } function butcherCost(level) { return 5 * Math.pow(2, level | 0); } function tipCost(level) { return 5 * Math.pow(2, level | 0); } export function onSpawn(objectApi) { // Invisible vehicle body objectApi.setProperty("primitive", { kind: "box", width: 1.8, height: 0.5, depth: 4.0 }); objectApi.setProperty("visible", false); // Smooth root position between physics ticks. High teleport threshold so // prediction reconciles at speed don't snap the chassis back visibly. objectApi.setProperty("interpolation", { teleportThreshold: 200 }); objectApi.setProperty("physics", { body: "vehicle", mass: 110, restitution: 0.05, linearDamping: 0.1, angularDamping: 3.5, // No more flipping — lock the swing axes (pitch + roll) so cornering // forces can never tip the car over. Yaw stays free for steering. lockedAxes: ["swing"], wheels: WHEELS, }); const P = objectApi.id; const PAINT = { color: "oklch(0.55 0.20 25)", roughness: 0.35, metalness: 0.4 }; const DARK = { color: "oklch(0.18 0.01 0)", roughness: 0.6 }; const GLASS = { color: "oklch(0.40 0.06 230)", roughness: 0.1, opacity: 0.4, transparent: true }; const TIRE = { color: "oklch(0.15 0.01 0)", roughness: 0.95 }; const RIM = { color: "oklch(0.85 0 0)", roughness: 0.25, metalness: 0.7 }; const TAIL = { color: "oklch(0.55 0.25 25)", roughness: 0.2, emissive: "oklch(0.5 0.25 25)", emissiveIntensity: 1.2 }; const HEAD = { color: "oklch(0.95 0.04 90)", roughness: 0.1, emissive: "oklch(0.95 0.05 90)", emissiveIntensity: 1.6 }; // ── Primitive truck rig ────────────────────────────────────────────── // Six boxes + four sphere lights. Cab in front (-Z forward), cargo box // behind, windshield on cab front, tail/head lights as emissive caps. // Wheels stay procedural below (they spin + steer with the raycasts). // Cab: driver compartment, sits at front (-Z). objectApi.spawn("cab", { parent: P, properties: { feetPosition: { x: 0, y: 0.25, z: -1.2 }, primitive: { kind: "box", width: 1.7, height: 1.0, depth: 1.4 }, material: PAINT, interpolation: { teleportThreshold: 20 }, }, }); // Cargo box: the burger-rig back. Taller + wider than the cab so it reads // as a delivery truck, not a car. objectApi.spawn("cargo", { parent: P, properties: { feetPosition: { x: 0, y: 0.3, z: 0.7 }, primitive: { kind: "box", width: 1.9, height: 1.6, depth: 2.4 }, material: PAINT, interpolation: { teleportThreshold: 20 }, }, }); // Windshield: thin glass slab on the cab's front face. Slight forward tilt // baked into geometry by sitting just ahead of the cab. objectApi.spawn("windshield", { parent: P, properties: { feetPosition: { x: 0, y: 0.7, z: -1.85 }, primitive: { kind: "box", width: 1.5, height: 0.55, depth: 0.08 }, material: GLASS, interpolation: { teleportThreshold: 20 }, }, }); // Headlights: two emissive spheres at the front bumper. for (const sx of [-0.55, 0.55]) { objectApi.spawn("headlight-" + (sx < 0 ? "L" : "R"), { parent: P, properties: { feetPosition: { x: sx, y: 0.35, z: -1.95 }, primitive: { kind: "sphere", radius: 0.12 }, material: HEAD, interpolation: { teleportThreshold: 20 }, }, }); } // Taillights: small emissive red boxes at the cargo box back. for (const sx of [-0.7, 0.7]) { objectApi.spawn("taillight-" + (sx < 0 ? "L" : "R"), { parent: P, properties: { feetPosition: { x: sx, y: 0.5, z: 1.92 }, primitive: { kind: "box", width: 0.25, height: 0.18, depth: 0.06 }, material: TAIL, interpolation: { teleportThreshold: 20 }, }, }); } // Dark roof strip (decorative; reads as roof seam). objectApi.spawn("roof-strip", { parent: P, properties: { feetPosition: { x: 0, y: 1.92, z: 0.7 }, primitive: { kind: "box", width: 2.0, height: 0.08, depth: 2.5 }, material: DARK, interpolation: { teleportThreshold: 20 }, }, }); // Wheels (tires + rims). Cylinder on its side: roll: 90. // Right wheels get a small visual nudge to match the left side's stance. for (let i = 0; i < WHEELS.length; i++) { const w = WHEELS[i].position; const visualX = w.x > 0 ? w.x + 0.15 : w.x + 0.15; objectApi.spawn("wheel-" + i, { parent: P, properties: { feetPosition: { x: visualX, y: w.y - WHEEL_R, z: w.z }, primitive: { kind: "cylinder", radius: WHEEL_R, height: 0.28 }, rotation: { roll: 90 }, material: TIRE, interpolation: { teleportThreshold: 20 }, }, }); objectApi.spawn("rim-" + i, { parent: P, properties: { feetPosition: { x: visualX + (w.x < 0 ? -0.07 : 0.07), y: w.y - WHEEL_R, z: w.z }, primitive: { kind: "cylinder", radius: WHEEL_R * 0.55, height: 0.04 }, rotation: { roll: 90 }, material: RIM, interpolation: { teleportThreshold: 20 }, }, }); } // No rooftop driver — the car drives itself, no figure on the roof. // The real player is hidden in onControlBegin and stays hidden. // ── Truck worklight ────────────────────────────────────────────────── // The neon sign was obstructing the camera, so it's gone. The warm point // light it carried stays — mounted high above the cab so the chassis and // a few meters of street around it glow at night. objectApi.spawn("sign-light", { parent: P, properties: { feetPosition: { x: 0, y: 3.2, z: -0.2 }, light: { kind: "point", color: "oklch(0.88 0.18 60)", intensity: 6.0, distance: 22, decay: 1.4, }, }, }); objectApi.replaceState({ gas: 0, steer: 0, brake: 0, currentSteering: 0, speed: 0, fuel: 1.0, // 0.0 empty → 1.0 full hp: 100, hpMax: 100, now: 0, flipReadyAt: 0, flipCooldown: 10, // seconds, exposed so UI can show it flipCost: 0.1, // 10% fuel flippedFor: 0, // seconds spent upside-down (for auto-recovery) meat: 0, burgers: 3, // starter stash — first three sales without cooking money: 10, // starter cash — small cushion for the first refuel cookTimeLevel: 0, recipeLevel: 0, hullLevel: 0, stoppedFor: 0, hitCooldown: {}, garageOpen: false, // populated by world-clock manager each tick: day: 1, phase: "dawn", dayFrac: 0, gameOver: false, daysSurvived: 0, }); } export function onInteract(other, objectApi) { if (!other.tags || !other.tags.includes("player")) return; // Allow re-take when: // - nobody is the controller, OR // - the same player is "the controller" per the engine but our // controlActive flag is false — that's the half-mount limbo where the // control link drifted off without onControlEnd firing. Re-firing // transferControl re-fires onControlBegin and re-parents/re-hides // cleanly. const ctrl = objectApi.getController(); const s = objectApi.getState(); const alreadyMine = ctrl === other.id && s.controlActive; if (alreadyMine) return; objectApi.transferControl(other.id, objectApi.id); } export function onControlBegin(player, objectApi) { // Mark active driver — zombies can damage car only while controlled. objectApi.patchState({ controlActive: true }); // --- Engine audio -------------------------------------------------------- // One-shot ignition kicks, then a low looping engine bed underneath // everything you do in the car. Stored loop id so onControlEnd can kill it. const pos = objectApi.getProperty("feetPosition"); objectApi.playSound( "/cdn/moodboard-zomburger/sfx-engine-start.mp3", { position: pos, volume: 0.85, pitch: 0.95 } ); // Stop any orphan loop from a previous mount before starting a fresh one — // half-mount limbo can leave the old id dangling. const prev = objectApi.getState().engineLoopId; if (prev) { try { objectApi.stopSound(prev); } catch (e) {} } const loopId = objectApi.playSound( "/cdn/moodboard-zomburger/sfx-engine-loop.mp3", { position: pos, volume: 0.35, pitch: 0.9, loop: true } ); objectApi.patchState({ engineLoopId: loopId || "" }); // Hide the player while driving — the visible rooftop "driver" is a // separate dummy child (see "driver" spawn in onSpawn). Scaling the real // player or sitting it on top of a vehicle body messed with the physics. objectApi.setObjectProperty(player.id, "visible", false); objectApi.setObjectProperty(player.id, "parent", objectApi.id); objectApi.setObjectProperty(player.id, "feetPosition", { x: 0, y: 0.5, z: -0.1 }); objectApi.setObjectProperty(player.id, "scale", 1); objectApi.setObjectProperty(player.id, "physics", null); // Chase camera with the cursor FREE. The driver needs to be able to // reach UI buttons (Cook Burger, garage tabs) without escaping a lock, // so we never request pointer lock while mounted. Mouse-look isn't // used in chase view anyway. objectApi.setCamera({ kind: "custom", state: { headingYaw: 0, followDist: 10, currentDist: 10 }, pointerLock: false, hideLocalPlayer: true, behavior: ["scripts/camera.js"], }, { mode: "replace" }); // Show the controls toast ONCE per session. onControlBegin can fire many // times when the engine half-mounts and the player.js tryMount loop // re-fires transferControl every 0.25s — without this gate the player // gets spammed by the prompt. if (!objectApi.getState().controlsToastShown) { objectApi.toast("WASD drive · Space brake · E sell / garage", { duration: 3 }); objectApi.patchState({ controlsToastShown: true }); } return true; } export function onControlEnd(player, objectApi) { // Cook sessions DO NOT cancel on dismount — they always complete. The // grill stays on the roof until the 3s timer finishes in update(). // Kill the engine loop. If onControlBegin runs again it'll start fresh. const loopId = objectApi.getState().engineLoopId; if (loopId) { try { objectApi.stopSound(loopId); } catch (e) {} } objectApi.clearCamera(); objectApi.patchState({ gas: 0, steer: 0, brake: 0, currentSteering: 0, controlActive: false, engineLoopId: "" }); for (let i = 0; i < 4; i++) { objectApi.setWheelEngineForce(i, 0); objectApi.setWheelBrake(i, 0); objectApi.setWheelSteering(i, 0); } const pos = objectApi.getProperty("feetPosition"); objectApi.setObjectProperty(player.id, "parent", false); objectApi.setObjectProperty(player.id, "feetPosition", { x: pos.x + 2.5, y: pos.y, z: pos.z }); objectApi.setObjectProperty(player.id, "physics", { body: "character" }); objectApi.setObjectProperty(player.id, "visible", true); objectApi.setObjectProperty(player.id, "scale", 1); } export function onInput(input, objectApi) { // Drive-thru sell is E-press only now — no RMB aim, no LMB lob. // The customer-prompt block down in `interact` handles the sale handshake. // Restart — handled HERE because input routes to the control target, and // during gameOver freeze the car still owns control (we just zero the // wheels, we don't release). Mirror the same patches player.js writes so // either entity picking it up does the right thing: // - bump car.resetRequestId so world-clock notices and runs the cascade // - clear car.gameOver immediately so the YOU DIED overlay drops now // - set car.lastResetAt so the instant-death gate at line ~1218 holds // the 3s window open until reset block restores hp=100 // Restart works any time — dead OR alive. If the player wants a fresh // world mid-run, they get one. 2s debounce stops a stuck key from // spamming resetRequestId every tick. if (input.actions.restart) { const s = objectApi.getState(); const nowT = s.now ?? 0; let last = s.lastRestartAt ?? -999; if (last > nowT) last = -999; if (nowT - last >= 2.0) { // Fill house + car HP RIGHT NOW, before anything else looks. Otherwise // there's a tick between this and world-clock's reset block where the // modal is hidden, the player is "alive", and the world-clock's next // game-over check reads house.hp=0 → fires gameOver again immediately. // The user lands in YOU DIED → R → YOU DIED → R loop. // World-clock's reset block still runs the full cascade (clearing // zombies, fresh wave seq, etc.) — this is just a sync prefill so the // intermediate frames see a healthy world. const houses = objectApi.query({ tags: ["garage"], radius: 1e9 }); for (const h of houses) { const hpMax = (h.state && h.state.hpMax) || 500; objectApi.patchObjectState(h.id, { hp: hpMax }); } const carHpMax = s.hpMax ?? 100; objectApi.patchState({ resetRequestId: (s.resetRequestId ?? 0) + 1, gameOver: false, hp: carHpMax, lastResetAt: nowT, lastRestartAt: nowT, }); objectApi.toast("RESTARTING...", { duration: 1.2 }); } return; } // Garage UI actions // ONE FIX button. $10 = full heal. If broke, spend whatever you have for // a proportional patch. Never get locked out by having $3. if (input.actions.buyHeal) { const s = objectApi.getState(); if (!s.garageOpen) return; const hpMax = s.hpMax ?? 100; const curHp = s.hp ?? 0; if (curHp >= hpMax) { objectApi.toast("HULL FULL", { duration: 1.2 }); return; } const money = s.money ?? 0; if (money <= 0) { objectApi.toast("NOT ENOUGH $", { duration: 1.2 }); return; } const HULL_FULL_COST = 10; const spend = Math.min(money, HULL_FULL_COST); const heal = Math.round((spend / HULL_FULL_COST) * hpMax); const newHp = Math.min(hpMax, curHp + heal); const actualHeal = newHp - curHp; objectApi.patchState({ money: money - spend, hp: newHp }); objectApi.toast("+" + actualHeal + " HULL · -$" + spend, { duration: 1.2 }); // Heal VFX — floating green pop + heal particle burst above the truck so // the patch-up feels like a thing, not a silent number tick. const carPos = objectApi.getProperty("feetPosition"); if (carPos) { objectApi.damageNumber( { x: carPos.x, y: carPos.y + 2.2, z: carPos.z }, actualHeal, { text: "+" + actualHeal + " ❤️", color: "oklch(0.85 0.22 145)", scale: 1.4, audience: { kind: "place" }, } ); objectApi.particleBurst( { x: carPos.x, y: carPos.y + 1.4, z: carPos.z }, "heal", { scale: 1.1, color: "oklch(0.85 0.25 145)", audience: { kind: "place" }, } ); } return; } // Repair the safehouse — self-calculating. Full heal cost = 5 + day * 5. // The bill scales with missing HP, so half-damaged = half cost. If the // player can't afford the full repair, they spend whatever they've got // for a proportional patch — never get locked out by being broke. if (input.actions.buyRepairHouse) { const s = objectApi.getState(); if (!s.garageOpen) return; const houses = objectApi.query({ tags: ["garage"], radius: 1e9 }); if (houses.length === 0) { objectApi.toast("NO HOUSE FOUND", { duration: 1.2 }); return; } const house = houses[0]; const hs = objectApi.getObjectState(house.id) || {}; const hpMax = hs.hpMax ?? 500; const curHp = typeof hs.hp === "number" ? hs.hp : hpMax; if (curHp >= hpMax) { objectApi.toast("HOUSE FULL HP", { duration: 1.2 }); return; } const money = s.money ?? 0; if (money <= 0) { objectApi.toast("NOT ENOUGH $", { duration: 1.2 }); return; } const day = Math.max(1, s.day ?? 1); const fullCost = 5 + day * 5; const missing = hpMax - curHp; const requiredCost = Math.max(1, Math.ceil(fullCost * (missing / hpMax))); const spend = Math.min(money, requiredCost); const healPerDollar = hpMax / fullCost; const heal = Math.min(missing, Math.round(spend * healPerDollar)); const newHp = Math.min(hpMax, curHp + heal); objectApi.patchObjectState(house.id, { hp: newHp }); objectApi.patchState({ money: money - spend }); objectApi.toast("+" + heal + " HOUSE · -$" + spend, { duration: 1.5 }); // Heal VFX over the safehouse — green damage-number + heal particle burst // at the building's center so the repair reads as a moment, not a toast. const hp = house.feetPosition; if (hp) { objectApi.damageNumber( { x: hp.x, y: hp.y + 4.2, z: hp.z }, heal, { text: "+" + heal + " 🏚️", color: "oklch(0.85 0.22 145)", scale: 1.5, audience: { kind: "place" }, } ); objectApi.particleBurst( { x: hp.x, y: hp.y + 3.0, z: hp.z }, "heal", { scale: 1.6, color: "oklch(0.85 0.25 145)", audience: { kind: "place" }, } ); } return; } if (input.actions.closeGarage) { objectApi.patchState({ garageOpen: false }); return; } if (input.actions.buyFuel) { const s = objectApi.getState(); if (!s.garageOpen) return; // $5 fills a full tank on day 1. Scarcity: +$1 per day past day 1. // Broke? Buy a partial top-up at the same per-litre rate. const fuelNow = Math.max(0, Math.min(1, s.fuel ?? 1)); if (fuelNow >= 0.999) { objectApi.toast("TANK ALREADY FULL", { duration: 1.2 }); return; } const money = s.money ?? 0; if (money <= 0) { objectApi.toast("NOT ENOUGH $", { duration: 1.2 }); return; } const dayNow = Math.max(1, s.day ?? 1); const fullTankCost = 5 + (dayNow - 1); const missing = 1 - fuelNow; const wantCost = Math.max(1, Math.ceil(fullTankCost * missing)); const spend = Math.min(money, wantCost); const fuelAdded = (spend / fullTankCost); const newFuel = Math.min(1, fuelNow + fuelAdded); objectApi.patchState({ money: money - spend, fuel: newFuel }); const filledFull = newFuel >= 0.999; objectApi.toast(filledFull ? "FULL TANK · -$" + spend : `+${Math.round((newFuel - fuelNow) * 100)}% FUEL · -${spend}`, { duration: 1.2 }); return; } if (input.actions.upgradeCookTime) { const s = objectApi.getState(); if (!s.garageOpen) return; const lvl = s.cookTimeLevel ?? 0; if (lvl >= COOK_TIME_MAX_LEVEL) { objectApi.toast("COOK TIME MAXED", { duration: 1.2 }); return; } const cost = cookTimeCost(lvl); if ((s.money ?? 0) < cost) { objectApi.toast("NOT ENOUGH $", { duration: 1.2 }); return; } objectApi.patchState({ money: (s.money ?? 0) - cost, cookTimeLevel: lvl + 1 }); objectApi.toast("COOK -0.25s · -$" + cost, { duration: 1.2 }); return; } if (input.actions.upgradeRecipe) { const s = objectApi.getState(); if (!s.garageOpen) return; const lvl = s.recipeLevel ?? 0; if (lvl >= RECIPE_MAX_LEVEL) { objectApi.toast("RECIPE MAXED", { duration: 1.2 }); return; } const cost = recipeCost(lvl); if ((s.money ?? 0) < cost) { objectApi.toast("NOT ENOUGH $", { duration: 1.2 }); return; } objectApi.patchState({ money: (s.money ?? 0) - cost, recipeLevel: lvl + 1 }); objectApi.toast("RECIPE -0.5 MEAT · -$" + cost, { duration: 1.2 }); return; } if (input.actions.upgradeHull) { const s = objectApi.getState(); if (!s.garageOpen) return; const lvl = s.hullLevel ?? 0; if (lvl >= HULL_MAX_LEVEL) { objectApi.toast("HULL MAXED", { duration: 1.2 }); return; } const cost = hullCost(lvl); if ((s.money ?? 0) < cost) { objectApi.toast("NOT ENOUGH $", { duration: 1.2 }); return; } objectApi.patchState({ money: (s.money ?? 0) - cost, hullLevel: lvl + 1 }); objectApi.toast("HULL +5% · -$" + cost, { duration: 1.2 }); return; } if (input.actions.upgradeButcher) { const s = objectApi.getState(); if (!s.garageOpen) return; const lvl = s.butcherLevel ?? 0; if (lvl >= BUTCHER_MAX_LEVEL) { objectApi.toast("BUTCHER MAXED", { duration: 1.2 }); return; } const cost = butcherCost(lvl); if ((s.money ?? 0) < cost) { objectApi.toast("NOT ENOUGH $", { duration: 1.2 }); return; } const newLvl = lvl + 1; objectApi.patchState({ money: (s.money ?? 0) - cost, butcherLevel: newLvl }); // New model: each level adds +0.5 meat to the single chunk a kill drops. const _amt = (1 + newLvl * 0.5).toFixed(1); const msg = newLvl === BUTCHER_MAX_LEVEL ? `BUTCHER MAX · ${_amt} MEAT/KILL · -${cost}` : `BUTCHER L${newLvl} · ${_amt} MEAT/KILL · -${cost}`; objectApi.toast(msg, { duration: 1.4 }); return; } if (input.actions.upgradeTip) { const s = objectApi.getState(); if (!s.garageOpen) return; const lvl = s.tipLevel ?? 0; if (lvl >= TIP_MAX_LEVEL) { objectApi.toast("TIP JAR MAXED", { duration: 1.2 }); return; } const cost = tipCost(lvl); if ((s.money ?? 0) < cost) { objectApi.toast("NOT ENOUGH $", { duration: 1.2 }); return; } objectApi.patchState({ money: (s.money ?? 0) - cost, tipLevel: lvl + 1 }); objectApi.toast("TIP JAR +5% · -$" + cost, { duration: 1.2 }); return; } // --- DEFENSE TAB --- // Hull max HP — bumps both hpMax AND current hp by the step so the new // capacity isn't just a paper number. 5 levels × +25 HP = 100 → 225 HP cap. if (input.actions.upgradeHullMax) { const s = objectApi.getState(); if (!s.garageOpen) return; const lvl = s.hullMaxLevel ?? 0; const MAX = 5; const STEP = 25; if (lvl >= MAX) { objectApi.toast("HULL CAP MAXED", { duration: 1.2 }); return; } const cost = 5 * Math.pow(2, lvl); if ((s.money ?? 0) < cost) { objectApi.toast("NOT ENOUGH $", { duration: 1.2 }); return; } const newMax = (s.hpMax ?? 100) + STEP; const newHp = (s.hp ?? 100) + STEP; objectApi.patchState({ money: (s.money ?? 0) - cost, hullMaxLevel: lvl + 1, hpMax: newMax, hp: newHp, }); objectApi.toast(`HULL +${STEP} HP · -${cost}`, { duration: 1.2 }); return; } // House max HP — mirrors hull but on the safehouse entity's state. if (input.actions.upgradeHouseMax) { const s = objectApi.getState(); if (!s.garageOpen) return; const lvl = s.houseMaxLevel ?? 0; const MAX = 5; const STEP = 100; if (lvl >= MAX) { objectApi.toast("HOUSE CAP MAXED", { duration: 1.2 }); return; } const cost = 50 * Math.pow(2, lvl); if ((s.money ?? 0) < cost) { objectApi.toast("NOT ENOUGH $", { duration: 1.2 }); return; } const houses = objectApi.query({ tags: ["garage"], radius: 1e9 }); if (houses.length === 0) { objectApi.toast("NO HOUSE FOUND", { duration: 1.2 }); return; } const h = houses[0]; const hs = objectApi.getObjectState(h.id) || {}; const curMax = hs.hpMax ?? 500; const curHp = typeof hs.hp === "number" ? hs.hp : curMax; objectApi.patchObjectState(h.id, { hpMax: curMax + STEP, hp: curHp + STEP }); objectApi.patchState({ money: (s.money ?? 0) - cost, houseMaxLevel: lvl + 1, }); objectApi.toast(`HOUSE +${STEP} HP · -${cost}`, { duration: 1.2 }); return; } // Turret — auto-fire perimeter defense. Each level adds one turret at // the next free slot around the safehouse (entrance kept clear). if (input.actions.upgradeTurret) { const s = objectApi.getState(); if (!s.garageOpen) return; const lvl = s.turretLevel ?? 0; const MAX = 6; if (lvl >= MAX) { objectApi.toast("TURRETS MAXED", { duration: 1.2 }); return; } const cost = 50 * Math.pow(2, lvl); if ((s.money ?? 0) < cost) { objectApi.toast("NOT ENOUGH $", { duration: 1.2 }); return; } // Safehouse at (0, 30), opening faces +Z. 6 slots ring the back/sides; // none in front so the bay entrance stays clear. // slot 0: back-left (-4, 20) // slot 1: back-right ( 4, 20) // slot 2: side-left (-7, 23) // slot 3: side-right ( 7, 23) // slot 4: side-left-f (-7, 29) ← still off the bay entry line at x=0 // slot 5: side-right-f( 7, 29) const SLOTS = [ { x: -4, z: 20 }, { x: 4, z: 20 }, { x: -7, z: 23 }, { x: 7, z: 23 }, { x: -7, z: 29 }, { x: 7, z: 29 }, ]; const slot = SLOTS[lvl]; const turretId = `turret-${lvl}`; objectApi.spawn({ id: turretId, tags: ["turret"], properties: { physics: "static", feetPosition: { x: slot.x, z: slot.z, y: { terrain: 0 } }, rotation: { yaw: 0 }, // Sandbag pedestal + barrel — built from primitive children so it // reads as defensive emplacement, not a flagpole. children: [ { id: "base", properties: { feetPosition: { x: 0, y: 0, z: 0 }, primitive: { kind: "cylinder", radius: 0.55, height: 0.6, radialSegments: 12 }, material: { texture: "/cdn/moodboard-zomburger/texture-sandbag-burlap-canvas-albedo.png", color: "oklch(0.55 0.06 75)", roughness: 0.95, }, }, }, { id: "mount", properties: { feetPosition: { x: 0, y: 0.6, z: 0 }, primitive: { kind: "cylinder", radius: 0.18, height: 0.5, radialSegments: 10 }, material: { color: "oklch(0.32 0.02 60)", metalness: 0.6, roughness: 0.45 }, }, }, { id: "head", properties: { feetPosition: { x: 0, y: 1.1, z: 0 }, primitive: { kind: "box", width: 0.5, height: 0.35, depth: 0.6 }, material: { color: "oklch(0.28 0.02 60)", metalness: 0.7, roughness: 0.4 }, }, }, { id: "barrel", properties: { feetPosition: { x: 0, y: 1.45, z: -0.5 }, rotation: { pitch: 90 }, primitive: { kind: "cylinder", radius: 0.08, height: 0.9, radialSegments: 8 }, material: { color: "oklch(0.20 0.02 60)", metalness: 0.8, roughness: 0.35 }, }, }, { id: "light", properties: { feetPosition: { x: 0, y: 1.3, z: 0 }, light: { kind: "point", color: "oklch(0.85 0.20 60)", intensity: 1.4, distance: 6, decay: 1.8 }, }, }, ], }, }); objectApi.addBehavior(turretId, "scripts/turret.js"); objectApi.patchState({ money: (s.money ?? 0) - cost, turretLevel: lvl + 1, }); objectApi.toast(`TURRET ${lvl + 1}/6 DEPLOYED · -${cost}`, { duration: 1.5 }); return; } // Drifter shop — close button. Pure UI state. if (input.actions.drifterClose) { const s = objectApi.getState(); if (s.drifterShop) objectApi.patchState({ drifterShop: null }); return; } // Drifter shop — buy one of the three rolled offers. After purchase the // merchant packs up and leaves immediately (his beacon, rig, and body // are destroyed, drifterShop is cleared, world-clock won't re-spawn him // until tomorrow because lastDrifterDay is already today). if (input.actions.drifterBuy && input.actionData && input.actionData.drifterBuy) { const s = objectApi.getState(); const shop = s.drifterShop; if (!shop) return; const kind = input.actionData.drifterBuy.kind; if (!kind || !(shop.offers || []).includes(kind)) return; // Compute current level + cost from the same tables the garage uses. // (Mirror of scripts/ui.js so the numbers match what the player sees.) const CT_MAX = 10, RC_MAX = 10, HL_MAX = 10, BT_MAX = 9, TP_MAX = 10; const HMX_MAX = 5, HSX_MAX = 5; const ctLvl = s.cookTimeLevel ?? 0; const rcLvl = s.recipeLevel ?? 0; const hlLvl = s.hullLevel ?? 0; const btLvl = s.butcherLevel ?? 0; const tpLvl = s.tipLevel ?? 0; const hmLvl = s.hullMaxLevel ?? 0; const hsLvl = s.houseMaxLevel ?? 0; const blLvl = s.bladeLevel ?? 0; const sfLvl = s.speedForceLevel ?? 0; const SF_MAX = 3; let cost = 0; let maxed = false; const patch = {}; switch (kind) { case "blade": { if (blLvl >= 1) { maxed = true; break; } cost = 300; patch.bladeLevel = 1; break; } case "speedForce": { if (sfLvl >= SF_MAX) { maxed = true; break; } cost = 75 * Math.pow(2, sfLvl); // 75, 150, 300 patch.speedForceLevel = sfLvl + 1; break; } case "cookTime": { if (ctLvl >= CT_MAX) { maxed = true; break; } cost = 5 * Math.pow(2, ctLvl); patch.cookTimeLevel = ctLvl + 1; break; } case "recipe": { if (rcLvl >= RC_MAX) { maxed = true; break; } cost = 5 * Math.pow(2, rcLvl); patch.recipeLevel = rcLvl + 1; break; } case "hull": { if (hlLvl >= HL_MAX) { maxed = true; break; } cost = 5 * Math.pow(2, hlLvl); patch.hullLevel = hlLvl + 1; break; } case "butcher": { if (btLvl >= BT_MAX) { maxed = true; break; } cost = 5 * Math.pow(2, btLvl); patch.butcherLevel = btLvl + 1; break; } case "tip": { if (tpLvl >= TP_MAX) { maxed = true; break; } cost = 5 * Math.pow(2, tpLvl); patch.tipLevel = tpLvl + 1; break; } case "hullMax": { if (hmLvl >= HMX_MAX) { maxed = true; break; } cost = 5 * Math.pow(2, hmLvl); patch.hullMaxLevel = hmLvl + 1; // Bump current hpMax + carry the heal-up so the upgrade feels real. patch.hpMax = (s.hpMax ?? 100) + 25; patch.hp = Math.min(patch.hpMax, (s.hp ?? 100) + 25); break; } case "houseMax": { if (hsLvl >= HSX_MAX) { maxed = true; break; } cost = 50 * Math.pow(2, hsLvl); patch.houseMaxLevel = hsLvl + 1; // Find the safehouse and bump its hpMax + heal up too. const houses = objectApi.query({ tags: ["garage"], radius: 1e9 }); if (houses[0]) { const hs = houses[0].state || {}; const newMax = (hs.hpMax ?? 500) + 100; const newHp = Math.min(newMax, (hs.hp ?? newMax) + 100); objectApi.patchObjectState(houses[0].id, { hpMax: newMax, hp: newHp }); } break; } default: return; } if (maxed) { objectApi.toast("ALREADY MAXED", { duration: 1.5 }); return; } if ((s.money ?? 0) < cost) { objectApi.toast(`NEED ${cost}`, { duration: 1.5 }); return; } // Charge, apply the upgrade, close the shop. objectApi.patchState({ money: (s.money ?? 0) - cost, ...patch, drifterShop: null, nearMerchant: null, }); objectApi.toast(`✓ PURCHASED · -${cost}`, { duration: 2.0 }); // Cash-register sting. try { objectApi.playSound({ clip: "/cdn/moodboard-zomburger/sfx-merchant-cash-register.mp3", gain: 0.8, }); } catch (e) {} // The Drifter packs up and leaves immediately — destroy his body, rig, // beacon, and beam. world-clock's `lastDrifterDay === day` guard keeps // him from re-spawning until tomorrow. const mid = shop.merchantId; if (mid) { try { objectApi.destroy(mid + "-beacon"); } catch (e) {} try { objectApi.destroy(mid + "-beam"); } catch (e) {} try { objectApi.destroy(mid + "-rig"); } catch (e) {} try { objectApi.destroy(mid); } catch (e) {} } return; } // Delivery — Q (or card "VIEW") opens the popup with a specific call so the // player gets a description AND a chance to decline. UI reads // pendingCallPopup off car state. // - With { callId }: open popup for THAT call (used by card click). // - Bare (no actionData): open popup for the oldest queued call (Q key). // - If a popup is already open and bare Q fires again: close it. if (input.actions.acceptCall) { const explicitId = input.actionData?.acceptCall?.callId; const s = objectApi.getState() || {}; if (explicitId) { objectApi.patchState({ pendingCallPopup: explicitId }); return; } if (s.pendingCallPopup) { objectApi.patchState({ pendingCallPopup: null }); return; } const wcs = objectApi.query({ tags: ["world-clock"], radius: 1e9 })[0]; const calls = wcs?.state?.calls || []; if (calls.length > 0) { objectApi.patchState({ pendingCallPopup: calls[0].id }); } return; } // Delivery — confirm an accept from inside the popup. if (input.actions.confirmCall) { const callId = input.actionData?.confirmCall?.callId; if (callId) objectApi.patchState({ deliveryAcceptReq: callId, pendingCallPopup: null }); return; } // Delivery — decline an incoming call (popup or anywhere). if (input.actions.declineCall) { const callId = input.actionData?.declineCall?.callId; if (callId) objectApi.patchState({ deliveryDeclineReq: callId, pendingCallPopup: null }); return; } // Tab switch — pure UI state, no cost. if (input.actions.garageTab) { const s = objectApi.getState(); if (!s.garageOpen) return; const tab = input.actionData?.garageTab?.tab || "maintenance"; // Culinary is no longer a safehouse tab — drifter merchant owns those // upgrades now. Only maintenance and defense are valid. if (tab === "maintenance" || tab === "defense") { objectApi.patchState({ garageTab: tab }); } return; } if (input.actions.interact) { const s = objectApi.getState(); if (s.gameOver) return; const carPos = objectApi.getProperty("feetPosition"); if (!carPos) return; // DELIVERY DROP — highest priority for E. If there's an active mission // and the player is near ANY glowing door, the press fires a drop request // that delivery-manager.js processes next tick. The manager handles range // and "no burgers" feedback. { const wcs = objectApi.getObjectState("world-clock") || {}; const active = wcs.activeDelivery; if (active) { const dx = carPos.x - active.xEnt; const dz = carPos.z - active.zEnt; const dist = Math.hypot(dx, dz); if (dist <= 10) { objectApi.patchState({ deliveryDropReq: (s.deliveryDropReq || 0) + 1 }); return; } } } // If garage panel is already open, E closes it. if (s.garageOpen) { objectApi.patchState({ garageOpen: false }); return; } // If the Drifter shop is already open, E closes it (same vibe as the // garage close — the player isn't trapped in a menu). if (s.drifterShop) { objectApi.patchState({ drifterShop: null }); return; } // CUSTOMER SALE — drive-up burger handoff. Priority above garage/drifter // so the player can pull up alongside a hungry car and sell with one tap. // Pick the closest unfed customer in range; no lobbing, no aim, no whiff. { const SELL_RADIUS = 7; const customers = objectApi.query({ tags: ["customer"], center: carPos, radius: SELL_RADIUS, }); let best = null, bestD = Infinity; for (const c of customers) { if (c.state && (c.state.fed || c.state.gone)) continue; const dx = c.feetPosition.x - carPos.x; const dz = c.feetPosition.z - carPos.z; const d = Math.hypot(dx, dz); if (d < bestD) { bestD = d; best = c; } } if (best) { const burgers = s.burgers ?? 0; if (burgers <= 0) { objectApi.toast("NO BURGERS", { duration: 1.2 }); return; } // Tip roll mirrors burger-projectile.js so the upgrade still reads. const tipLvl = Math.max(0, Math.min(10, s.tipLevel ?? 0)); const tipChance = 0.05 * tipLvl; const tipped = objectApi.random() < tipChance; // Burger sells for $20 base / $40 tipped. Mirror of burger-projectile.js. const earned = tipped ? 40 : 20; const newMoney = (s.money ?? 0) + earned; objectApi.patchState({ burgers: burgers - 1, money: newMoney }); // +3 popularity per drive-up sale — mirrors burger-projectile.js so // both sale paths feed the same rep economy. Without this, players // who hand off via E never gain pop and never unlock delivery calls. const POP_PER_ROAD_SALE = 5; const _wcs = objectApi.query({ tags: ["world-clock"], radius: 1e9 })[0]; if (_wcs) { const _wsCur = _wcs.state || {}; objectApi.patchObjectState(_wcs.id, { popularity: (_wsCur.popularity || 0) + POP_PER_ROAD_SALE }); const _bp = best.feetPosition; objectApi.damageNumber( { x: _bp.x, y: _bp.y + 3.0, z: _bp.z }, POP_PER_ROAD_SALE, { text: "⭐ +" + POP_PER_ROAD_SALE, color: "oklch(0.88 0.20 60)", scale: 1.4, audience: { kind: "place" } } ); } objectApi.patchObjectState(best.id, { fed: true, gone: true }); // World-space money pop at the sale point. const cp = best.feetPosition; objectApi.damageNumber( { x: cp.x, y: cp.y + 2.4, z: cp.z }, earned, { text: tipped ? `💰 +${earned} TIP!` : `+${earned}`, color: tipped ? "oklch(0.90 0.20 145)" : "oklch(0.92 0.18 95)", scale: tipped ? 1.6 : 1.3, audience: { kind: "place" }, } ); objectApi.particleBurst( { x: cp.x, y: cp.y + 1.6, z: cp.z }, tipped ? "magic" : "stars", { scale: 0.7, color: tipped ? "oklch(0.85 0.20 145)" : "oklch(0.85 0.18 95)", audience: { kind: "place" }, } ); // Light ka-ching feedback so the sale lands in the ear too. objectApi.playSound( "/cdn/moodboard-zomburger/sfx-cash-register.mp3", { position: carPos, volume: 0.7, pitch: tipped ? 1.15 : 1.0 } ); return; } } // If parked near The Drifter, route E to him before the garage. His // beacon is unmistakable so the player knows what they're doing. { const drifters = objectApi.query({ tags: ["drifter-merchant"], center: carPos, radius: 9, }); if (drifters.length > 0) { objectApi.interact(drifters[0].id); return; } } // Try to enter the garage. const garages = objectApi.query({ tags: ["garage"], center: carPos, radius: 8 }); if (garages.length > 0) { objectApi.patchState({ garageOpen: true }); return; } return; } if (input.actions.unflip) { tryUnflip(objectApi); return; } // --- Tutorial controls (UI-only — buttons inside the intro modal). --- // tutorialDone latches once the player dismisses; ui.js stops rendering // the modal at that point. Page index defaults to 1. if (input.actions.tutorialNext || input.actions.tutorialPrev || input.actions.tutorialClose) { const ts = objectApi.getState(); if (input.actions.tutorialClose) { objectApi.patchState({ tutorialDone: true, tutorialPage: 1 }); } else if (input.actions.tutorialNext) { const nextPage = Math.min(2, (ts.tutorialPage ?? 1) + 1); objectApi.patchState({ tutorialPage: nextPage }); } else if (input.actions.tutorialPrev) { const prevPage = Math.max(1, (ts.tutorialPage ?? 1) - 1); objectApi.patchState({ tutorialPage: prevPage }); } return; } // --- Radio controls (UI-only — sent by clicking the HUD music player) --- // Swap the bg-music entity's audio.clip on prev/next; toggle audio on/off // on play. We don't seek mid-clip (the engine doesn't expose a playhead), // so a track restart always starts from the top. The progress bar in the // UI just reads musicTrackStartT vs. now for a visual estimate. if (input.actions.musicPrev || input.actions.musicNext || input.actions.musicPlay) { const s = objectApi.getState(); const count = PLAYLIST.length; if (count === 0) return; let idx = ((s.musicTrack ?? 0) | 0) % count; let playing = s.musicPlaying ?? true; const nowT = s.now ?? 0; if (input.actions.musicPrev) { idx = (idx - 1 + count) % count; playing = true; } else if (input.actions.musicNext) { idx = (idx + 1) % count; playing = true; } else if (input.actions.musicPlay) { playing = !playing; } const track = PLAYLIST[idx]; // Pause truly stops the song. The engine has no audio seek for object // audio, so play restarts the current track from the top — but the // important thing is that pause cuts the audio, not just lowers volume. if (playing) { // loop:false so update() can auto-advance to the next track when this // one ends. The engine would otherwise hide track-end from us. objectApi.setObjectProperty("bg-music", "audio", { kind: "clip", clip: track.clip, loop: false, spatial: false, gain: 1.0, }); } else { objectApi.setObjectProperty("bg-music", "audio", null); } objectApi.patchState({ musicTrack: idx, musicPlaying: playing, musicTrackStartT: nowT, }); return; } // Debug: press 1 to instantly receive 5 burgers. Survival cheat. if (input.actions.debugBurgers) { const s = objectApi.getState(); const burgers = (s.burgers ?? 0) + 5; objectApi.patchState({ burgers }); objectApi.toast("🍔 DEBUG +5 BURGERS", { duration: 1.2 }); return; } // Debug: press 2 to instantly receive 10 meat. Skips the zombie-grind step. if (input.actions.debugMeat) { const s = objectApi.getState(); const meat = (s.meat ?? 0) + 10; objectApi.patchState({ meat }); objectApi.toast("🥩 DEBUG +10 MEAT", { duration: 1.2 }); return; } // Cook button — kicks off a roof-top cookout that locks movement. if (input.actions.startCook) { const s = objectApi.getState(); if (s.gameOver) return; if (s.cooking) return; if (s.garageOpen) return; const recipe = recipeFor(s.recipeLevel ?? 0); const cookTime = cookTimeFor(s.cookTimeLevel ?? 0); if ((s.meat ?? 0) < recipe) { objectApi.toast("INSUFFICIENT MEAT (" + recipe + ")", { duration: 1.2 }); return; } // Flat 3-second cook — locks wheels, advances no matter what. // No movement gate: cooking while rolling parks the truck for 3s. startCookSession(objectApi, 3); return; } // Block driving inputs while the cook lock is on. if (objectApi.getState().cooking) { objectApi.patchState({ gas: 0, steer: 0, brake: 1 }); return; } objectApi.patchState({ gas: input.axes.moveZ ?? 0, steer: input.axes.moveX ?? 0, brake: input.actions.jump ? 1 : 0, }); } // --- Rooftop cookout ------------------------------------------------------- // While cooking: car frozen, grill on roof, driver visible standing on the // car holding (next to) the grill. State drives all of it; update() finishes // the cook on the timer and tears the scene back down. function startCookSession(objectApi, cookTime) { const s = objectApi.getState(); const now = s.now ?? 0; const P = objectApi.id; // Hard stop the chassis. for (let i = 0; i < 4; i++) { objectApi.setWheelEngineForce(i, 0); objectApi.setWheelBrake(i, BRAKE_FORCE); objectApi.setWheelSteering(i, 0); } // Grill on the roof — base + grate + glow. objectApi.spawn("cook-grill-base", { parent: P, properties: { feetPosition: { x: -0.4, y: 1.05, z: 0 }, primitive: { kind: "box", width: 0.55, height: 0.06, depth: 0.55 }, material: { color: "oklch(0.20 0.01 30)", roughness: 0.6, metalness: 0.4 }, interpolation: { teleportThreshold: 20 }, }, }); // four little legs for (const [lx, lz, key] of [ [-0.22, -0.22, "fl"], [ 0.22, -0.22, "fr"], [-0.22, 0.22, "rl"], [ 0.22, 0.22, "rr"], ]) { objectApi.spawn("cook-grill-leg-" + key, { parent: P, properties: { feetPosition: { x: -0.4 + lx, y: 1.05 - 0.32, z: lz }, primitive: { kind: "cylinder", radius: 0.025, height: 0.32 }, material: { color: "oklch(0.18 0.01 30)", roughness: 0.7, metalness: 0.6 }, interpolation: { teleportThreshold: 20 }, }, }); } objectApi.spawn("cook-grill-grate", { parent: P, properties: { feetPosition: { x: -0.4, y: 1.13, z: 0 }, primitive: { kind: "box", width: 0.5, height: 0.02, depth: 0.5 }, material: { color: "oklch(0.30 0.01 30)", roughness: 0.4, metalness: 0.8 }, interpolation: { teleportThreshold: 20 }, }, }); // Glowing coals objectApi.spawn("cook-grill-coals", { parent: P, properties: { feetPosition: { x: -0.4, y: 1.09, z: 0 }, primitive: { kind: "box", width: 0.42, height: 0.04, depth: 0.42 }, material: { color: "oklch(0.55 0.22 35)", emissive: "oklch(0.70 0.25 40)", emissiveIntensity: 1.8, roughness: 0.9, }, interpolation: { teleportThreshold: 20 }, }, }); // The patty being grilled — small dark disk on the grate. objectApi.spawn("cook-patty", { parent: P, properties: { feetPosition: { x: -0.4, y: 1.16, z: 0 }, primitive: { kind: "cylinder", radius: 0.11, height: 0.04 }, material: { color: "oklch(0.30 0.06 50)", roughness: 0.9 }, interpolation: { teleportThreshold: 20 }, }, }); // Fire / smoke from the grill. const carPos = objectApi.getProperty("feetPosition") || { x: 0, y: 0, z: 0 }; objectApi.particleBurst( { x: carPos.x, y: carPos.y + 1.4, z: carPos.z }, "fire", { scale: 0.4, audience: { kind: "nearby", position: carPos, radius: 40 } } ); // No rooftop driver visual — the cookout is just the grill on top of the // car. Player stays hidden the whole time. // Pausable cookout: track ELAPSED cook seconds (not wall-clock end time). // The cook block in update() only advances cookElapsed when the truck is // stopped, so driving off freezes progress until the player parks again. objectApi.patchState({ cooking: true, cookElapsed: 0, cookDuration: cookTime, // Legacy fields zeroed so any stale reader doesn't accidentally see the // old wall-clock end time and force-complete. cookStartedAt: 0, cookEndAt: 0, gas: 0, steer: 0, brake: 1, currentSteering: 0, }); objectApi.toast("COOKING…", { duration: 1.2 }); } function endCookSession(objectApi, { completed }) { const s = objectApi.getState(); const P = objectApi.id; // Tear down the grill props. for (const id of [ P + "/cook-grill-base", P + "/cook-grill-grate", P + "/cook-grill-coals", P + "/cook-patty", P + "/cook-grill-leg-fl", P + "/cook-grill-leg-fr", P + "/cook-grill-leg-rl", P + "/cook-grill-leg-rr", ]) { try { objectApi.destroy(id); } catch (e) {} } // No driver visual to tuck away — player is already hidden. if (completed) { const recipe = recipeFor(s.recipeLevel ?? 0); const newMeat = Math.max(0, (s.meat ?? 0) - recipe); const newBurgers = (s.burgers ?? 0) + 1; // Release the wheels and give the player a few seconds of free movement // before auto-cook can re-trigger. Otherwise they're trapped: cook ends, // they have leftover meat, the next tick they're stopped, and auto-cook // grabs them again. Cooldown breaks the loop. for (let i = 0; i < 4; i++) { try { objectApi.setWheelEngineForce(i, 0); } catch (e) {} try { objectApi.setWheelBrake(i, 0); } catch (e) {} try { objectApi.setWheelSteering(i, 0); } catch (e) {} } const _now = (typeof s.now === "number") ? s.now : 0; objectApi.patchState({ cooking: false, meat: newMeat, burgers: newBurgers, cookCooldownUntil: _now + 4, }); const carPos = objectApi.getProperty("feetPosition"); if (carPos) { objectApi.damageNumber( { x: carPos.x, y: carPos.y + 1.6, z: carPos.z }, 1, { text: "🍔 +1", color: "oklch(0.82 0.16 70)" } ); } objectApi.toast("🍔 +1 BURGER", { duration: 1.2 }); } else { objectApi.patchState({ cooking: false }); } } // Returns world-up.y for the chassis (1 = upright, -1 = upside down). function chassisUpY(objectApi) { const rot = objectApi.getProperty("rotation"); if (rot && typeof rot === "object" && "w" in rot) { const qx = rot.x, qy = rot.y, qz = rot.z, qw = rot.w; // Rotate (0,1,0) by quaternion — take Y component of result. return 1 - 2 * (qx * qx + qz * qz); } return 1; } // Read current yaw (degrees) from the live body quaternion. function chassisYawDeg(objectApi) { const rot = objectApi.getProperty("rotation"); if (rot && typeof rot === "object" && "w" in rot) { const qx = rot.x, qy = rot.y, qz = rot.z, qw = rot.w; const fx = -2 * (qx * qz + qw * qy); const fz = -(1 - 2 * (qx * qx + qy * qy)); return Math.atan2(-fx, -fz) * 180 / Math.PI; } if (rot && typeof rot.yaw === "number") return rot.yaw; return 0; } // Pure upright operation — used by manual button + auto-recovery. function doUnflip(objectApi) { const yawDeg = chassisYawDeg(objectApi); const pos = objectApi.getProperty("feetPosition") || { x: 0, y: 1, z: 0 }; objectApi.setProperty("rotation", { yaw: yawDeg }); objectApi.setProperty("feetPosition", { x: pos.x, y: pos.y + 1.4, z: pos.z }); if (objectApi.setVelocity) objectApi.setVelocity(0, 0, 0); for (let i = 0; i < 4; i++) { objectApi.setWheelEngineForce(i, 0); objectApi.setWheelBrake(i, 0); objectApi.setWheelSteering(i, 0); } objectApi.patchState({ gas: 0, steer: 0, brake: 0, currentSteering: 0, flippedFor: 0, }); } function tryUnflip(objectApi) { const s = objectApi.getState(); const now = s.now ?? 0; const readyAt = s.flipReadyAt ?? 0; const fuel = s.fuel ?? 0; const cost = s.flipCost ?? 0.1; const cooldown = s.flipCooldown ?? 10; if (now < readyAt) { objectApi.toast("RECOVERY COOLING DOWN — " + Math.ceil(readyAt - now) + "s", { duration: 1.5 }); return; } if (fuel < cost) { objectApi.toast("NOT ENOUGH FUEL TO RECOVER", { duration: 1.5 }); return; } doUnflip(objectApi); objectApi.patchState({ fuel: Math.max(0, fuel - cost), flipReadyAt: now + cooldown, }); objectApi.toast("RECOVERED · -10% FUEL", { duration: 1.5 }); } // Auto-recovery: when the chassis is upside down for AUTO_FLIP_DELAY seconds, // snap it upright. No fuel cost, no cooldown — pure stuck-car safety net. const AUTO_FLIP_DELAY = 3; const FLIP_UP_THRESHOLD = 0.35; // world up.y < this = considered flipped function checkAutoUnflip(dt, objectApi) { const s = objectApi.getState(); const upY = chassisUpY(objectApi); const isFlipped = upY < FLIP_UP_THRESHOLD; let flippedFor = s.flippedFor ?? 0; if (isFlipped) { flippedFor += dt; if (flippedFor >= AUTO_FLIP_DELAY) { doUnflip(objectApi); objectApi.toast("AUTO-RECOVERED", { duration: 1.5 }); return; } } else if (flippedFor !== 0) { flippedFor = 0; } // Only write when changed to avoid stomping other patchState calls each tick. if (flippedFor !== (s.flippedFor ?? 0)) { objectApi.patchState({ flippedFor }); } } export function update(dt, objectApi) { // One-shot state migration. Bump SCHEMA_V to force a fresh session. // Note: patchState here doesn't show up in this tick's getState() reads, so // we ALSO mutate the live state via replaceState merged with a snapshot to // ensure the rest of this update sees the migrated values. { const SCHEMA_V = 15; const cs = objectApi.getState(); if (cs.schemaV !== SCHEMA_V) { // Hull max scales with hullMaxLevel — preserve prior upgrades across // schema bumps so a fresh session doesn't strip purchases. const HULL_MAX_STEP = 25; const hullMaxLvl = cs.hullMaxLevel ?? 0; const hpMax = 100 + HULL_MAX_STEP * hullMaxLvl; objectApi.replaceState({ ...cs, schemaV: SCHEMA_V, hp: hpMax, hpMax, gameOver: false, daysSurvived: 0, day: 1, phase: "dawn", dayFrac: 0, burgers: 3, meat: 0, money: cs.money ?? 0, stoppedFor: 0, hitCooldown: {}, garageOpen: false, safeUntil: 0, hullLevel: cs.hullLevel ?? 0, hullMaxLevel: hullMaxLvl, houseMaxLevel: cs.houseMaxLevel ?? 0, turretLevel: cs.turretLevel ?? 0, garageTab: cs.garageTab || "maintenance", // DEBUG: tutorial auto-dismissed so deliveries flow on game start. // World-clock pauses time while !tutorialDone, and delivery-manager // bails out the same way — nothing ticks until the intro modal is // closed. For testing we skip straight into the live loop. tutorialDone: true, tutorialPage: 1, }); return; } } // Tutorial pause — while the intro modal is up, the whole driving sim // holds. Zero out the wheels so a stuck key from before pause doesn't // sneak forces through, then bail. onInput still runs for the tutorial // close/next/prev buttons, so the player can dismiss the modal. // // Same treatment for the home menu — when garageOpen is true, freeze the // car so the player can shop without zombies chewing their bumper or // fuel ticking down. onInput still routes for menu buttons. { const cs = objectApi.getState(); if (!cs.tutorialDone || cs.garageOpen) { for (let i = 0; i < 4; i++) { objectApi.setWheelEngineForce(i, 0); objectApi.setWheelBrake(i, 50); objectApi.setWheelSteering(i, 0); } if (objectApi.setVelocity) objectApi.setVelocity(0, 0, 0); return; } } // Void rescue — if anything ever yeets the car below the world, snap it // back to a safe spawn point instead of falling forever. const livePos = objectApi.getProperty("feetPosition"); if (livePos && (livePos.y < -50 || livePos.y > 500)) { // Garage is home — never fall back into the zombie-haunted origin. objectApi.setProperty("feetPosition", { x: 3, z: 30, y: { terrain: 2 } }); objectApi.setProperty("rotation", { yaw: 0 }); if (objectApi.setVelocity) objectApi.setVelocity(0, 0, 0); for (let i = 0; i < 4; i++) { objectApi.setWheelEngineForce(i, 0); objectApi.setWheelBrake(i, 0); objectApi.setWheelSteering(i, 0); } objectApi.patchState({ gas: 0, steer: 0, brake: 0, currentSteering: 0, flippedFor: 0 }); objectApi.toast("VOID RESCUE", { duration: 2 }); return; } // --- DEBUG CHEAT POLLING --- // The player's onInput bumps debugMeatReq / debugBurgersReq on their own // state. We poll those counters every tick and apply the cheat to the // car here, where cross-realm writes work. Without this, pressing 2 on // foot silently dropped the request (player can't write to the car // directly — different realm). { const cs = objectApi.getState(); const players = objectApi.query({ tags: ["player"], radius: 1e9 }); const p = players && players[0]; if (p && p.state) { const meatReq = p.state.debugMeatReq ?? 0; const burgReq = p.state.debugBurgersReq ?? 0; const lastMeat = cs.lastDebugMeatReq ?? 0; const lastBurg = cs.lastDebugBurgersReq ?? 0; if (meatReq > lastMeat) { const meat = (cs.meat ?? 0) + 10 * (meatReq - lastMeat); objectApi.patchState({ meat, lastDebugMeatReq: meatReq }); } if (burgReq > lastBurg) { const burgers = (cs.burgers ?? 0) + 5 * (burgReq - lastBurg); objectApi.patchState({ burgers, lastDebugBurgersReq: burgReq }); } } } // Auto-recovery first — if the car was flipped long enough this tick, it // teleports upright and we let the rest of the update run on the new pose. checkAutoUnflip(dt, objectApi); const s = objectApi.getState(); const now = (s.now ?? 0) + dt; // Radio auto-advance — when the current track has been playing for its // duration, roll to the next song (wrapping back to track 0 at the end). // No engine hook for "audio finished" on object audio, so we time it from // musicTrackStartT vs. now. loop:false on the audio prevents the engine // from looping under us. Durations come from scripts/lib/playlist.js. if (s.musicPlaying && PLAYLIST.length > 0) { const idx = ((s.musicTrack ?? 0) | 0) % PLAYLIST.length; const startT = s.musicTrackStartT ?? now; const dur = (PLAYLIST[idx] && PLAYLIST[idx].duration) || 180; if (now - startT >= dur) { const nextIdx = (idx + 1) % PLAYLIST.length; const nextTrack = PLAYLIST[nextIdx]; objectApi.setObjectProperty("bg-music", "audio", { kind: "clip", clip: nextTrack.clip, loop: false, spatial: false, gain: 1.0, }); objectApi.patchState({ musicTrack: nextIdx, musicTrackStartT: now, }); } } const fuel = s.fuel ?? 1.0; const dry = fuel <= 0; const gas = dry ? 0 : (s.gas ?? 0); const handbrake = (s.brake ?? 0) > 0; const signedSpeed = objectApi.getVehicleSpeed(); // --- Throttle belch: V8 exhaust pop when you slam the gas from low speed. // Fires on the leading edge of a throttle slam, throttled so it doesn't // chain-fire if you tap-tap-tap. Skip if dry — no fuel, no boom. { const prevGasMag = Math.abs(s.lastGasMag ?? 0); const gasMag = Math.abs(gas); const slammed = prevGasMag < 0.15 && gasMag > 0.55; const lastBelch = s.lastBelchAt ?? -999; if (slammed && !dry && (now - lastBelch) > 1.6 && Math.abs(signedSpeed) < 8) { const carPosForBelch = objectApi.getProperty("feetPosition"); objectApi.playSound( "/cdn/moodboard-zomburger/sfx-exhaust-belch.mp3", { position: carPosForBelch, volume: 0.7, pitch: 0.85 + objectApi.random() * 0.15, } ); // Black smoke puff out the tailpipe — sits behind the chassis, low. if (carPosForBelch) { const yaw = (objectApi.getProperty("rotation") || {}).yaw || 0; const back = 1.6; objectApi.particleBurst( { x: carPosForBelch.x - Math.sin(yaw) * back, y: carPosForBelch.y + 0.45, z: carPosForBelch.z - Math.cos(yaw) * back, }, "smoke", { scale: 0.7, color: "oklch(0.32 0.02 30)", audience: { kind: "nearby", position: carPosForBelch, radius: 40 }, } ); } objectApi.patchState({ lastBelchAt: now }); } // Remember this tick's throttle for next-tick edge detection. Stored // separately so it doesn't fight with the main gas write further down. if (gasMag !== prevGasMag) { objectApi.patchState({ lastGasMag: gasMag }); } } const speed = Math.abs(signedSpeed); // --- SPEED FORCE VISUALS --- // While the Speed Force upgrade is active and the truck is actually moving, // rake electric trails off the chassis flanks. Intensity scales with level // (1→soft cyan flicker, 2→thicker streaks, 3→full electric corona). { const sfLvl = Math.max(0, Math.min(3, (s.speedForceLevel ?? 0) | 0)); if (sfLvl > 0 && speed >= 1.5) { const now = s.now ?? 0; const interval = 0.10 - sfLvl * 0.02; // 0.08 / 0.06 / 0.04s — denser at higher levels const lastSfx = s.lastSpeedForceFxAt ?? -999; if (now - lastSfx >= interval) { const carPosSf = objectApi.getProperty("feetPosition"); const yawSf = ((objectApi.getProperty("rotation") || {}).yaw) || 0; if (carPosSf) { // Flank offsets — perpendicular to truck heading. const side = 1.8 + sfLvl * 0.25; const right = { x: Math.cos(yawSf), z: -Math.sin(yawSf) }; const back = { x: -Math.sin(yawSf), z: -Math.cos(yawSf) }; // Color brightens with level. Electric cyan → white-hot. const sfColor = sfLvl === 1 ? "oklch(0.85 0.18 220)" : sfLvl === 2 ? "oklch(0.92 0.20 210)" : "oklch(0.97 0.18 200)"; const scale = 0.5 + sfLvl * 0.18; const nearby = { kind: "nearby", position: carPosSf, radius: 50 }; // Left flank streak. objectApi.particleBurst( { x: carPosSf.x - right.x * side + back.x * 0.5, y: carPosSf.y + 0.9, z: carPosSf.z - right.z * side + back.z * 0.5, }, "electric", { scale, color: sfColor, audience: nearby } ); // Right flank streak. objectApi.particleBurst( { x: carPosSf.x + right.x * side + back.x * 0.5, y: carPosSf.y + 0.9, z: carPosSf.z + right.z * side + back.z * 0.5, }, "electric", { scale, color: sfColor, audience: nearby } ); // At max level, a third burst right behind the cab — full corona. if (sfLvl >= 3) { objectApi.particleBurst( { x: carPosSf.x + back.x * 2.2, y: carPosSf.y + 1.3, z: carPosSf.z + back.z * 2.2, }, "spark", { scale: 0.7, color: sfColor, audience: nearby } ); } objectApi.patchState({ lastSpeedForceFxAt: now }); } } } } // --- GAME OVER FREEZE --- // Read live clock state so freeze tracks the source of truth, not stale s. let clockGameOver = false, clockDay = s.day ?? 1, clockPhase = s.phase ?? "dawn", clockDayFrac = 0, clockDaysSurvived = 0; let clockResetEpoch = s.resetEpoch ?? 0; { const clocks = objectApi.query({ tags: ["world-clock"], radius: 1e9 }); if (clocks.length > 0) { const cs = clocks[0].state || {}; clockGameOver = !!cs.gameOver; clockDay = cs.day ?? clockDay; clockPhase = cs.phase ?? clockPhase; if (typeof cs.t === "number") { clockDayFrac = cs.t / (cs.dayLength || 180); } clockDaysSurvived = cs.daysSurvived ?? 0; clockResetEpoch = cs.resetEpoch ?? 0; } } // --- reset detection: world-clock bumped resetEpoch since we last saw it --- // Triple-gate: // 1) STRICTLY GREATER — if the clock ever ticks DOWN (state wipe, schema // bump on the clock side), we don't fire a phantom reset; we just sync. // 2) Time cooldown — even a real reqId bump can't fire the reset block // twice within 1.5s, so any duplicate trigger from a state race becomes // a silent no-op. // 3) Reset-while-busy gate handled below by the replaceState's // lastResetEpoch write — once we run, lastResetEpoch jumps to match. const lastEpoch = s.lastResetEpoch ?? 0; const sinceLastReset = (s.now ?? 0) - (s.lastResetFiredAt ?? -999); if (clockResetEpoch < lastEpoch) { // Clock state was wiped beneath us — silently re-sync without a respawn. objectApi.patchState({ lastResetEpoch: clockResetEpoch }); } if (clockResetEpoch > lastEpoch && sinceLastReset > 1.5) { // Park at the garage — that's home base, safe zone, the only place // a fresh respawn should land. The old (0,0) spawn was buried in zombies. objectApi.setProperty("feetPosition", { x: 3, z: 30, y: { terrain: 0.8 } }); objectApi.setProperty("rotation", { yaw: 0 }); if (objectApi.setLinearVelocity) objectApi.setLinearVelocity({ x: 0, y: 0, z: 0 }); if (objectApi.setAngularVelocity) objectApi.setAngularVelocity({ x: 0, y: 0, z: 0 }); // Restore the truck's primitive children — they were hidden by the // explosion FX. Without this, R reloads at the safehouse with an // invisible truck. const SHOW = ["cab","cargo","windshield","headlight-L","headlight-R", "taillight-L","taillight-R","roof-strip","sign-light", "wheel-0","wheel-1","wheel-2","wheel-3", "rim-0","rim-1","rim-2","rim-3"]; for (const k of SHOW) { try { objectApi.setObjectProperty(P + "/" + k, "visible", true); } catch (e) {} } // Wipe any wreck debris still in the air. const wreckage = objectApi.query({ tags: ["wreck"], radius: 1e9 }); for (const w of wreckage) { try { objectApi.destroy(w.id); } catch (e) {} } // R-restart sweep: wipe every zombie, every meat pickup, reset every // upgrade. Fresh world, fresh car, zero history. const allZombies = objectApi.query({ tags: ["zombie"], radius: 1e9 }); for (const z of allZombies) { objectApi.destroy(z.id); } const allMeat = objectApi.query({ tags: ["meat"], radius: 1e9 }); for (const m of allMeat) { objectApi.destroy(m.id); // Sibling MEAT label spawned alongside the chunk in zombie.js. try { objectApi.destroy(m.id + "-label"); } catch (e) {} } objectApi.replaceState({ ...s, hp: 100, hpMax: 100, gameOver: false, exploding: false, explodingAt: 0, daysSurvived: 0, meat: 0, burgers: 3, money: 10, stoppedFor: 0, hitCooldown: {}, garageOpen: false, fuel: 1.0, // upgrade reset — back to stock car. cookTimeLevel: 0, recipeLevel: 0, hullLevel: 0, // Drifter purchases reset too — fresh world, no blades, no butchery, // no tip jar, no hull-cap perk, no speed force, no house buffs. bladeLevel: 0, bladeCutAt: {}, butcherLevel: 0, tipLevel: 0, hullMaxLevel: 0, houseMaxLevel: 0, speedForceLevel: 0, nearMerchant: null, drifterShop: null, // DEBUG: keep tutorial dismissed across restarts so R-press doesn't // re-freeze the world. Restore to `false` when shipping. tutorialDone: true, tutorialPage: 1, lastResetEpoch: clockResetEpoch, lastResetFiredAt: now, safeUntil: now + 4, }); objectApi.toast("DAY 1 — STOCK CAR · FRESH WORLD", { duration: 2 }); return; // skip the rest of this tick; next tick runs on fresh state } // Pending-restart gate: player.onInput bumps resetRequestId one tick before // the world-clock notices. During that single-tick window, don't re-apply // gameOver — the YOU DIED overlay would flicker back on between click and // respawn. clockResetEpoch mirrors world-clock.lastResetReqId, so if our // resetRequestId is ahead, a restart is in flight. const restartPending = (s.resetRequestId ?? 0) > clockResetEpoch; if (clockGameOver && !restartPending) { for (let i = 0; i < 4; i++) { objectApi.setWheelEngineForce(i, 0); objectApi.setWheelBrake(i, 60); objectApi.setWheelSteering(i, 0); } objectApi.patchState({ gas: 0, steer: 0, brake: 0, currentSteering: 0, gameOver: true, daysSurvived: clockDaysSurvived, day: clockDay, phase: clockPhase, dayFrac: clockDayFrac, }); return; } // --- HP DAMAGE: bites when parked + collision damage scaled by impact speed --- let hp = s.hp ?? 100; const driven = !!s.controlActive; const carPos = objectApi.getProperty("feetPosition"); // Hull armor — applies to every damage source below. const hullReduction = hullReductionFor(s.hullLevel ?? 0); const dmgMult = 1 - hullReduction; // a) Zombie bite damage MOVED to scripts/zombie.js — each zombie now // telegraphs (windup → strike) and writes hp via patchObjectState. // Track whether car-side code modifies hp this tick — if not, we must // NOT write hp back at the end of update, or we'd stomp zombie writes // that arrived between our snapshot and our final patchState. let hpDirty = false; // b) impact damage on hitting a zombie. Two rules: // - Rolling over them at speed = no car damage. The horde-manager turns // them into meat on contact above SPLATTER_KMH; the car just plows // through. Charge the horde and you don't pay HP for it. // - Bogged down ramming (< splatter speed) = up to 3 HP per tick TOTAL, // regardless of how many bodies are in the shell. A pile of zombies // used to deal 2 HP × bodyCount in one tick, which made any actual // ramming brutal. Capped to 3 so getting briefly stuck on a corpse // costs the same as one bite, not ten. const SPLATTER_KMH = 80; // matches horde-manager.SPLATTER_KMH const RAM_TICK_CAP = 3; // hard ceiling on per-tick collision damage const hitCooldown = s.hitCooldown ? { ...s.hitCooldown } : {}; const nowT = now; if (carPos) { const speedKmh = speed * 3.6; // Tiny rolling threshold so a parked car doesn't tick this every frame — // that overlap belongs to the gnaw block (a). Above 1 km/h we're rolling. // Above SPLATTER_KMH, skip the whole block: you're rolling over them. if (speedKmh > 1 && speedKmh < SPLATTER_KMH) { // Broadphase: covers the full chassis diagonal (≈5.6m). The strict // oriented-box test below culls anything outside the actual footprint. const slammable = objectApi.query({ tags: ["zombie"], center: carPos, radius: 6.0, }); // Oriented chassis shell — matches CAR_SHELL constants in zombie.js // so both sides agree on "is this zombie under the truck?" // Sized to the visible truck (3.8 × 8.0), zero buffer: a zombie has // to actually be under the chassis to count as run over. const CAR_HALF_X = 1.9; const CAR_HALF_Z = 4.0; const HIT_BUFFER = 0.5; const carYawRad = (s.heading ?? 0); // already radians const cYaw = Math.cos(carYawRad); const sYaw = Math.sin(carYawRad); // Track impact mass — every fresh zombie in the slam ring this tick // adds to the deceleration. One wet body = small bump. Three at once = // a wall of meat that stops you. let hitsThisTick = 0; // Count zombies CURRENTLY overlapping the shell — used by the sub-20km/h // wall test below. Needs to be a count, not a boolean: one body is a // bump (you drive over it), only a pile reads as a real wall. let bodiesInShell = 0; // Ram damage budget — drains as bodies hit, stops at zero. Whole pile // shares 3 HP per tick instead of each charging 2 HP separately. let ramBudget = Math.max(1, Math.round(RAM_TICK_CAP * dmgMult)); for (const z of slammable) { const ph = (z.state && z.state.phase) || "wander"; // Only zombies that are still "in the way" damage the hull. if (ph === "consumed" || ph === "meat" || ph === "down") continue; // Strict footprint test — world offset → car-local → axis-aligned // box compare. Zombies outside the actual chassis area get skipped. const relX = z.feetPosition.x - carPos.x; const relZ = z.feetPosition.z - carPos.z; const localX = cYaw * relX + sYaw * relZ; const localZ = -sYaw * relX + cYaw * relZ; if (Math.abs(localX) > CAR_HALF_X + HIT_BUFFER) continue; if (Math.abs(localZ) > CAR_HALF_Z + HIT_BUFFER) continue; bodiesInShell += 1; const lastHit = hitCooldown[z.id] || 0; if (nowT - lastHit < 0.9) continue; if (ramBudget <= 0) { // Budget spent — still register the hit cooldown so this body // doesn't re-trigger next tick, just no HP cost. hitCooldown[z.id] = nowT; continue; } const dmg = Math.min(ramBudget, Math.max(1, Math.round(2 * dmgMult))); ramBudget -= dmg; hp = Math.max(0, hp - dmg); hpDirty = true; hitCooldown[z.id] = nowT; objectApi.damageNumber( { x: carPos.x, y: carPos.y + 1.2, z: carPos.z }, dmg, { text: "-" + dmg, color: "oklch(0.78 0.14 60)" } ); // Wet, fleshy thud. Pitch drops with hit speed — slow grazes click // higher, full-speed slams thump lower. Per-zombie position so a // pack reads as multiple bodies, not one over-loud blast. const speedT = Math.min(1, speedKmh / 60); const pitch = 1.15 - speedT * 0.45; // 1.15 (graze) → 0.70 (slam) const vol = 0.55 + speedT * 0.35; // 0.55 → 0.90 objectApi.playSound( "/cdn/moodboard-zomburger/sfx-zombie-thud.mp3", { position: z.feetPosition, volume: vol, pitch: pitch * (0.92 + objectApi.random() * 0.16), // ±8% wobble } ); objectApi.screenShake(0.04 + speedT * 0.06, 0.08 + speedT * 0.06); hitsThisTick += 1; } // --- IMPACT DECELERATION ---------------------------------------- // Each body in the slam this tick eats a chunk of forward momentum. // Above 20 km/h: scale per hit ~0.78; two ~0.61; three ~0.47. Floor 0.3. // Below 20 km/h: HARD STOP. A wall of zombies is a wall — the truck // doesn't have the speed to plow through, so it dead-stops on contact. // Plays with the new HIT_MIN_CAR_SPEED gate in zombie.js (no knock/flip // below 20 km/h either), so low-speed contact reads as "stuck on meat" // instead of "phase through bodies." if (objectApi.getVelocity && objectApi.setVelocity) { const v = objectApi.getVelocity(); if (v) { // Wall of meat — only fires when 3+ bodies are stacked under the // chassis at low speed, and only once per 0.6s so it can't pin the // truck by re-applying drag every tick. One or two bodies = drive // through; the per-hit decel below handles the bump. const lastWall = s.lastWallStopAt ?? 0; if (bodiesInShell >= 3 && speedKmh < 20 && nowT - lastWall > 0.6) { objectApi.setVelocity(v.x * 0.5, v.y, v.z * 0.5); objectApi.patchState({ lastWallStopAt: nowT }); } else if (hitsThisTick > 0) { // Per-hit deceleration HALVED. Old: keep 78% per body (lose 22%). // New: keep 89% per body (lose 11%). Floor lifted from 30% kept // to 65% kept so even a multi-body slam barely slows the truck. const scale = Math.max(0.65, Math.pow(0.89, hitsThisTick)); // Y left untouched — don't yank the car into the ground or pop it // off its suspension when it rolls through a body. objectApi.setVelocity(v.x * scale, v.y, v.z * scale); } } } } // Prune stale cooldown entries so the dict doesn't grow forever. for (const k in hitCooldown) { if (nowT - hitCooldown[k] > 4) delete hitCooldown[k]; } // --- c2) SIDE BLADE SLASH ------------------------------------------- // The Drifter's upgrade. Above 40 km/h, anything that brushes the // FLANKS of the car gets cut clean in half. Forward hits still go // through the slam ring above (damage to hull, normal squash drops). // Sideways hits skip the hull cost entirely and drop 2 meat chunks. if ((s.bladeLevel ?? 0) >= 1 && speedKmh >= 40) { const heading = s.heading ?? 0; // yaw in radians, 0 = -Z forward const fwdX = -Math.sin(heading); const fwdZ = -Math.cos(heading); const bladeCutAt = s.bladeCutAt ? { ...s.bladeCutAt } : {}; const cuts = objectApi.query({ tags: ["zombie"], center: carPos, radius: 3.4, // slightly wider than the slam ring so blades reach }); let cutThisTick = 0; for (const z of cuts) { const ph = (z.state && z.state.phase) || "wander"; if (ph === "consumed" || ph === "meat" || ph === "down") continue; const last = bladeCutAt[z.id] || 0; if (nowT - last < 1.2) continue; const dx = z.feetPosition.x - carPos.x; const dz = z.feetPosition.z - carPos.z; const len = Math.hypot(dx, dz) || 1; // Forward-alignment: 1 = directly ahead, 0 = directly to the side. const fwdDot = Math.abs((dx / len) * fwdX + (dz / len) * fwdZ); if (fwdDot > 0.55) continue; // too "in front" — slam ring handles it // SLICE. Spawn blood, slash VFX, 2 meat chunks, kill zombie. bladeCutAt[z.id] = nowT; cutThisTick += 1; bladeSlice(objectApi, z, heading); } if (cutThisTick > 0) { objectApi.patchState({ bladeCutAt }); } else if (s.bladeCutAt) { // Prune stale entries so the dict doesn't grow forever. let pruned = false; const next = {}; for (const k in s.bladeCutAt) { if (nowT - s.bladeCutAt[k] < 4) next[k] = s.bladeCutAt[k]; else pruned = true; } if (pruned) objectApi.patchState({ bladeCutAt: next }); } } // --- c3) BLADE VISUAL RECONCILE ------------------------------------- // Two long curved blades, one on each flank. Spawn them once when the // player first owns the upgrade; reconciled here so a fresh world or // a god-mode unlock both work without a special-case onSpawn path. if ((s.bladeLevel ?? 0) >= 1 && !s.bladesMounted) { mountSideBlades(objectApi); objectApi.patchState({ bladesMounted: true }); } else if ((s.bladeLevel ?? 0) <= 0 && s.bladesMounted) { unmountSideBlades(objectApi); objectApi.patchState({ bladesMounted: false }); } } // d) Wall crunch — detect a sharp deceleration that wasn't a zombie hit. // Compare realized speed (position delta) tick-to-tick. If the car // suddenly drops by a big chunk in a single tick AND no zombie damage // fired this tick, we crunched into a wall. Damage scales with the // speed we lost in the impact. let zombieDmgThisTick = false; for (const k in hitCooldown) { if (hitCooldown[k] === nowT) { zombieDmgThisTick = true; break; } } let realizedSpeed = 0; if (carPos && typeof s.carX === "number" && typeof s.carZ === "number" && dt > 0) { const dx = carPos.x - s.carX; const dz = carPos.z - s.carZ; realizedSpeed = Math.hypot(dx, dz) / dt; } const prevRealized = s.realizedSpeed ?? realizedSpeed; const lastWallHitAt = s.lastWallHitAt ?? -999; // Track how long the car has wanted to move but isn't actually moving. // Crunch only fires after it's been stuck for a sustained window — otherwise // the first frame of pressing gas (before physics responds) reads as stuck // and falsely crunches a parked car. const wantsToMove = Math.abs(s.gas ?? 0) > 0.1; const notMoving = prevRealized < 0.6 && realizedSpeed < 0.6; let stuckTime = s.stuckTime ?? 0; if (wantsToMove && notMoving) { stuckTime += dt; } else { stuckTime = 0; } // Only crunch when there's actually SOMETHING in front of us — otherwise // sitting on a hill or fighting physics jitter racked up bogus damage. let blockerAhead = false; if (carPos && wantsToMove && stuckTime > 0.3) { const headingNow = s.heading ?? 0; const fwd = Math.sign(s.gas ?? 0); const probeX = carPos.x + Math.sin(headingNow) * fwd * 1.8; const probeZ = carPos.z + Math.cos(headingNow) * fwd * 1.8; const ahead = objectApi.query({ center: { x: probeX, y: carPos.y, z: probeZ }, radius: 2.2, anyTags: ["zombie", "wreck", "garage", "obstacle"], }); blockerAhead = ahead.length > 0; } if (carPos && !zombieDmgThisTick && (nowT - lastWallHitAt) > 1.0) { // Two ways to crunch: // 1) sudden deceleration — were rolling, lost > 2 m/s in one tick // 2) stuck-against — engine has been shoving for over a second AND // there's a real blocker in front. (Just spinning wheels in open // ground used to crunch the car for no reason.) const drop = prevRealized - realizedSpeed; const hardStop = prevRealized > 2 && drop > 2; const stuckShove = stuckTime > 1.2 && blockerAhead; if (hardStop || stuckShove) { const dmg = Math.max(1, Math.round(5 * dmgMult)); hp = Math.max(0, hp - dmg); hpDirty = true; objectApi.damageNumber( { x: carPos.x, y: carPos.y + 1.4, z: carPos.z }, dmg, { text: "CRUNCH -" + dmg, color: "oklch(0.75 0.22 50)" } ); objectApi.particleBurst( { x: carPos.x, y: carPos.y + 0.3, z: carPos.z }, "explosion", { scale: 0.4, color: "oklch(0.8 0.18 60)", audience: { kind: "nearby", position: carPos, radius: 30 } } ); objectApi.screenShake(0.12, 0.2); // Dry metal-on-concrete crunch — distinct timbre from the wet thud // so the player can tell at a glance whether they just hit meat // or a wall they shouldn't have hit. objectApi.playSound( "/cdn/moodboard-zomburger/sfx-wall-crunch.mp3", { position: carPos, volume: 0.9, pitch: 0.95 + objectApi.random() * 0.1 } ); objectApi.patchState({ lastWallHitAt: nowT }); // SAFEHOUSE COLLISION — if the wall the truck just kissed belongs to // the home, the home eats damage too. Box matches garage-build.js // (W=10, D=8, feet at front opening, building extends -Z). Small // proximity skirt so a glancing scrape still registers. { const houses = objectApi.query({ tags: ["garage"], radius: 1e9 }); const h = houses[0]; if (h) { const f = h.feetPosition; const xMin = f.x - 5, xMax = f.x + 5; const zMin = f.z - 8, zMax = f.z; const SKIRT = 2.5; const dxh = Math.max(xMin - SKIRT - carPos.x, 0, carPos.x - (xMax + SKIRT)); const dzh = Math.max(zMin - SKIRT - carPos.z, 0, carPos.z - (zMax + SKIRT)); const wallDist = Math.hypot(dxh, dzh); if (wallDist < 0.5) { // Impact severity scales house damage. A nudge clips 3 hp, // a full slam takes more — but capped so the truck can't // demolish the safehouse in one crash. const slamT = Math.min(1, prevRealized / 18); // 18 m/s ≈ 65 km/h = full slam const houseDmg = Math.max(3, Math.round(3 + 12 * slamT)); const hs = h.state || {}; const hpNow = typeof hs.hp === "number" ? hs.hp : 500; const newHp = Math.max(0, hpNow - houseDmg); objectApi.patchObjectState(h.id, { hp: newHp, lastDamageAt: nowT, }); objectApi.damageNumber( { x: carPos.x + (objectApi.random() * 2 - 1), y: carPos.y + 2.2, z: carPos.z + (objectApi.random() * 2 - 1) }, houseDmg, { text: "HOUSE -" + houseDmg, color: "oklch(0.65 0.22 25)", audience: { kind: "place" } } ); // Debris puff at the wall, not the car — sells the impact site. const wallX = Math.max(xMin, Math.min(xMax, carPos.x)); const wallZ = Math.max(zMin, Math.min(zMax, carPos.z)); objectApi.particleBurst( { x: wallX, y: carPos.y + 0.6, z: wallZ }, "dust", { scale: 0.6, audience: { kind: "nearby", position: carPos, radius: 40 } } ); } } } } } // --- INSTANT DEATH: hp hit zero. Flip game over here on the same tick // instead of waiting for the world-clock to poll us. Also bake the // hp into state so the dashboard reads 0/100 and the YOU DIED screen // fires immediately. The clock will catch up on its next poll. // Merge in any zombie hp writes that arrived mid-tick before we decide. if (!hpDirty) { const liveHp = objectApi.getState().hp; if (typeof liveHp === "number") hp = liveHp; } // Skip instant-death if R was JUST pressed — there's a 2–3 tick window // between onInput bumping resetRequestId and the reset block actually // applying hp=100. Without this gate, hp=0 fires another gameOver in that // window and the modal pops back up forever. // Time-based gate (not counter-based): counters can drift after multiple // resets, but lastResetAt is always real wall-clock-ish "now" on R press. const resetJustPressed = (now - (s.lastResetAt ?? -999)) < 3.0; if (hp <= 0 && !s.gameOver && !s.exploding && !resetJustPressed) { // Truck just died. Hold YOU DIED back for a beat — boom, debris, shake, // THEN modal. Death gets a moment to land. for (let i = 0; i < 4; i++) { objectApi.setWheelEngineForce(i, 0); objectApi.setWheelBrake(i, 60); objectApi.setWheelSteering(i, 0); } explodeCar(objectApi, objectApi.id, now); // Tell the world-clock the cause NOW. world-clock backs off when the // car is exploding (so we own the gameOver flip), which means it never // writes deathCause itself. Without this, the YOU DIED modal renders // headless — no "CAR GO KABOOM" tagline, just confusion. { const _wc = objectApi.query({ tags: ["world-clock"], radius: 1e9 })[0]; if (_wc) objectApi.patchObjectState(_wc.id, { deathCause: "zombie" }); } objectApi.patchState({ hp: 0, gas: 0, steer: 0, brake: 0, currentSteering: 0, exploding: true, explodingAt: now, daysSurvived: (s.day ?? 1) - 1 + (s.dayFrac ?? 0), hitCooldown, }); return; } // Hold during the explosion. After 1.6s the modal pops. if (s.exploding && !s.gameOver) { if (now - (s.explodingAt ?? now) > 1.6) { // Mirror gameOver to the world-clock alongside our local flip. The // clock backed off earlier (carExploding gate); now that the cinematic // is done, push the authoritative flag through so player.js mirror + // UI both agree on dead, with a cause set. const _wc = objectApi.query({ tags: ["world-clock"], radius: 1e9 })[0]; if (_wc) { const _wcs = _wc.state || {}; objectApi.patchObjectState(_wc.id, { gameOver: true, deathCause: _wcs.deathCause || "zombie", daysSurvived: (s.day ?? 1) - 1 + (s.dayFrac ?? 0), }); } objectApi.patchState({ gameOver: true }); } return; } // c0) Rooftop cookout — pausable. Auto-starts when stopped with meat // (see auto-start block below). After starting, the player CAN drive // away: motion just freezes progress instead of canceling. Park again // and the patty keeps cooking from where it left off. if (s.cooking) { // Cook ALWAYS advances. Doesn't matter if the truck is moving, stopped, // being eaten, falling off a cliff — once you press cook, that patty // finishes in 3 seconds. let elapsed = s.cookElapsed ?? 0; const duration = s.cookDuration ?? 3; // Lock the wheels so the truck holds still while the grill is on the // roof; the input-block above already zeroes inputs. for (let i = 0; i < 4; i++) { objectApi.setWheelEngineForce(i, 0); objectApi.setWheelBrake(i, BRAKE_FORCE); objectApi.setWheelSteering(i, 0); } elapsed = Math.min(duration, elapsed + dt); if (elapsed >= duration) { endCookSession(objectApi, { completed: true }); return; } objectApi.patchState({ now, cookElapsed: elapsed, heading: s.heading || 0 }); return; } // c0.5) Auto-cook REMOVED. The cook button (startCook in onInput) is now // the only way to start a cookout — stopping with meat on hand no longer // hijacks the player. The cook button still requires the truck to be at // a standstill (movingKmh > 1 → "STOP TO COOK" toast). // c) Cook loop — burgers only get made AT HOME (garage panel open). The // player has to drive back to base to turn raw meat into food. // cookTime and recipe both shrink with home upgrades. let stoppedFor = s.stoppedFor ?? 0; let burgers = s.burgers ?? 0; let meat = s.meat ?? 0; const cookTime = cookTimeFor(s.cookTimeLevel ?? 0); const recipe = recipeFor(s.recipeLevel ?? 0); const cookingAtHome = !!s.garageOpen; if (driven && cookingAtHome && meat >= recipe) { stoppedFor += dt; // Press as many burgers as the timer + larder allow this tick. while (stoppedFor >= cookTime && meat >= recipe) { stoppedFor -= cookTime; meat -= recipe; burgers += 1; if (carPos) { objectApi.damageNumber( { x: carPos.x, y: carPos.y + 1.6, z: carPos.z }, 1, { text: "🍔 +1", color: "oklch(0.82 0.16 70)" } ); } } // If we ran out of meat mid-cook, drop the partial-progress timer too. if (meat < recipe) stoppedFor = 0; } else { stoppedFor = 0; } const drifting = handbrake && speed > DRIFT_MIN_SPEED; const fullBrake = handbrake && !drifting; const coasting = Math.abs(gas) < 0.05 && !handbrake; // Fuel drain — only while actually applying throttle. Full tank ~ 3 minutes // of constant gas; idle burns nothing. let nextFuel = fuel; if (Math.abs(gas) > 0.05 && fuel > 0) { nextFuel = Math.max(0, fuel - dt * 0.0055); } // Engine force on rear wheels (forward is -Z, so negate). // Full handbrake locks out throttle — W + Space must NOT crawl forward. // Drift handbrake still keeps gas (that's the whole point of a drift). const force = fullBrake ? 0 : (-gas * DRIVE_FORCE); objectApi.setWheelEngineForce(2, force); objectApi.setWheelEngineForce(3, force); // Brakes + drift handbrake if (drifting) { objectApi.setWheelBrake(0, 0); objectApi.setWheelBrake(1, 0); objectApi.setWheelBrake(2, DRIFT_BRAKE); objectApi.setWheelBrake(3, DRIFT_BRAKE); } else if (fullBrake) { for (let i = 0; i < 4; i++) objectApi.setWheelBrake(i, BRAKE_FORCE); } else if (coasting) { for (let i = 0; i < 4; i++) objectApi.setWheelBrake(i, ENGINE_BRAKE); } else { for (let i = 0; i < 4; i++) objectApi.setWheelBrake(i, 0); } // Rear wheel friction — only write on change (constant writes cause jitter) const rearFriction = drifting ? DRIFT_FRICTION : 9; if (s.rearFriction !== rearFriction) { objectApi.setWheelFrictionSlip(2, rearFriction); objectApi.setWheelFrictionSlip(3, rearFriction); objectApi.patchState({ rearFriction }); } // Speed-dependent steering — gentler at top speed kills the high-speed wobble const t = Math.exp(-STEER_SPEED_FACTOR * speed); // Handbrake-drift bonus — sharper rack + snappier response so the car // actually carves corners while sliding. Plus a light forward drag to bleed // top speed (the handbrake is supposed to slow you down a little). const driftSteerMul = drifting ? 1.6 : 1; const driftSteerLerp = drifting ? 0.35 : STEER_LERP; const maxSteer = (STEER_MIN + (STEER_MAX - STEER_MIN) * t) * driftSteerMul; const targetSteering = -maxSteer * (s.steer ?? 0); const newSteering = (s.currentSteering ?? 0) + (targetSteering - (s.currentSteering ?? 0)) * driftSteerLerp; objectApi.setWheelSteering(0, newSteering); objectApi.setWheelSteering(1, newSteering); // Publish heading (radians) — read directly from live body rotation quaternion. const rot = objectApi.getProperty("rotation"); let heading = s.heading || 0; if (rot && typeof rot === "object" && "w" in rot) { const qx = rot.x, qy = rot.y, qz = rot.z, qw = rot.w; // Forward = q * (0,0,-1); heading = atan2(forward.x, -forward.z) const fx = -2 * (qx * qz + qw * qy); const fz = -(1 - 2 * (qx * qx + qy * qy)); heading = Math.atan2(-fx, -fz); } // Continuous skid marks while drifting — connect last wheel pos to current with a stretched strip let skidIdx = s.skidIdx || 0; let lastSkidLX = s.lastSkidLX, lastSkidLZ = s.lastSkidLZ; let lastSkidRX = s.lastSkidRX, lastSkidRZ = s.lastSkidRZ; if (drifting) { const carPos = objectApi.getProperty("feetPosition"); if (carPos) { const cosH = Math.cos(heading); const sinH = Math.sin(heading); // Rear wheel world positions const lx = carPos.x - sinH * RZ + cosH * (-HW); const lz = carPos.z - cosH * RZ - sinH * (-HW); const rx = carPos.x - sinH * RZ + cosH * ( HW); const rz = carPos.z - cosH * RZ - sinH * ( HW); const stamp = (x0, z0, x1, z1) => { const dx = x1 - x0, dz = z1 - z0; const len = Math.hypot(dx, dz); if (len < SKID_MIN_SEG || len > 5) return; // skip tiny/teleport segments const cx = (x0 + x1) * 0.5; const cz = (z0 + z1) * 0.5; const segYaw = Math.atan2(-dx, -dz) * 180 / Math.PI; const id = "skid-" + (skidIdx % SKID_MAX); skidIdx++; if (objectApi.destroy) objectApi.destroy(id); objectApi.spawn(id, { properties: { feetPosition: { x: cx, y: 0.005, z: cz }, rotation: { yaw: segYaw }, primitive: { kind: "box", width: 0.22, height: 0.01, depth: len + 0.05 }, material: { color: "oklch(0.15 0.01 0)", roughness: 1, opacity: 0.85, transparent: true }, physics: null, }, }); return true; }; // Only stamp when the wheel has moved enough to make a worthwhile new // segment — keeps the skid budget honest at high frame rates. if (typeof lastSkidLX === "number") { const moved = Math.hypot(lx - lastSkidLX, lz - lastSkidLZ); if (moved >= SKID_MIN_SEG) { stamp(lastSkidLX, lastSkidLZ, lx, lz); lastSkidLX = lx; lastSkidLZ = lz; } } else { lastSkidLX = lx; lastSkidLZ = lz; } if (typeof lastSkidRX === "number") { const moved = Math.hypot(rx - lastSkidRX, rz - lastSkidRZ); if (moved >= SKID_MIN_SEG) { stamp(lastSkidRX, lastSkidRZ, rx, rz); lastSkidRX = rx; lastSkidRZ = rz; } } else { lastSkidRX = rx; lastSkidRZ = rz; } } } else { // Reset last-points so the next drift doesn't draw a line from where we stopped lastSkidLX = undefined; lastSkidLZ = undefined; lastSkidRX = undefined; lastSkidRZ = undefined; } // Auto-close garage panel if we drive away. let garageOpen = s.garageOpen; let atHome = false; if (carPos) { const garages = objectApi.query({ tags: ["garage"], center: carPos, radius: 10 }); atHome = garages.length > 0 && speed < 4; if (garageOpen && !atHome) garageOpen = false; } // Passive hull repair while parked at the safehouse — the player gets a // slow trickle of HP back just from being home, separate from the paid // FIX HULL button. ~5 HP/sec, so a fresh ride patches up in ~20 seconds // of resting. Doesn't tick while driven or away. if (atHome && hp < (s.hpMax ?? 100)) { const HEAL_RATE = 5; // hp per second const next = Math.min(s.hpMax ?? 100, hp + HEAL_RATE * dt); if (next > hp) { hp = next; hpDirty = true; // Throttled VFX so the passive trickle reads as a thing. Every ~1.0s // pop a small green particle burst + a "+N" number above the truck. // Skip when fully topped — no flicker once at max. const lastPHA = s.lastPassiveHealAt ?? 0; if (now - lastPHA > 1.0 && next < (s.hpMax ?? 100) + 0.001) { objectApi.patchState({ lastPassiveHealAt: now }); const _cp = objectApi.getProperty("feetPosition"); if (_cp) { objectApi.particleBurst( { x: _cp.x, y: _cp.y + 1.6, z: _cp.z }, "heal", { scale: 0.5, audience: { kind: "place" } } ); } } } } // --- Aim trajectory preview --- // While the player is aiming, project the burger's predicted arc as a row // of glowing dots so the lob is legible BEFORE they throw. Math here mirrors // scripts/burger-projectile.js exactly — same gravity, same muzzle offset, // same initial speed — so what you see is what you throw. { const TRAJ_DOTS = 16; const TRAJ_DT = 0.07; const TRAJ_G = 12; // must match GRAVITY in burger-projectile.js const TRAJ_SPEED = 16; // must match `const speed = ...` in the throw block const dotPrefix = `${objectApi.id}-aim-dot-`; // Lazy-spawn the dot pool. Flag lives in car state so a world reset // (which destroys all spawns) triggers a fresh pool next time we aim. const haveDots = !!s.aimDotsReady && objectApi.query({ tags: ["aim-dot"], radius: 1e9 }).length >= TRAJ_DOTS; if (s.aiming && !haveDots) { for (let i = 0; i < TRAJ_DOTS; i++) { objectApi.spawn({ id: dotPrefix + i, tags: ["aim-dot"], properties: { feetPosition: { x: 0, y: -1000, z: 0 }, // Lead dot a touch bigger, tail dots smaller — reads as a fading // trail pointing where the burger will go. primitive: { kind: "sphere", radius: 0.07 + 0.005 * (TRAJ_DOTS - i) }, material: { color: "oklch(0.90 0.18 80)", emissive: "oklch(0.90 0.20 80)", emissiveIntensity: 1.4, }, visible: false, }, }); } objectApi.patchState({ aimDotsReady: true }); } if (s.aiming && carPos) { const aimYaw = s.aimYaw ?? (s.heading ?? 0); const aimPitch = s.aimPitch ?? 0; const cpA = Math.cos(aimPitch); const spA = Math.sin(aimPitch); const fx = -Math.sin(aimYaw) * cpA; const fy = spA; const fz = -Math.cos(aimYaw) * cpA; const mX = carPos.x + fx * 1.4; const mY = carPos.y + 1.7 + fy * 0.6; const mZ = carPos.z + fz * 1.4; const vx = fx * TRAJ_SPEED; const vy = fy * TRAJ_SPEED; const vz = fz * TRAJ_SPEED; let landed = false; for (let i = 0; i < TRAJ_DOTS; i++) { const t = (i + 1) * TRAJ_DT; const dy = mY + vy * t - 0.5 * TRAJ_G * t * t; if (landed || dy <= 0.1) { objectApi.setObjectProperty(dotPrefix + i, "visible", false); landed = true; continue; } const dx = mX + vx * t; const dz = mZ + vz * t; objectApi.setObjectProperty(dotPrefix + i, "feetPosition", { x: dx, y: dy, z: dz }); objectApi.setObjectProperty(dotPrefix + i, "visible", true); } } else if (s.aimDotsReady) { // Hide on aim release. Cheap to spam — engine ignores no-op visible flips. for (let i = 0; i < TRAJ_DOTS; i++) { objectApi.setObjectProperty(dotPrefix + i, "visible", false); } } } // World-clock state was read at top of update (clockGameOver etc.) // IMPORTANT: only include `hp` in the patch when car-side code modified it. // Otherwise we'd stomp hp patches written by zombies between our snapshot // and this final patch (causing damage to vanish when parked). const periodicPatch = { currentSteering: newSteering, speed: Math.round(speed * 3.6), heading, carX: carPos ? carPos.x : 0, carZ: carPos ? carPos.z : 0, fuel: nextFuel, meat, burgers, money: s.money ?? 0, stoppedFor, hitCooldown, garageOpen, day: clockDay, phase: clockPhase, dayFrac: clockDayFrac, // STICKY gameOver — once it goes true, only the explicit reset paths // (R-restart in onInput, schema-bump in update) write it back to false. // Without this, the clock's view of gameOver could lag the car's gnaw-hit // by one tick and stomp the flag false → YOU DIED modal would flicker. // EXCEPTION: if R was JUST pressed, a reset handshake is in flight — // trust the car-local gameOver=false so the modal drops on R immediately // instead of waiting for the clock ack. Time-based, see resetJustPressed // above for why counters can't be trusted here. gameOver: resetJustPressed ? false : !!(s.gameOver || clockGameOver), daysSurvived: clockDaysSurvived, now, skidIdx, lastSkidLX, lastSkidLZ, lastSkidRX, lastSkidRZ, realizedSpeed, stuckTime, }; if (hpDirty) periodicPatch.hp = hp; objectApi.patchState(periodicPatch); // Anti-flip clamp — re-write the chassis rotation every frame to yaw only. // Pitch and roll never accumulate, so the car physically cannot tip over // no matter how hard you corner. Arcade feel, on purpose. const headingDeg = heading * 180 / Math.PI; objectApi.setProperty("rotation", { yaw: headingDeg, pitch: 0, roll: 0 }); // Visual wheel sync — suspension Y + spin + steering. // Mod the spin to ±360 so the rotation channel never accumulates huge // values that confuse client interpolation at speed. for (let i = 0; i < 4; i++) { const ws = objectApi.getWheelState(i); if (!ws) continue; const w = WHEELS[i].position; const visualX = w.x > 0 ? w.x + 0.15 : w.x + 0.15; const suspY = SUSP_REST - (ws.suspensionLength ?? SUSP_REST); const steerDeg = i < 2 ? (ws.steering ?? 0) * 180 / Math.PI : 0; let spinDeg = (ws.rotation ?? 0) * 180 / Math.PI; spinDeg = ((spinDeg % 360) + 360) % 360; objectApi.setObjectProperty("wheel-" + i, "rotation", { yaw: steerDeg, pitch: spinDeg, roll: 90 }); objectApi.setObjectProperty("wheel-" + i, "feetPosition", { x: visualX, y: w.y - WHEEL_R + suspY, z: w.z }); objectApi.setObjectProperty("rim-" + i, "rotation", { yaw: steerDeg, pitch: spinDeg, roll: 90 }); objectApi.setObjectProperty("rim-" + i, "feetPosition", { x: visualX + (w.x < 0 ? -0.07 : 0.07), y: w.y - WHEEL_R + suspY, z: w.z, }); } } // ── SIDE BLADES (The Drifter's upgrade) ───────────────────────────────── // Spawn two long curved blade primitives, one on each flank of the chassis, // parented so they ride with the truck. The blade is a tall thin wedge: // short height, long along Z (the car's forward axis), bright steel material // with an emissive edge so it reads even at speed. function mountSideBlades(objectApi) { const P = objectApi.id; const STEEL_BODY = { color: "oklch(0.72 0.02 220)", metalness: 0.85, roughness: 0.25, }; const STEEL_EDGE = { color: "oklch(0.92 0.02 230)", metalness: 0.9, roughness: 0.15, emissive: "oklch(0.85 0.06 230)", emissiveIntensity: 1.6, }; // Two blades, mirrored across X. y=0.35 = mid-chassis, between wheels. // Long along Z, thin along X, slim height — classic side-saw silhouette. for (const side of [-1, 1]) { const id = "blade-" + (side < 0 ? "left" : "right"); objectApi.spawn(id, { parent: P, properties: { feetPosition: { x: side * 1.05, y: 0.18, z: 0 }, // Wide-base wedge — points outward, fang side away from the car. // pitch -90 puts the flat of the wedge sideways with the point // outward and the long axis running Z (forward to back). rotation: { yaw: side < 0 ? 180 : 0, pitch: 0, roll: 0 }, primitive: { kind: "wedge", width: 0.35, height: 0.32, depth: 3.4, }, material: STEEL_BODY, physics: null, }, }); // Glowing edge strip — thin emissive plate along the slicing tip so the // blade catches light from a distance. objectApi.spawn(id + "-edge", { parent: P, properties: { feetPosition: { x: side * 1.32, y: 0.30, z: 0 }, rotation: { yaw: 0, pitch: 0, roll: 0 }, primitive: { kind: "box", width: 0.04, height: 0.08, depth: 3.5, }, material: STEEL_EDGE, physics: null, }, }); } objectApi.toast("🗡 BLADES READY — 40 KM/H TO SLICE", { duration: 2.5 }); } function unmountSideBlades(objectApi) { for (const side of ["left", "right"]) { try { objectApi.destroy("blade-" + side); } catch (e) {} try { objectApi.destroy("blade-" + side + "-edge"); } catch (e) {} } } // Cleanly slice a zombie in half. Spawns a horizontal slash VFX at zombie // torso height, a sticky blood pool, two meat chunks (the spec — half the // normal three-chunk drop, since the zombie was halved not pulped), and // destroys the zombie outright. function bladeSlice(objectApi, zombieView, heading) { const pos = zombieView.feetPosition; // Horizontal slash arc at torso height — wide steel arc, cold blue-white. // pitch:0 = arc lies flat with normal up; yaw matches the car's heading // so the swing reads as the blade passing through left-to-right. const yawDeg = heading * 180 / Math.PI; objectApi.slash( { x: pos.x, y: pos.y + 1.1, z: pos.z }, { shape: "crescent", edgeBody: "fadedBodyMedium", timing: "quick", edgeColor: 0xeaf2ff, bodyColor1: 0xbcd6ff, bodyColor2: 0x88a8d8, bodyColor3: 0x3a4868, rotation: { pitch: 0, yaw: yawDeg, roll: objectApi.random() < 0.5 ? 0 : 180 }, scale: 3.2, } ); // Two meat chunks — the spec for the blade kill. Tagged the same as // zombie-dropped meat so meat.js can pick them up identically. for (let i = 0; i < 2; i++) { const side = i === 0 ? 1 : -1; const ox = (objectApi.random() - 0.5) * 1.2 + side * 0.9; const oz = (objectApi.random() - 0.5) * 1.2; const chunkId = "blade-meat-" + zombieView.id + "-" + i; objectApi.spawn(chunkId, { tags: ["meat", "pickup"], properties: { feetPosition: { x: pos.x + ox, z: pos.z + oz, y: { terrain: 0 } }, primitive: { kind: "sphere", radius: 0.35 }, material: { color: "oklch(0.45 0.24 25)", roughness: 0.7 }, }, }); objectApi.addBehavior(chunkId, "scripts/meat.js"); objectApi.spawn(chunkId + "-label", { properties: { feetPosition: { x: pos.x + ox, z: pos.z + oz, y: { terrain: 2.2 } }, physics: null, text: { content: "MEAT", size: 0.6, color: 0xff5533, outlineColor: 0x110000, outlineWidth: 0.18, billboard: "full", align: "center", anchor: [0.5, 0.5], }, }, }); } // Sticky pool + a quick wet shred sound. Same audio family as the // zombie-splat path so the impact reads cohesive. objectApi.spawn("blade-pool-" + zombieView.id, { tags: ["decor"], properties: { feetPosition: { x: pos.x, z: pos.z, y: { terrain: 0.02 } }, primitive: { kind: "cylinder", radius: 1.0, height: 0.03 }, material: { color: "oklch(0.22 0.18 25)", roughness: 0.6, transparent: true, opacity: 0.85, depthWrite: false, }, physics: null, }, }); objectApi.playSound( "/cdn/moodboard-zomburger/sfx-zombie-splat.mp3", { position: pos, volume: 0.75, pitch: 1.15 + objectApi.random() * 0.15 } ); objectApi.screenShake(0.05, 0.1); // Destroy the zombie. Its meat ownership doesn't matter here — the blade // spawns its own chunks above, so cascading destroy is safe. try { objectApi.destroy(zombieView.id); } catch (e) {} }