@adatechnology/game-fluids-three 0.4.6 → 0.4.8

package/dist/index.global.js

@@ -38,6 +38,84 @@ var GameFluidsThree = (() => {
     tinted: () => tinted
   });
 
+  // ../game-contracts/dist/index.js
+  var DEFAULT_COST_ALLOCATION_BYTES = 1024 * 1024;
+  var DEFERRED_QUEUE_ID = {
+    DESTRUCTION_EVENTS: "destruction.events",
+    BREACH_PAINT: "floorplan.breach-paint",
+    AUDIO_VOICES: "audio.voices",
+    VEHICLE_CREASE: "vehicles.crease"
+  };
+  var DEFERRED_PRIORITY = {
+    [DEFERRED_QUEUE_ID.DESTRUCTION_EVENTS]: { priority: 300, phase: "present" },
+    [DEFERRED_QUEUE_ID.BREACH_PAINT]: { priority: 250, phase: "present" },
+    [DEFERRED_QUEUE_ID.AUDIO_VOICES]: { priority: 200, phase: "idle", reserveMs: 1 },
+    [DEFERRED_QUEUE_ID.VEHICLE_CREASE]: { priority: 100, phase: "idle" }
+  };
+  var WARNED_KEY = /* @__PURE__ */ Symbol.for("@adatechnology/game-contracts.warned");
+  var warnedKeys = () => {
+    const holder = globalThis;
+    return holder[WARNED_KEY] ?? (holder[WARNED_KEY] = /* @__PURE__ */ new Set());
+  };
+  var isProduction = () => {
+    try {
+      return process.env.NODE_ENV === "production";
+    } catch {
+      return false;
+    }
+  };
+  var isQuiet = () => globalThis.__GAME_KIT_QUIET__ === true;
+  var warnOnce = (key, message) => {
+    if (isQuiet() || isProduction()) return;
+    const seen = warnedKeys();
+    if (seen.has(key)) return;
+    seen.add(key);
+    console.warn(`[game-kit] ${message}`);
+  };
+  var KIT_ORIGIN_KEY = "kitOrigin";
+  function markKitOrigin(object, origin) {
+    const node = object;
+    node.userData = node.userData ?? {};
+    node.userData[KIT_ORIGIN_KEY] = { ...origin };
+    return object;
+  }
+  var SURFACE_IDS = ["concrete", "asphalt", "wood", "tile", "dirt", "grass", "gravel", "sand", "metal", "water", "glass", "carpet"];
+  var GAIT_IDS = ["walk", "run"];
+  var LANDING_IDS = ["light", "heavy"];
+  var BODY_SOUND_IDS = [
+    "jump",
+    "cloth_rustle",
+    "body_fall",
+    "fall_damage",
+    "player_hurt",
+    "player_breath_run",
+    "player_death",
+    "bite",
+    "grab",
+    "punch_swing",
+    "punch_hit_body",
+    "punch_hit_face",
+    "punch_hit_object",
+    "kick_swing",
+    "kick_hit",
+    "kick_hit_object",
+    "shove_two_hands",
+    "knife_swing",
+    "knife_stab",
+    "knife_slash",
+    "knife_hit_object",
+    "blunt_swing",
+    "blunt_hit",
+    "blunt_hit_object",
+    "axe_swing",
+    "axe_chop",
+    "axe_hit_object"
+  ];
+  var footstepSoundId = (surface, gait) => `footstep_${surface}_${gait}`;
+  var FOOTSTEP_SOUND_IDS = SURFACE_IDS.flatMap((surface) => GAIT_IDS.map((gait) => footstepSoundId(surface, gait)));
+  var LAND_SOUND_IDS = SURFACE_IDS.flatMap((surface) => LANDING_IDS.map((landing) => `land_${surface}_${landing}`));
+  var BODY_FOLEY_IDS = [...FOOTSTEP_SOUND_IDS, ...LAND_SOUND_IDS, ...BODY_SOUND_IDS];
+
   // ../game-vfx/dist/index.js
   var __defProp2 = Object.defineProperty;
   var __defNormalProp2 = (obj, key, value) => key in obj ? __defProp2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
@@ -1325,11 +1403,231 @@ var GameFluidsThree = (() => {
       glow.outIntensity = glow.i * Math.pow(1 - age, glow.curve) * flicker;
     }
   }
+  var LEHMER_MULTIPLIER = 16807;
+  var LEHMER_MODULUS = 2147483647;
+  var HASH_MIX = 2654435761;
+  function normalizeLehmerSeed(seed) {
+    const whole = Math.floor(Math.abs(seed)) % (LEHMER_MODULUS - 1);
+    return whole === 0 ? 1 : whole;
+  }
+  function lehmer(seed) {
+    let state = normalizeLehmerSeed(seed);
+    const next = () => {
+      state = state * LEHMER_MULTIPLIER % LEHMER_MODULUS;
+      return (state - 1) / (LEHMER_MODULUS - 1);
+    };
+    return {
+      next,
+      between: (min2, max2) => min2 + (max2 - min2) * next(),
+      direction(out) {
+        const up = next() * 2 - 1;
+        const angle = next() * Math.PI * 2;
+        const ring2 = Math.sqrt(1 - up * up);
+        out.x = ring2 * Math.cos(angle);
+        out.y = up;
+        out.z = ring2 * Math.sin(angle);
+        return out;
+      },
+      get state() {
+        return state;
+      }
+    };
+  }
+  function mixEventSeed(eventSeed) {
+    let mixed = Math.imul((eventSeed | 0) ^ HASH_MIX, 2246822507);
+    mixed ^= mixed >>> 13;
+    mixed = Math.imul(mixed, 3266489909);
+    mixed ^= mixed >>> 16;
+    return (mixed >>> 0) % (LEHMER_MODULUS - 1) + 1;
+  }
+  function streamFor(eventSeed) {
+    return lehmer(mixEventSeed(eventSeed));
+  }
+  var SKIN = 5e-3;
+  var MAX_PAD = 0.45;
+  function rotation(q) {
+    const [x, y, z, w] = q ?? [0, 0, 0, 1];
+    const n = Math.hypot(x, y, z, w) || 1;
+    const qx = x / n;
+    const qy = y / n;
+    const qz = z / n;
+    const qw = w / n;
+    return new Float64Array([
+      1 - 2 * (qy * qy + qz * qz),
+      2 * (qx * qy - qz * qw),
+      2 * (qx * qz + qy * qw),
+      2 * (qx * qy + qz * qw),
+      1 - 2 * (qx * qx + qz * qz),
+      2 * (qy * qz - qx * qw),
+      2 * (qx * qz - qy * qw),
+      2 * (qy * qz + qx * qw),
+      1 - 2 * (qx * qx + qy * qy)
+    ]);
+  }
+  var Enclosures = class {
+    constructor(seed = 20973) {
+      __publicField2(this, "spaces", /* @__PURE__ */ new Map());
+      __publicField2(this, "list", []);
+      __publicField2(this, "random");
+      __publicField2(this, "out", { x: 0, y: 0, z: 0, nx: 0, ny: 0, nz: 0 });
+      __publicField2(this, "l0", new Float64Array(3));
+      __publicField2(this, "l1", new Float64Array(3));
+      __publicField2(this, "q", new Float64Array(3));
+      this.random = lehmer(seed);
+    }
+    get empty() {
+      return this.list.length === 0;
+    }
+    get size() {
+      return this.list.length;
+    }
+    /** Declares, moves or (with `null`) ends the space `id`. */
+    set(id, enclosure) {
+      if (!enclosure) {
+        if (this.spaces.delete(id)) this.list = [...this.spaces.values()];
+        return;
+      }
+      const [hx, hy, hz] = enclosure.halfSize;
+      const space = {
+        cx: enclosure.center[0],
+        cy: enclosure.center[1],
+        cz: enclosure.center[2],
+        hx: Math.abs(hx),
+        hy: Math.abs(hy),
+        hz: Math.abs(hz),
+        r: rotation(enclosure.orientation),
+        radius: Math.hypot(hx, hy, hz),
+        openings: enclosure.openings ?? [],
+        leak: Math.max(0, enclosure.leak ?? 0)
+      };
+      const old = this.spaces.get(id);
+      this.spaces.set(id, space);
+      const at3 = old ? this.list.indexOf(old) : -1;
+      if (at3 >= 0) this.list[at3] = space;
+      else this.list.push(space);
+    }
+    get(id) {
+      const s = this.spaces.get(id);
+      if (!s) return void 0;
+      return { center: [s.cx, s.cy, s.cz], halfSize: [s.hx, s.hy, s.hz], openings: s.openings, leak: s.leak };
+    }
+    ids() {
+      return [...this.spaces.keys()];
+    }
+    clear() {
+      this.spaces.clear();
+      this.list = [];
+    }
+    /** Whether a point is inside any space (on the inside of its walls). */
+    inside(x, y, z) {
+      for (const s of this.list) {
+        this.toLocal(s, x, y, z, this.l0);
+        if (Math.abs(this.l0[0]) <= s.hx && Math.abs(this.l0[1]) <= s.hy && Math.abs(this.l0[2]) <= s.hz) return true;
+      }
+      return false;
+    }
+    toLocal(s, x, y, z, out) {
+      const dx = x - s.cx;
+      const dy = y - s.cy;
+      const dz = z - s.cz;
+      const r = s.r;
+      out[0] = r[0] * dx + r[3] * dy + r[6] * dz;
+      out[1] = r[1] * dx + r[4] * dy + r[7] * dz;
+      out[2] = r[2] * dx + r[5] * dy + r[8] * dz;
+    }
+    /** Passes at `rate` per second. */
+    chance(rate, dt) {
+      return rate > 0 && this.random.next() < 1 - Math.exp(-rate * dt);
+    }
+    /** The opening the wall point `q` (local) is in lets it through now. */
+    through(s, q, dt) {
+      for (const o of s.openings) {
+        if (Math.abs(q[0] - o.center[0]) > o.halfSize[0] || Math.abs(q[1] - o.center[1]) > o.halfSize[1] || Math.abs(q[2] - o.center[2]) > o.halfSize[2]) continue;
+        if (o.rate === void 0 || this.chance(o.rate, dt)) return true;
+      }
+      return this.chance(s.leak, dt);
+    }
+    confine(x0, y0, z0, x1, y1, z1, pad, dt) {
+      const list = this.list;
+      if (list.length === 0) return false;
+      const p = Math.min(Math.max(0, pad), MAX_PAD);
+      const l0 = this.l0;
+      const l1 = this.l1;
+      const q = this.q;
+      for (const s of list) {
+        const reach = s.radius + p + 0.05;
+        const dx = x1 - s.cx;
+        const dy = y1 - s.cy;
+        const dz = z1 - s.cz;
+        if (dx * dx + dy * dy + dz * dz > reach * reach) {
+          const ex = x0 - s.cx;
+          const ey = y0 - s.cy;
+          const ez = z0 - s.cz;
+          if (ex * ex + ey * ey + ez * ez > reach * reach) continue;
+        }
+        this.toLocal(s, x0, y0, z0, l0);
+        this.toLocal(s, x1, y1, z1, l1);
+        const h = [s.hx, s.hy, s.hz];
+        const in0 = Math.abs(l0[0]) <= s.hx && Math.abs(l0[1]) <= s.hy && Math.abs(l0[2]) <= s.hz;
+        let axis2 = 0;
+        let sign = 1;
+        if (in0) {
+          if (Math.abs(l1[0]) <= s.hx && Math.abs(l1[1]) <= s.hy && Math.abs(l1[2]) <= s.hz) continue;
+          for (let a = 0; a < 3; a++) q[a] = Math.min(h[a], Math.max(-h[a], l1[a]));
+          if (this.through(s, q, dt)) continue;
+          let worst = -Infinity;
+          for (let a = 0; a < 3; a++) {
+            const over = Math.abs(l1[a]) - h[a];
+            if (over > worst) {
+              worst = over;
+              axis2 = a;
+            }
+          }
+          sign = l1[axis2] < 0 ? -1 : 1;
+          for (let a = 0; a < 3; a++) l1[a] = Math.min(h[a] - SKIN, Math.max(-(h[a] - SKIN), l1[a]));
+          sign = -sign;
+        } else {
+          const padded0 = Math.abs(l0[0]) <= s.hx + p && Math.abs(l0[1]) <= s.hy + p && Math.abs(l0[2]) <= s.hz + p;
+          const bound = padded0 ? 0 : p;
+          if (!(Math.abs(l1[0]) <= s.hx + bound && Math.abs(l1[1]) <= s.hy + bound && Math.abs(l1[2]) <= s.hz + bound)) continue;
+          for (let a = 0; a < 3; a++) q[a] = Math.min(h[a], Math.max(-h[a], l1[a]));
+          if (this.through(s, q, dt)) continue;
+          let worst = -Infinity;
+          for (let a = 0; a < 3; a++) {
+            const over = Math.abs(l0[a]) - (h[a] + bound);
+            if (over > worst) {
+              worst = over;
+              axis2 = a;
+            }
+          }
+          sign = l0[axis2] < 0 ? -1 : 1;
+          l1[axis2] = sign * (h[axis2] + bound + SKIN);
+        }
+        const r = s.r;
+        const out = this.out;
+        out.x = s.cx + r[0] * l1[0] + r[1] * l1[1] + r[2] * l1[2];
+        out.y = s.cy + r[3] * l1[0] + r[4] * l1[1] + r[5] * l1[2];
+        out.z = s.cz + r[6] * l1[0] + r[7] * l1[1] + r[8] * l1[2];
+        out.nx = r[axis2] * sign;
+        out.ny = r[3 + axis2] * sign;
+        out.nz = r[6 + axis2] * sign;
+        return true;
+      }
+      return false;
+    }
+  };
+  function slideAlong(out, vx2, vy2, vz2) {
+    const into = vx2 * out.nx + vy2 * out.ny + vz2 * out.nz;
+    if (into >= 0) return [vx2, vy2, vz2];
+    return [vx2 - into * out.nx, vy2 - into * out.ny, vz2 - into * out.nz];
+  }
   var FLOOR_FRACTION = 0.4;
   var FLOOR_BOUNCE = -0.2;
   var ARRIVAL_FRAME = 30;
   var ARRIVAL_BASE = 0.3;
   var GROWTH_CAP_SECONDS = 3.5;
+  var CARRIED_KINDS = [true, true, false, true, false];
+  var PAD_OF_SIZE = 0.35;
   function createPuffPool(capacity) {
     const placeholder = { next: () => 0, between: (min2) => min2, direction: (out) => out, state: 0 };
     return new OrderedPool(capacity, () => ({
@@ -1424,13 +1722,24 @@ var GameFluidsThree = (() => {
       if (puff3.vy < 0) puff3.vy *= FLOOR_BOUNCE;
     }
   }
-  function updatePuffs(pool, dt, wind) {
+  function updatePuffs(pool, dt, wind, confiner) {
     pool.compact(ageOrKeep2, dt);
+    const confining = confiner !== void 0 && !confiner.empty;
     for (const puff3 of pool.items) {
       const age = puff3.t / puff3.life;
       const heat = puff3.h0 > 0 ? puff3.h0 * Math.pow(Math.max(0, 1 - puff3.t / puff3.hl), 1.25) : 0;
+      const x0 = puff3.x;
+      const y0 = puff3.y;
+      const z0 = puff3.z;
       if (puff3.ring) moveOnRing(puff3, puff3.ring, wind);
       else moveFree(puff3, dt, age, heat, wind);
+      if (confining && CARRIED_KINDS[puff3.kind] && confiner.confine(x0, y0, z0, puff3.x, puff3.y, puff3.z, puff3.size * PAD_OF_SIZE, dt)) {
+        const out = confiner.out;
+        puff3.x = out.x;
+        puff3.y = out.y;
+        puff3.z = out.z;
+        [puff3.vx, puff3.vy, puff3.vz] = slideAlong(out, puff3.vx, puff3.vy, puff3.vz);
+      }
       const size = puff3.s0 + (puff3.s1 - puff3.s0) * (1 - Math.exp(-puff3.t * puff3.gk)) + puff3.sg * Math.min(puff3.t, GROWTH_CAP_SECONDS);
       puff3.size = size * Math.min(1, puff3.t * ARRIVAL_FRAME + ARRIVAL_BASE);
       puff3.age = age;
@@ -1956,10 +2265,10 @@ var GameFluidsThree = (() => {
       ])
     ]
   };
-  function localToWorld(translation, rotation, local2) {
+  function localToWorld(translation, rotation2, local2) {
     const [x, y, z] = local2;
-    const [a, c, e] = [Math.cos(rotation[0]), Math.cos(rotation[1]), Math.cos(rotation[2])];
-    const [b, d, f] = [Math.sin(rotation[0]), Math.sin(rotation[1]), Math.sin(rotation[2])];
+    const [a, c, e] = [Math.cos(rotation2[0]), Math.cos(rotation2[1]), Math.cos(rotation2[2])];
+    const [b, d, f] = [Math.sin(rotation2[0]), Math.sin(rotation2[1]), Math.sin(rotation2[2])];
     const [ae, af, be, bf] = [a * e, a * f, b * e, b * f];
     return [
       c * e * x + -c * f * y + d * z + translation[0],
@@ -2301,22 +2610,22 @@ var GameFluidsThree = (() => {
       )
     ]
   };
-  function normalized(vector) {
-    const length2 = Math.sqrt(vector[0] * vector[0] + vector[1] * vector[1] + vector[2] * vector[2]) || 1;
+  function normalized(vector2) {
+    const length2 = Math.sqrt(vector2[0] * vector2[0] + vector2[1] * vector2[1] + vector2[2] * vector2[2]) || 1;
     const inverse = 1 / length2;
-    return [vector[0] * inverse, vector[1] * inverse, vector[2] * inverse];
+    return [vector2[0] * inverse, vector2[1] * inverse, vector2[2] * inverse];
   }
-  function plus(vector, x, y, z) {
-    return [vector[0] + x, vector[1] + y, vector[2] + z];
+  function plus(vector2, x, y, z) {
+    return [vector2[0] + x, vector2[1] + y, vector2[2] + z];
   }
-  function scaledBy(vector, factor) {
-    return [vector[0] * factor, vector[1] * factor, vector[2] * factor];
+  function scaledBy(vector2, factor) {
+    return [vector2[0] * factor, vector2[1] * factor, vector2[2] * factor];
   }
-  function plusScaled(vector, direction, factor) {
-    return [vector[0] + direction[0] * factor, vector[1] + direction[1] * factor, vector[2] + direction[2] * factor];
+  function plusScaled(vector2, direction, factor) {
+    return [vector2[0] + direction[0] * factor, vector2[1] + direction[1] * factor, vector2[2] + direction[2] * factor];
   }
-  function negated(vector) {
-    return [-vector[0], -vector[1], -vector[2]];
+  function negated(vector2) {
+    return [-vector2[0], -vector2[1], -vector2[2]];
   }
   var FRAME_DUST = normalized([0, -0.3, 1]);
   var SPLINTER_DIRECTION = normalized([0, 0.3, 1]);
@@ -3619,49 +3928,32 @@ var GameFluidsThree = (() => {
     /** The leak caught fire (an incendiary or tracer round, a spark, a fire near): the page's whole sequence, the fire running along the pool to the tank and the blast. */
     aliasOf(FUEL_LEAK, "vehicle_leak_ignited", {})
   ];
+  var vector = [variable("vx"), variable("vy"), variable("vz")];
+  var range = (name) => [variable(name), variable(name)];
+  var singleParticle = (id, system) => ({
+    id,
+    pageId: `particle:${id}`,
+    team: "world",
+    budget: { particles: 1, lights: 0 },
+    loop: 1e-3,
+    timeline: [
+      spawn(system, {
+        p: [0, 0, 0],
+        v: vector,
+        life: range("life"),
+        size: range("size"),
+        grow: variable("grow"),
+        c0: variable("color"),
+        a: variable("alpha"),
+        g: variable("gravity"),
+        drag: variable("drag")
+      })
+    ]
+  });
+  var SINGLE_PARTICLE_EFFECTS = [singleParticle("particle_puff", "normal"), singleParticle("particle_glow", "add"), singleParticle("particle_streak", "streak")];
   var ALL_EFFECTS = [BLOOD_HIT, HEADSHOT, DISMEMBER, BLOATER_CLOUD, SCREAMER_SHRIEK, CORPSE_DECAY, REANIMATION, EYES_IN_FOG, MUZZLE_FLASH, IMPACT_BY_MATERIAL, PENETRATION, CASINGS_AND_MAGAZINE, MOLOTOV, GRENADE, EXPLOSIVE_BARREL, SHOPFRONT_GLASS, DOOR_STAGES, BUILDING_COLLAPSE, BLOCK_WALL, METAL_DOOR_EFFECT, IRON_RAILING, WOODEN_FENCE, HIT_POINT_BREAKAGE, PRESSURE_CYLINDERS, BUILDING_FIRE, RAIN_AND_PUDDLES, FOG_AND_ASH, SCRAPING_SPARKS, ENGINE_SMOKE, FUEL_LEAK, CAR_EXPLOSION, WINDSHIELD, HEADLIGHTS_IN_RAIN, DAMAGE_AND_BITE, INFECTION_PHASES, PANIC, BLOATER_BLINDNESS, CAMPFIRE, COUGH_AND_BREATH];
   var WORKSHOP_EFFECTS = Object.fromEntries(ALL_EFFECTS.map((effect) => [effect.id, effect]));
-  var GAME_EFFECTS = { ...WORKSHOP_EFFECTS, ...Object.fromEntries([...EVENT_EFFECTS, ...VIEWMODEL_EFFECTS, ...VEHICLE_EFFECTS].map((effect) => [effect.id, effect])) };
-  var LEHMER_MULTIPLIER = 16807;
-  var LEHMER_MODULUS = 2147483647;
-  var HASH_MIX = 2654435761;
-  function normalizeLehmerSeed(seed) {
-    const whole = Math.floor(Math.abs(seed)) % (LEHMER_MODULUS - 1);
-    return whole === 0 ? 1 : whole;
-  }
-  function lehmer(seed) {
-    let state = normalizeLehmerSeed(seed);
-    const next = () => {
-      state = state * LEHMER_MULTIPLIER % LEHMER_MODULUS;
-      return (state - 1) / (LEHMER_MODULUS - 1);
-    };
-    return {
-      next,
-      between: (min2, max2) => min2 + (max2 - min2) * next(),
-      direction(out) {
-        const up = next() * 2 - 1;
-        const angle = next() * Math.PI * 2;
-        const ring2 = Math.sqrt(1 - up * up);
-        out.x = ring2 * Math.cos(angle);
-        out.y = up;
-        out.z = ring2 * Math.sin(angle);
-        return out;
-      },
-      get state() {
-        return state;
-      }
-    };
-  }
-  function mixEventSeed(eventSeed) {
-    let mixed = Math.imul((eventSeed | 0) ^ HASH_MIX, 2246822507);
-    mixed ^= mixed >>> 13;
-    mixed = Math.imul(mixed, 3266489909);
-    mixed ^= mixed >>> 16;
-    return (mixed >>> 0) % (LEHMER_MODULUS - 1) + 1;
-  }
-  function streamFor(eventSeed) {
-    return lehmer(mixEventSeed(eventSeed));
-  }
+  var GAME_EFFECTS = { ...WORKSHOP_EFFECTS, ...Object.fromEntries([...EVENT_EFFECTS, ...VIEWMODEL_EFFECTS, ...VEHICLE_EFFECTS, ...SINGLE_PARTICLE_EFFECTS].map((effect) => [effect.id, effect])) };
   var TABLE = {
     concrete: { dust: 9078138, chip: 7236195, spark: 2 },
     metal: { dust: 0, chip: 0, spark: 18 },
@@ -4331,8 +4623,8 @@ var GameFluidsThree = (() => {
   var UP12 = [0, 1, 0];
   var ZERO = [0, 0, 0];
   var FULL_TURN_DRAWN = 6.283;
-  function scaledSizes(range2, factor) {
-    return [range2[0] * Math.sqrt(factor), range2[1] * Math.sqrt(factor)];
+  function scaledSizes(range22, factor) {
+    return [range22[0] * Math.sqrt(factor), range22[1] * Math.sqrt(factor)];
   }
   function fireEmit(engine, key, dt, centre, radius, factor, options = {}) {
     const wind = options.wind ?? ZERO;
@@ -4965,8 +5257,8 @@ var GameFluidsThree = (() => {
   function addScorch(store, random, x, z, radius) {
     const variant = Math.floor(random.next() * SCORCH_VARIANTS);
     const lift = 0.03 + nextLift(store) * 1e-3;
-    const rotation = random.next() * 6;
-    store.add({ kind: "scorch", x, z, radius, variant, lift, rotation });
+    const rotation2 = random.next() * 6;
+    store.add({ kind: "scorch", x, z, radius, variant, lift, rotation: rotation2 });
   }
   function addRimRocks(store, ground, random, x, z, radius) {
     const count = Math.round(6 + radius * 7);
@@ -4995,8 +5287,8 @@ var GameFluidsThree = (() => {
   function addCrater(store, ground, random, spec) {
     ground?.dent(random, spec.x, spec.z, spec.radius, spec.depth);
     if (!spec.marks) return;
-    const rotation = random.next() * 6;
-    store.add({ kind: "dirt", x: spec.x, z: spec.z, radius: spec.radius * 1.02, lift: 0.045, rotation });
+    const rotation2 = random.next() * 6;
+    store.add({ kind: "dirt", x: spec.x, z: spec.z, radius: spec.radius * 1.02, lift: 0.045, rotation: rotation2 });
     addRimRocks(store, ground, random, spec.x, spec.z, spec.radius);
   }
   function addBloodSplat(store, ground, random, spec) {
@@ -5552,6 +5844,7 @@ var GameFluidsThree = (() => {
     state.gas = Math.max(0, state.gas - dt / DECAY.gasSeconds);
     state.beat *= Math.exp(-DECAY.beat * dt);
   }
+  var PAD_OF_SIZE2 = 0.35;
   var clamp4 = (v, lo, hi) => v < lo ? lo : v > hi ? hi : v;
   var lerp4 = (a, b, t) => a + (b - a) * t;
   function rgb(hex) {
@@ -5711,9 +6004,20 @@ var GameFluidsThree = (() => {
           vy2 *= k;
           vz2 *= k;
         }
-        const x = this.position[i3] + vx2 * dt;
+        let x = this.position[i3] + vx2 * dt;
         let y = this.position[i3 + 1] + vy2 * dt;
-        const z = this.position[i3 + 2] + vz2 * dt;
+        let z = this.position[i3 + 2] + vz2 * dt;
+        const confiner = host.confiner;
+        if (def.carried && confiner && !confiner.empty) {
+          const pad = this.size0[i] * lerp4(1, def.grow, t) * PAD_OF_SIZE2;
+          if (confiner.confine(this.position[i3], this.position[i3 + 1], this.position[i3 + 2], x, y, z, pad, dt)) {
+            const out = confiner.out;
+            x = out.x;
+            y = out.y;
+            z = out.z;
+            [vx2, vy2, vz2] = slideAlong(out, vx2, vy2, vz2);
+          }
+        }
         if (def.ground !== "none") {
           const own = this.floor[i];
           const gy = Number.isNaN(own) ? host.groundAt(x, z) + 5e-3 : own;
@@ -5799,7 +6103,8 @@ var GameFluidsThree = (() => {
       alpha: 0.35,
       fadeIn: 0.15,
       cone: 0.6,
-      ground: "none"
+      ground: "none",
+      carried: true
     },
     sparks: {
       id: "sparks",
@@ -5843,7 +6148,8 @@ var GameFluidsThree = (() => {
       alpha: 0.4,
       fadeIn: 0.1,
       cone: 0.4,
-      ground: "none"
+      ground: "none",
+      carried: true
     },
     shards: {
       id: "shards",
@@ -6001,7 +6307,8 @@ var GameFluidsThree = (() => {
       fadeIn: 0.1,
       cone: 0.5,
       ground: "stop",
-      flutter: 0.6
+      flutter: 0.6,
+      carried: true
     },
     steam: {
       id: "steam",
@@ -6023,7 +6330,8 @@ var GameFluidsThree = (() => {
       alpha: 0.35,
       fadeIn: 0.15,
       cone: 0.6,
-      ground: "none"
+      ground: "none",
+      carried: true
     },
     flash: {
       id: "flash",
@@ -6156,7 +6464,8 @@ var GameFluidsThree = (() => {
       const host = {
         groundAt: this.options.groundAt,
         gravity: this.options.gravity,
-        land: (owner, x, y, z, color, tag) => this.listeners.get(owner)?.(x, y, z, color, tag)
+        land: (owner, x, y, z, color, tag) => this.listeners.get(owner)?.(x, y, z, color, tag),
+        ...this.options.confiner ? { confiner: this.options.confiner } : {}
       };
       if (this.additive.live > 0 || this.additive.drawCount > 0) this.additive.update(dt, host);
       if (this.normal.live > 0 || this.normal.drawCount > 0) this.normal.update(dt, host);
@@ -6169,9 +6478,9 @@ var GameFluidsThree = (() => {
   var TWO_PI_ROUNDED = 6.2832;
   var WIDE_CONE = 3.1;
   var UP13 = [0, 1, 0];
-  function drawRange(random, range2) {
-    if (Array.isArray(range2)) return random.between(range2[0], range2[1]);
-    return range2 || 0;
+  function drawRange(random, range22) {
+    if (Array.isArray(range22)) return random.between(range22[0], range22[1]);
+    return range22 || 0;
   }
   function randomUnit(random, out) {
     const up = random.next() * 2 - 1;
@@ -6362,8 +6671,8 @@ var GameFluidsThree = (() => {
      * Takes away the marks inside a box: world `center`, `half` extents along the axes of the world `rotation` (a quaternion, x y z w; none means the
      * world axes). The surface they were on is gone (a brick came out of a wall with its bullet holes). Returns how many went.
      */
-    clearInside(center, half, rotation = [0, 0, 0, 1]) {
-      const qx = -rotation[0], qy = -rotation[1], qz = -rotation[2], qw = rotation[3];
+    clearInside(center, half, rotation2 = [0, 0, 0, 1]) {
+      const qx = -rotation2[0], qy = -rotation2[1], qz = -rotation2[2], qw = rotation2[3];
       let gone = 0;
       for (const decal2 of this.decals) {
         if (!decal2.on) continue;
@@ -6484,10 +6793,14 @@ var GameFluidsThree = (() => {
   var DEFAULT_FADE_IN = 0.1;
   var FLOATS_PER_VECTOR = 3;
   var BYTE_MAX2 = 255;
+  var CARRIED_GRAVITY = 3;
+  var PAD_OF_SIZE3 = 0.35;
   var SpritePool = class {
-    constructor(capacity, context) {
+    /** `carried`: the normal-blend pool (smoke, dust, steam), whose light sprites go round the closed spaces; the additive one (flames, sparks) does not. */
+    constructor(capacity, context, carried = false) {
       __publicField2(this, "capacity", capacity);
       __publicField2(this, "context", context);
+      __publicField2(this, "carried", carried);
       __publicField2(this, "count", 0);
       __publicField2(this, "position");
       __publicField2(this, "velocity");
@@ -6587,6 +6900,7 @@ var GameFluidsThree = (() => {
     }
     update(dt, leaveDecal) {
       const { position, velocity } = this;
+      const confiner = this.context.confiner;
       for (let index = this.count - 1; index >= 0; index--) {
         this.life[index] -= dt;
         if (this.life[index] <= 0) {
@@ -6600,9 +6914,25 @@ var GameFluidsThree = (() => {
         velocity[offset] *= factor;
         velocity[offset + 1] *= factor;
         velocity[offset + 2] *= factor;
+        const x0 = position[offset];
+        const y0 = position[offset + 1];
+        const z0 = position[offset + 2];
         position[offset] += velocity[offset] * dt;
         position[offset + 1] += velocity[offset + 1] * dt;
         position[offset + 2] += velocity[offset + 2] * dt;
+        if (this.carried && confiner && !confiner.empty && Math.abs(this.gravity[index]) < CARRIED_GRAVITY) {
+          const size = this.startSize[index] * (1 + (this.growth[index] - 1) * age);
+          if (confiner.confine(x0, y0, z0, position[offset], position[offset + 1], position[offset + 2], size * PAD_OF_SIZE3, dt)) {
+            const out = confiner.out;
+            position[offset] = out.x;
+            position[offset + 1] = out.y;
+            position[offset + 2] = out.z;
+            const [vx2, vy2, vz2] = slideAlong(out, velocity[offset], velocity[offset + 1], velocity[offset + 2]);
+            velocity[offset] = vx2;
+            velocity[offset + 1] = vy2;
+            velocity[offset + 2] = vz2;
+          }
+        }
         const mode = this.groundMode[index];
         if (mode) {
           const groundHeight = this.context.groundAt(position[offset], position[offset + 2]);
@@ -6879,9 +7209,9 @@ var GameFluidsThree = (() => {
       __publicField2(this, "placement");
       __publicField2(this, "accumulators", /* @__PURE__ */ new Map());
       const profile = options.profile ?? PROFILES.high;
-      this.context = { random: options.random, groundAt: options.groundAt ?? workshopGround, quality: { level: 0, mult: 1 }, trace: options.trace };
+      this.context = { random: options.random, groundAt: options.groundAt ?? workshopGround, quality: { level: 0, mult: 1 }, trace: options.trace, ...options.confiner ? { confiner: options.confiner } : {} };
       this.add = new SpritePool(profile.sprites.add, this.context);
-      this.normal = new SpritePool(profile.sprites.normal, this.context);
+      this.normal = new SpritePool(profile.sprites.normal, this.context, true);
       this.streaks = new StreakPool(profile.streaks, this.context);
       this.debris = new DebrisPool(this.context);
       this.decals = new DecalPool(this.context);
@@ -6917,13 +7247,13 @@ var GameFluidsThree = (() => {
       return [origin[0] + cos2 * x + sin2 * z, origin[1] + point[1] - anchor[1], origin[2] - sin2 * x + cos2 * z];
     }
     /** A direction or velocity of the recipe's space in the world. */
-    turn(vector) {
+    turn(vector2) {
       const placement = this.placement;
-      if (!placement) return vector;
-      if (placement.orientation) return rotate(placement.orientation, vector);
+      if (!placement) return vector2;
+      if (placement.orientation) return rotate(placement.orientation, vector2);
       const cos2 = Math.cos(placement.yaw);
       const sin2 = Math.sin(placement.yaw);
-      return [cos2 * vector[0] + sin2 * vector[2], vector[1], -sin2 * vector[0] + cos2 * vector[2]];
+      return [cos2 * vector2[0] + sin2 * vector2[2], vector2[1], -sin2 * vector2[0] + cos2 * vector2[2]];
     }
     placed(options) {
       if (!this.placement) return options;
@@ -7069,12 +7399,14 @@ var GameFluidsThree = (() => {
     const groundAt = options.groundAt ?? (ground ? (x, z) => ground.heightAt(x, z) : () => 0);
     const handles = { next: 0, events: 0 };
     const low = options.profile === "low";
+    const enclosures = new Enclosures(20973 + (options.seed ?? 0));
     const spriteSystem = new SpriteKindSystem({
       capacity: options.sprites?.capacity ?? (low ? 1250 : 2500),
       density: options.sprites?.density ?? (low ? 0.6 : 1),
       seed: 2654435761 + (options.seed ?? 0),
       groundAt,
       gravity: options.gravity ?? DEFAULT_GRAVITY,
+      confiner: enclosures,
       ...options.sprites?.kinds ? { kinds: options.sprites.kinds } : {}
     });
     const core = {
@@ -7124,7 +7456,7 @@ var GameFluidsThree = (() => {
       return [camera2.x, camera2.y, camera2.z];
     }, forward: (local2) => [local2[0] ?? 0, local2[1] ?? 0, local2[2] ?? 0] };
     function workshop() {
-      return engine ?? (engine = new WorkshopEngine({ random: sharedRandom, profile, groundAt }));
+      return engine ?? (engine = new WorkshopEngine({ random: sharedRandom, profile, groundAt, confiner: enclosures }));
     }
     function effectPlayer() {
       return player ?? (player = createEffectPlayer({ engine: workshop(), effects, view }));
@@ -7183,6 +7515,10 @@ var GameFluidsThree = (() => {
           puff3.vz += dz * strength;
         }
       },
+      enclose(id, enclosure) {
+        enclosures.set(id, enclosure);
+      },
+      enclosures: () => enclosures,
       stop(handle) {
         player?.stop(handle);
         const fires = core.fires;
@@ -7210,7 +7546,7 @@ var GameFluidsThree = (() => {
         core.clock.time += dt;
         core.schedule.update(core.clock.time);
         updateRings(core.rings, dt);
-        updatePuffs(core.puffs, dt, wind);
+        updatePuffs(core.puffs, dt, wind, enclosures);
         updateSparks(core.sparks, { dt, groundAt });
         updateGlows(core.glows, dt);
         updateShocks(core.shocks, core.puffs.items, dt);
@@ -7278,16 +7614,22 @@ var GameFluidsThree = (() => {
     };
   }
 
-  // ../game-contracts/dist/index.js
-  var KIT_ORIGIN_KEY = "kitOrigin";
-  function markKitOrigin(object, origin) {
-    const node = object;
-    node.userData = node.userData ?? {};
-    node.userData[KIT_ORIGIN_KEY] = { ...origin };
-    return object;
-  }
+  // ../game-render-three/dist/index.js
+  var DEFAULT_ANGLE = Math.PI / 3;
+  var LIGHT_PRIORITY = {
+    blast: 900,
+    rocket: 800,
+    muzzle: 750,
+    fire: 600,
+    flare: 500,
+    headlight: 400,
+    weaponLight: 400,
+    lamp: 200,
+    street: 150
+  };
+  var EFFECT_STEP_SECONDS = 1 / 50;
 
-  // ../game-vfx-three/dist/index.js
+  // ../game-vfx-three/dist/chunk-ALDCQ5RH.js
   var GLOW_VERTEX = `attribute vec4 aP;attribute vec4 aC;varying vec2 vU;varying vec4 vC;
 void main(){vec3 R=vec3(viewMatrix[0][0],viewMatrix[1][0],viewMatrix[2][0]);vec3 Up=vec3(viewMatrix[0][1],viewMatrix[1][1],viewMatrix[2][1]);
 vec3 wp=aP.xyz+(R*position.x+Up*position.y)*aP.w;vU=position.xy;vC=aC;gl_Position=projectionMatrix*viewMatrix*vec4(wp,1.);}`;
@@ -7566,8 +7908,26 @@ void main(){
       }
     };
   }
-  function createLightLayer(THREE, pool, scale2) {
+  var LIGHT_ON_THRESHOLD = 0.05;
+  var FIRE_COLOR = 16742954;
+  var FIRE_DECAY = 2;
+  var BLAST_DECAY = 2;
+  function followEntry(budget, handles, index, entry, request) {
+    const handle = handles[index] ?? null;
+    if (entry.intensity <= LIGHT_ON_THRESHOLD) {
+      handle?.release({ fadeMs: 0 });
+      handles[index] = null;
+      return;
+    }
+    if (handle?.alive) {
+      handle.update({ color: request.color, intensity: request.intensity, distance: request.distance, position: request.position });
+      return;
+    }
+    handles[index] = budget.acquire(request);
+  }
+  function createLightLayer(THREE, pool, scale2, budget) {
     const group = new THREE.Group();
+    if (budget) return createBudgetedLightLayer(group, pool, scale2, budget);
     const blast = pool.blast.map(() => {
       const light = new THREE.PointLight(16752720, 0, 30, 2);
       light.position.set(0, -50, 0);
@@ -7606,6 +7966,30 @@ void main(){
       }
     };
   }
+  function createBudgetedLightLayer(group, pool, scale2, budget) {
+    const blast = pool.blast.map(() => null);
+    const fire = pool.fire.map(() => null);
+    return {
+      group,
+      sync() {
+        let lit = 0;
+        pool.blast.forEach((entry, index) => {
+          const request = { owner: "vfx.blast", priority: LIGHT_PRIORITY.blast, urgent: true, color: entry.color, intensity: entry.intensity * scale2, distance: entry.distance, decay: BLAST_DECAY, position: [entry.x, entry.y, entry.z] };
+          followEntry(budget, blast, index, entry, request);
+          if (entry.intensity > LIGHT_ON_THRESHOLD) lit++;
+        });
+        pool.fire.forEach((entry, index) => {
+          const request = { owner: "vfx.fire", priority: LIGHT_PRIORITY.fire, color: FIRE_COLOR, intensity: entry.intensity * scale2, distance: entry.distance, decay: FIRE_DECAY, position: [entry.x, entry.y, entry.z] };
+          followEntry(budget, fire, index, entry, request);
+          if (entry.intensity > LIGHT_ON_THRESHOLD) lit++;
+        });
+        return lit;
+      },
+      dispose() {
+        for (const handle of [...blast, ...fire]) handle?.release({ fadeMs: 0 });
+      }
+    };
+  }
   var SCORCH_SEED = 5;
   var TEXTURE_SIZE = 256;
   var FULL_TURN = Math.PI * 2;
@@ -7739,6 +8123,7 @@ void main(){
       group.add(mesh2);
       return mesh2;
     }
+    let probeGeometry;
     const groundMarks = [];
     const spareGeometries = [];
     const blood = [];
@@ -7844,6 +8229,15 @@ void main(){
         rockMesh();
         plateMesh();
       },
+      probes() {
+        probeGeometry ?? (probeGeometry = new THREE.PlaneGeometry(1e-3, 1e-3).rotateX(-Math.PI / 2));
+        return [...scorchMaterials, dirtMaterial].map((material) => {
+          const mesh2 = new THREE.Mesh(probeGeometry, material);
+          mesh2.receiveShadow = true;
+          mesh2.frustumCulled = false;
+          return mesh2;
+        });
+      },
       update(dt) {
         for (let index = 0; index < blood.length; index++) {
           const drawn = blood[index];
@@ -7856,6 +8250,7 @@ void main(){
       dispose() {
         clearMarks();
         for (const mesh2 of [instanced.blood, instanced.rock, instanced.plate]) mesh2?.dispose();
+        probeGeometry?.dispose();
         for (const item of owned) item.dispose();
       }
     };
@@ -8431,7 +8826,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       }
     };
   }
-  function createWorkshopLayers(THREE, engine, pointScale, lightScale) {
+  function createWorkshopLayers(THREE, engine, pointScale, lightScale, budget) {
     const group = new THREE.Group();
     group.name = "workshop";
     const layers = [
@@ -8446,15 +8841,30 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     for (const layer2 of layers) group.add(layer2.object);
     const meshes = createMeshLayer(THREE, engine.meshes);
     group.add(meshes.group);
-    const flashLights = engine.lights.lights.map(() => new THREE.PointLight(16760944, 0, 14));
-    const fireLights = engine.lights.fire.map(() => new THREE.PointLight(FIRE_LIGHT_COLOR, 0, FIRE_LIGHT_DISTANCE));
-    for (const light of [...flashLights, ...fireLights]) group.add(light);
+    const lights = budget ? budgetedLights(engine, lightScale, budget) : legacyLights(THREE, engine, lightScale, group);
     return {
       group,
       sync() {
         let drawCalls = 0;
         for (const layer2 of layers) if (layer2.sync()) drawCalls++;
         drawCalls += meshes.sync();
+        lights.sync();
+        return drawCalls;
+      },
+      dispose() {
+        for (const layer2 of layers) layer2.dispose();
+        meshes.dispose();
+        lights.dispose();
+        group.clear();
+      }
+    };
+  }
+  function legacyLights(THREE, engine, lightScale, group) {
+    const flashLights = engine.lights.lights.map(() => new THREE.PointLight(16760944, 0, 14));
+    const fireLights = engine.lights.fire.map(() => new THREE.PointLight(FIRE_LIGHT_COLOR, 0, FIRE_LIGHT_DISTANCE));
+    for (const light of [...flashLights, ...fireLights]) group.add(light);
+    return {
+      sync() {
         engine.lights.lights.forEach((source, index) => {
           const light = flashLights[index];
           light.position.set(source.x, source.y, source.z);
@@ -8467,12 +8877,27 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
           light.position.set(source.x, source.y, source.z);
           light.intensity = source.intensity * lightScale;
         });
-        return drawCalls;
       },
       dispose() {
-        for (const layer2 of layers) layer2.dispose();
-        meshes.dispose();
-        group.clear();
+      }
+    };
+  }
+  function budgetedLights(engine, lightScale, budget) {
+    const flash2 = engine.lights.lights.map(() => null);
+    const fire = engine.lights.fire.map(() => null);
+    return {
+      sync() {
+        engine.lights.lights.forEach((source, index) => {
+          const request = { owner: "vfx.workshop", priority: LIGHT_PRIORITY.blast, urgent: true, color: source.color, intensity: source.intensity * lightScale, distance: source.distance, position: [source.x, source.y, source.z] };
+          followEntry(budget, flash2, index, source, request);
+        });
+        engine.lights.fire.forEach((source, index) => {
+          const request = { owner: "vfx.workshop", priority: LIGHT_PRIORITY.fire, color: FIRE_LIGHT_COLOR, intensity: source.intensity * lightScale, distance: FIRE_LIGHT_DISTANCE, position: [source.x, source.y, source.z] };
+          followEntry(budget, fire, index, source, request);
+        });
+      },
+      dispose() {
+        for (const handle of [...flash2, ...fire]) handle?.release({ fadeMs: 0 });
       }
     };
   }
@@ -8530,7 +8955,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     const chunks = createChunkLayer(THREE, pools.chunks, { rock: rockGeometry, plate: plateGeometry }, colorOfChunk);
     const shocks = createShockLayer(THREE, pools.shocks);
     const sprites = createSpriteLayer(THREE, world.sprites(), options.pointScale ?? 700);
-    const lights = createLightLayer(THREE, pools.lights, options.lightScale ?? Math.PI);
+    const lights = createLightLayer(THREE, pools.lights, options.lightScale ?? Math.PI, options.lights);
     const marks = createMarkLayer(THREE, { ground: pools.ground, createCanvas: options.createCanvas, rockGeometry, plateGeometry, ...options.markLimits });
     root.add(puffs.mesh, sparks.mesh, glows.mesh, chunks.rocks, chunks.plates, shocks.group, lights.group, sprites.additive, sprites.normal, marks.group);
     const stopMarks = world.onMarks((event) => marks.handle(event));
@@ -8563,7 +8988,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       workshopLayers?.dispose();
       if (workshopLayers) root.remove(workshopLayers.group);
       workshopEngine = engine;
-      workshopLayers = createWorkshopLayers(THREE, engine, options.pointScale ?? 700, 1);
+      workshopLayers = createWorkshopLayers(THREE, engine, options.pointScale ?? 700, 1, options.lights);
       root.add(workshopLayers.group);
       applyLayers();
     }
@@ -8603,6 +9028,8 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         });
       },
       stop: (handle) => world.stop(handle),
+      // a module's closed space (a shut car's cabin): the world's smoke, dust and steam go round it
+      enclose: (id, enclosure) => world.enclose(id, enclosure),
       configure(settings) {
         const band = settings.lod_band;
         if (typeof band === "string" && band in LOD_BANDS) world.forceLod(LOD_BANDS[band] ?? null);
@@ -8634,7 +9061,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         const meshes = createMeshLayerProbes(THREE);
         for (const mesh2 of meshes) mesh2.frustumCulled = false;
         const group = new THREE.Group();
-        group.add(...meshes);
+        group.add(...meshes, ...marks.probes());
         anchors = { meshes, group };
         return { group, dispose: () => {
         } };
@@ -9502,7 +9929,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       }
     };
   }
-  var range = (random, from, to) => from + random() * (to - from);
+  var range2 = (random, from, to) => from + random() * (to - from);
   function updateDrip(drip, bead, layout, random, launch, dt) {
     if (!drip) {
       bead.visible = false;
@@ -9521,11 +9948,11 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     if (drip.elapsed < drip.every) return;
     const origin = [bead.position[0], bead.position[1] + -radius * 1e-3, bead.position[2]];
     if (isWorkshop) {
-      const sideX2 = range(random, -0.025, 0.025);
-      const sideZ2 = range(random, -0.025, 0.025);
-      launch(origin, [sideX2, -0.2, sideZ2], drip.radius * range(random, 0.85, 1.15));
+      const sideX2 = range2(random, -0.025, 0.025);
+      const sideZ2 = range2(random, -0.025, 0.025);
+      launch(origin, [sideX2, -0.2, sideZ2], drip.radius * range2(random, 0.85, 1.15));
       drip.elapsed = 0;
-      drip.every = drip.base * range(random, 0.75, 1.25);
+      drip.every = drip.base * range2(random, 0.75, 1.25);
       return;
     }
     const sideX = (random() - 0.5) * 0.05;
@@ -9858,7 +10285,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
   var DEFAULT_CURB_ROWS = 12;
   var RULES = { dropCapacity: 160, curbCatch: false, guardBehindWall: false, clipRoadEnd: false, dripStyle: "padrao" };
   var along3 = (origin, axis2, distance2) => add2(origin, scale(axis2, distance2));
-  var reject = (vector, axis2) => sub3(vector, scale(axis2, dot2(vector, axis2)));
+  var reject = (vector2, axis2) => sub3(vector2, scale(axis2, dot2(vector2, axis2)));
   function layoutFromSurfaces(options) {
     const columns = options.columns ?? DEFAULT_COLUMNS;
     const totalRows = options.rows ?? DEFAULT_ROWS;
@@ -10463,6 +10890,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     const root = new THREE.Group();
     root.name = "fluid_renderer";
     scene.add(root);
+    if (!options.vfx) warnOnce("game-fluids-three.own-effects-world", "game-fluids-three made an effects world of its own because the host lent none (options.vfx); pass the host effects so the effects share one budget");
     const vfx = options.vfx ?? createVfx({ profile: quality, gravity: fluids.gravity, sprites: { capacity: profile.maxParticles } });
     const ownVfx = options.vfx ? void 0 : createVfxRenderer(THREE, { scene, camera: options.camera ?? new THREE.PerspectiveCamera(), vfx, pointScale: options.pointScale ?? 600 });
     const particles = new FluidSprites(vfx, `fluids-${++rendererCount}`);
@@ -10673,7 +11101,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     const direction = new THREE.Vector3();
     const location = new THREE.Vector3();
     const scale2 = new THREE.Vector3();
-    const rotation = new THREE.Quaternion();
+    const rotation2 = new THREE.Quaternion();
     const matrix = new THREE.Matrix4();
     return {
       drops,
@@ -10693,9 +11121,9 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
           const o = i * 3;
           const speed = Math.hypot(velocity[o], velocity[o + 1], velocity[o + 2]);
           direction.set(velocity[o], velocity[o + 1], velocity[o + 2]).normalize();
-          rotation.setFromUnitVectors(up, direction);
+          rotation2.setFromUnitVectors(up, direction);
           const size = radius[i] * METRES_PER_MM;
-          matrix.compose(location.set(position[o], position[o + 1], position[o + 2]), rotation, scale2.set(size, size * (1 + Math.min(MAX_STRETCH, speed * STRETCH_PER_SPEED)), size));
+          matrix.compose(location.set(position[o], position[o + 1], position[o + 2]), rotation2, scale2.set(size, size * (1 + Math.min(MAX_STRETCH, speed * STRETCH_PER_SPEED)), size));
           drops.setMatrixAt(i, matrix);
           drawn++;
         }
@@ -11168,7 +11596,7 @@ void main(){
     update(dt) {
       this.time += dt;
       const viewer = this.viewer();
-      const range2 = this.options.range ?? DEFAULT_RANGE;
+      const range3 = this.options.range ?? DEFAULT_RANGE;
       const budget = this.options.budgetMs ?? DEFAULT_BUDGET_MS;
       const drying = dt * (this.options.dryingSpeed ?? 1);
       const order = [...this.grids].sort((a, b) => viewer ? distance(viewer.position, a.center) - distance(viewer.position, b.center) : 0);
@@ -11176,7 +11604,7 @@ void main(){
       let starved = 0;
       let uploaded = 0;
       for (const grid of order) {
-        if (viewer && distance(viewer.position, grid.center) > range2 * BAKE_RANGE_FACTOR) {
+        if (viewer && distance(viewer.position, grid.center) > range3 * BAKE_RANGE_FACTOR) {
           this.release(grid, "range");
           continue;
         }