@adatechnology/game-vfx-three 0.1.3 → 0.2.0

package/dist/index.global.js

@@ -1374,77 +1374,77 @@ var GameVfxThree = (() => {
     }));
   }
   function spawnPuff(pool, random, init) {
-    const puff2 = pool.acquire();
-    puff2.x = init.x ?? 0;
-    puff2.y = init.y ?? 0;
-    puff2.z = init.z ?? 0;
-    puff2.vx = init.vx ?? 0;
-    puff2.vy = init.vy ?? 0;
-    puff2.vz = init.vz ?? 0;
-    puff2.s0 = init.s0 ?? 0.2;
-    puff2.s1 = init.s1 ?? 1;
-    puff2.sg = init.sg ?? 0.1;
-    puff2.gk = init.gk ?? 6;
-    puff2.life = init.life ?? 3;
-    puff2.t = 0;
-    puff2.h0 = init.h0 ?? 0;
-    puff2.hl = init.hl ?? 0.4;
-    puff2.drag = init.drag ?? 3;
-    puff2.buoy = init.buoy ?? 0.5;
-    puff2.grav = init.grav ?? 0;
-    puff2.kind = init.kind ?? 0;
-    puff2.seed = random.next();
-    puff2.wind = init.wind ?? 1;
-    puff2.color = init.color ?? SMOKE_COLORS.grey;
-    puff2.ring = init.ring ?? null;
-    puff2.ph = init.ph ?? 0;
-    puff2.th = init.th ?? 0;
-    puff2.rng = random;
-    puff2.age = 0;
-    puff2.heat = 0;
-    puff2.size = 0;
-    return puff2;
-  }
-  function ageOrKeep2(puff2, dt) {
-    puff2.t += dt;
-    return puff2.t < puff2.life;
-  }
-  function moveOnRing(puff2, ring2, wind) {
+    const puff3 = pool.acquire();
+    puff3.x = init.x ?? 0;
+    puff3.y = init.y ?? 0;
+    puff3.z = init.z ?? 0;
+    puff3.vx = init.vx ?? 0;
+    puff3.vy = init.vy ?? 0;
+    puff3.vz = init.vz ?? 0;
+    puff3.s0 = init.s0 ?? 0.2;
+    puff3.s1 = init.s1 ?? 1;
+    puff3.sg = init.sg ?? 0.1;
+    puff3.gk = init.gk ?? 6;
+    puff3.life = init.life ?? 3;
+    puff3.t = 0;
+    puff3.h0 = init.h0 ?? 0;
+    puff3.hl = init.hl ?? 0.4;
+    puff3.drag = init.drag ?? 3;
+    puff3.buoy = init.buoy ?? 0.5;
+    puff3.grav = init.grav ?? 0;
+    puff3.kind = init.kind ?? 0;
+    puff3.seed = random.next();
+    puff3.wind = init.wind ?? 1;
+    puff3.color = init.color ?? SMOKE_COLORS.grey;
+    puff3.ring = init.ring ?? null;
+    puff3.ph = init.ph ?? 0;
+    puff3.th = init.th ?? 0;
+    puff3.rng = random;
+    puff3.age = 0;
+    puff3.heat = 0;
+    puff3.size = 0;
+    return puff3;
+  }
+  function ageOrKeep2(puff3, dt) {
+    puff3.t += dt;
+    return puff3.t < puff3.life;
+  }
+  function moveOnRing(puff3, ring2, wind) {
     const ringTime = ring2.t;
     const centerY = ring2.y0 + ring2.rise * (1 - Math.exp(-ringTime * ring2.rk));
     const majorRadius = ring2.R0 + (ring2.R1 - ring2.R0) * (1 - Math.exp(-ringTime * 1.6));
-    const theta = puff2.th + ringTime * ring2.roll;
+    const theta = puff3.th + ringTime * ring2.roll;
     const minorRadius = ring2.r * (0.8 + 0.4 * Math.min(1, ringTime));
     const radius = majorRadius + minorRadius * Math.cos(theta);
-    puff2.x = ring2.x + Math.cos(puff2.ph) * radius + wind.x * ringTime * 0.6;
-    puff2.z = ring2.z + Math.sin(puff2.ph) * radius + wind.z * ringTime * 0.6;
-    puff2.y = centerY + minorRadius * Math.sin(theta);
-  }
-  function moveFree(puff2, dt, age, heat, wind) {
-    const damping = Math.exp(-puff2.drag * dt);
-    puff2.vx *= damping;
-    puff2.vy *= damping;
-    puff2.vz *= damping;
-    puff2.vy += (puff2.buoy * (heat > 0 ? 1.6 : 1) - puff2.grav) * dt;
-    puff2.x += (puff2.vx + wind.x * puff2.wind * age) * dt;
-    puff2.y += puff2.vy * dt;
-    puff2.z += (puff2.vz + wind.z * puff2.wind * age) * dt;
-    if (puff2.y < puff2.s0 * FLOOR_FRACTION) {
-      puff2.y = puff2.s0 * FLOOR_FRACTION;
-      if (puff2.vy < 0) puff2.vy *= FLOOR_BOUNCE;
+    puff3.x = ring2.x + Math.cos(puff3.ph) * radius + wind.x * ringTime * 0.6;
+    puff3.z = ring2.z + Math.sin(puff3.ph) * radius + wind.z * ringTime * 0.6;
+    puff3.y = centerY + minorRadius * Math.sin(theta);
+  }
+  function moveFree(puff3, dt, age, heat, wind) {
+    const damping = Math.exp(-puff3.drag * dt);
+    puff3.vx *= damping;
+    puff3.vy *= damping;
+    puff3.vz *= damping;
+    puff3.vy += (puff3.buoy * (heat > 0 ? 1.6 : 1) - puff3.grav) * dt;
+    puff3.x += (puff3.vx + wind.x * puff3.wind * age) * dt;
+    puff3.y += puff3.vy * dt;
+    puff3.z += (puff3.vz + wind.z * puff3.wind * age) * dt;
+    if (puff3.y < puff3.s0 * FLOOR_FRACTION) {
+      puff3.y = puff3.s0 * FLOOR_FRACTION;
+      if (puff3.vy < 0) puff3.vy *= FLOOR_BOUNCE;
     }
   }
   function updatePuffs(pool, dt, wind) {
     pool.compact(ageOrKeep2, dt);
-    for (const puff2 of pool.items) {
-      const age = puff2.t / puff2.life;
-      const heat = puff2.h0 > 0 ? puff2.h0 * Math.pow(Math.max(0, 1 - puff2.t / puff2.hl), 1.25) : 0;
-      if (puff2.ring) moveOnRing(puff2, puff2.ring, wind);
-      else moveFree(puff2, dt, age, heat, wind);
-      const size = puff2.s0 + (puff2.s1 - puff2.s0) * (1 - Math.exp(-puff2.t * puff2.gk)) + puff2.sg * Math.min(puff2.t, GROWTH_CAP_SECONDS);
-      puff2.size = size * Math.min(1, puff2.t * ARRIVAL_FRAME + ARRIVAL_BASE);
-      puff2.age = age;
-      puff2.heat = heat;
+    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;
+      if (puff3.ring) moveOnRing(puff3, puff3.ring, wind);
+      else moveFree(puff3, dt, age, heat, wind);
+      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;
+      puff3.heat = heat;
     }
   }
   var GROUND_LIFT = 0.02;
@@ -1501,9 +1501,9 @@ var GameVfxThree = (() => {
   var HOT_GLOW_COLOR = [1, 0.45, 0.12];
   function addPuff(core, random, init) {
     core.spawned.puffs++;
-    const puff2 = spawnPuff(core.puffs, random, init);
-    core.trace?.puff?.(puff2);
-    return puff2;
+    const puff3 = spawnPuff(core.puffs, random, init);
+    core.trace?.puff?.(puff3);
+    return puff3;
   }
   function addSpark(core, init) {
     core.spawned.sparks++;
@@ -1685,6 +1685,7 @@ var GameVfxThree = (() => {
   var neg = call("neg");
   var abs = call("abs");
   var sqrt = call("sqrt");
+  var exp = call("exp");
   var sin = call("sin");
   var cos = call("cos");
   var atan2 = call("atan2");
@@ -1730,10 +1731,12 @@ var GameVfxThree = (() => {
   var INDEX = { $: "index" };
   var QUALITY = { $: "quality" };
   var FRESH = { $: "fresh" };
+  var DIRECTION = { $: "direction" };
   var CAMERA_POSITION = { $: "cameraPosition" };
   var burst = (system, count, spawn2) => ({ op: "burst", system, count, spawn: spawn2 });
   var spawn = (system, options) => ({ op: "spawn", system, spawn: options });
   var emit = (key, system, rate, options) => ({ op: "emit", key, system, rate, spawn: options });
+  var mesh = (options) => ({ op: "mesh", spawn: options });
   var debris = (options) => ({ op: "debris", spawn: options });
   var decal = (...args) => ({ op: "decal", args });
   var ring = (...args) => ({ op: "ring", args });
@@ -2745,6 +2748,241 @@ var GameVfxThree = (() => {
       )
     ]
   };
+  var SPOTS_X = [-3, 1, 5];
+  var SPOTS_Z = [-1, -2.4, 0.4];
+  var FOG_AND_ASH = {
+    id: "fog_and_ash",
+    pageId: "neblina",
+    team: "world",
+    budget: { particles: 120, lights: 1 },
+    loop: 0,
+    view: { eye: [3, 1.8, 7.5], target: [-3, 1.2, -1] },
+    setup: [
+      cue("fog", { density: 0.075 }),
+      cue("lamp_cone", { visible: true }),
+      cue("zombie_visible", { index: -1, visible: false }),
+      repeat(
+        SPOTS_X.length,
+        set("turn", rnd(-0.6, 0.6)),
+        behavior("walkers", "place", { index: INDEX, x: pick(SPOTS_X, INDEX), z: pick(SPOTS_Z, INDEX), facing: variable("turn") })
+      )
+    ],
+    timeline: [],
+    tick: [
+      emit("fog", "normal", 5, { p: [rnd(-14, 10), rnd(0.2, 1.1), rnd(-3, 8)], v: [rnd(0.15, 0.35), 0, rnd(-0.05, 0.05)], sp: 0, life: [9, 13], size: [3, 5], grow: 1.4, c0: 8227488, a: 0.13, fi: 0.35 }),
+      emit("ash", "normal", 14, { p: [rnd(-10, 8), rnd(4, 6), rnd(-3, 7)], v: [rnd(0.1, 0.4), -0.35, rnd(-0.1, 0.1)], sp: [0.05, 0.15], life: [8, 12], size: [0.025, 0.04], c0: 10525328, a: 0.75, fi: 0.1, gnd: 1 })
+    ]
+  };
+  var RAIN_CAPACITY = 4e3;
+  var FALL_SPEED = 15;
+  var WIND_PER_FALL = 0.07;
+  var STREAK_SLANT = 0.04;
+  var STREAK_LENGTH = 0.6;
+  var BOX_X = [-15, 15];
+  var BOX_Z = [-6, 16];
+  var START_HEIGHT = [0, 16];
+  var REENTRY_HEIGHT = [14, 17];
+  var SPLASH_CHANCE = 0.35;
+  var SPLASH_RANGE = 12;
+  var SPRITE_CHANCE = 0.5;
+  var UP9 = [0, 1, 0];
+  var WORKSHOP_PUDDLES = [
+    [-1.5, 2.2, 1.6, 0.9],
+    [3, 3.6, 1.1, 0.7],
+    [-6, 3.2, 1.3, 0.8],
+    [1.4, -2.2, 0.9, 0.5]
+  ];
+  var inPuddle = (puddles, x, z) => puddles.some((p) => ((x - p[0]) / p[2]) ** 2 + ((z - p[1]) / p[3]) ** 2 < 1);
+  var RainField = class {
+    constructor(engine) {
+      __publicField(this, "engine", engine);
+      __publicField(this, "positions", new Float32Array(RAIN_CAPACITY * 6));
+      __publicField(this, "count", 0);
+      __publicField(this, "wind", 1);
+      __publicField(this, "on", false);
+      __publicField(this, "centerX", 0);
+      __publicField(this, "centerZ", 0);
+      __publicField(this, "puddles", WORKSHOP_PUDDLES);
+      __publicField(this, "puddleAt");
+    }
+    /** `initRain` (W321): `count` streaks (thinned by the quality), each drawn at a random place in the box. */
+    init(count, wind) {
+      const { random } = this.engine;
+      this.count = Math.min(RAIN_CAPACITY, Math.round(count * this.engine.context.quality.mult));
+      this.wind = wind;
+      this.on = true;
+      for (let index = 0; index < this.count; index++) {
+        const offset = index * 6;
+        const x = random.between(BOX_X[0], BOX_X[1]);
+        const y = random.between(START_HEIGHT[0], START_HEIGHT[1]);
+        const z = random.between(BOX_Z[0], BOX_Z[1]);
+        this.set(offset, x, y, z);
+      }
+    }
+    /**
+     * What a game does with the field every frame: the box follows the camera (`centerX`, `centerZ`), the streaks thin or thicken to `count` (a new streak
+     * starts at a random place of the box, as `init` draws it) and the wind slants them. The golden never calls it.
+     */
+    drive(count, wind, centerX, centerZ) {
+      const { random } = this.engine;
+      const target = Math.max(0, Math.min(RAIN_CAPACITY, Math.round(count * this.engine.context.quality.mult)));
+      this.wind = wind;
+      this.centerX = centerX;
+      this.centerZ = centerZ;
+      this.on = target > 0;
+      for (let index = this.count; index < target; index++) {
+        this.set(index * 6, random.between(BOX_X[0], BOX_X[1]) + centerX, random.between(START_HEIGHT[0], START_HEIGHT[1]), random.between(BOX_Z[0], BOX_Z[1]) + centerZ);
+      }
+      this.count = target;
+    }
+    /** `updateRain` (W322-329). `camera` is where the eye is; `splash` lets the drops that land leave a splash. */
+    update(dt, splash, camera2) {
+      if (!this.on) return;
+      const { random, context } = this.engine;
+      const positions = this.positions;
+      const fall = FALL_SPEED * dt;
+      const slant = this.wind * fall * WIND_PER_FALL;
+      const reach = SPLASH_RANGE / (1 + context.quality.level);
+      for (let index = 0; index < this.count; index++) {
+        const o = index * 6;
+        positions[o] += slant;
+        positions[o + 3] += slant;
+        positions[o + 1] -= fall;
+        positions[o + 4] -= fall;
+        const ground = context.groundAt(positions[o], positions[o + 2]);
+        if (positions[o + 4] < ground) {
+          const x = positions[o];
+          const z = positions[o + 2];
+          if (splash && random.next() < SPLASH_CHANCE) {
+            const distance = Math.hypot(x - camera2[0], z - camera2[2]);
+            if (distance < reach) {
+              if (random.next() < SPRITE_CHANCE) {
+                this.engine.spawn("normal", { p: [x, ground + 0.01, z], dir: UP9, cone: 0.6, sp: [0.6, 1.3], life: [0.18, 0.3], size: 0.035, c0: 12110044, a: 0.6, g: 9.8, fi: 0 });
+              }
+              if (this.puddleAt ? this.puddleAt(x, z) : inPuddle(this.puddles, x, z)) {
+                this.engine.ring([[x, ground + 0.012, z], 0.01, random.between(0.12, 0.25), random.between(0.4, 0.6), 6978192]);
+              }
+            }
+          }
+          const nx = random.between(BOX_X[0], BOX_X[1]) + this.centerX;
+          const ny = random.between(REENTRY_HEIGHT[0], REENTRY_HEIGHT[1]);
+          const nz = random.between(BOX_Z[0], BOX_Z[1]) + this.centerZ;
+          this.set(o, nx, ny, nz);
+        }
+      }
+    }
+    /** `rain.visible = false; RN.on = false` (W440): the field stops; the streaks stay where they were. */
+    clear() {
+      this.on = false;
+    }
+    set(offset, x, y, z) {
+      const positions = this.positions;
+      positions[offset] = x;
+      positions[offset + 1] = y;
+      positions[offset + 2] = z;
+      positions[offset + 3] = x + this.wind * STREAK_SLANT;
+      positions[offset + 4] = y - STREAK_LENGTH;
+      positions[offset + 5] = z;
+    }
+  };
+  var DROPS = [900, 2200, 4e3];
+  var SLANT = [0.3, 1.2, 4.5];
+  var STORM = 2;
+  var FLASH_STEPS = ite(lt(variable("flash"), 0.08), 1, ite(lt(variable("flash"), 0.16), 0.2, ite(lt(variable("flash"), 0.26), 0.8, 0)));
+  var RAIN_AND_PUDDLES = {
+    id: "rain_and_puddles",
+    pageId: "chuva",
+    team: "world",
+    params: { id: "intensity", options: ["drizzle", "rain", "storm"], default: 1 },
+    budget: { particles: 4e3, decals: 4 },
+    loop: 0,
+    view: { eye: [2, 2, 7], target: [-1, 0.6, 1] },
+    setup: [
+      cue("lamp_cone", { visible: true }),
+      ...WORKSHOP_PUDDLES.map(([x, z, radiusX, radiusZ]) => decal(x, 0, z, radiusX * 2, 790550, { grow: 0, life: 1e6, ar: radiusZ / radiusX }))
+    ],
+    timeline: [
+      behavior("rain", "init", { count: ite(eq(PARAM, 0), DROPS[0], ite(eq(PARAM, 1), DROPS[1], DROPS[2])), wind: ite(eq(PARAM, 0), SLANT[0], ite(eq(PARAM, 1), SLANT[1], SLANT[2])) }),
+      set("nextStrike", rnd(2, 4)),
+      set("flash", -1)
+    ],
+    tick: [
+      behavior("rain", "update", { dt: DELTA, splash: gt(PARAM, 0) }),
+      when(eq(PARAM, STORM), [
+        when(gt(TIME, variable("nextStrike")), [set("nextStrike", add(TIME, rnd(3.5, 6))), set("flash", 0)]),
+        when(ge(variable("flash"), 0), [
+          set("flash", add(variable("flash"), DELTA)),
+          set("light", FLASH_STEPS),
+          cue("lightning", { intensity: variable("light") }),
+          screen({ max: { white: mul(variable("light"), 0.12) } }),
+          when(gt(variable("flash"), 0.4), [set("flash", -1), cue("lightning", { intensity: 0 })])
+        ]),
+        emit("sheet", "normal", 2.5, { p: [-12, 2.5, rnd(-1, 8)], box: [0, 2, 0], v: [7, -0.5, 0], sp: 0, life: [3, 4], size: [3, 5], grow: 1.3, c0: 9083568, a: 0.06, fi: 0.3 })
+      ])
+    ]
+  };
+  var CAR_ORIGIN2 = [5.6, 0, 0.8];
+  var CAR_ROTATION2 = [0, -0.4, 0];
+  var carPoint = (x, y, z) => localToWorld(CAR_ORIGIN2, CAR_ROTATION2, [x, y, z]);
+  var carDirection = (from, to) => normalized([to[0] - from[0], to[1] - from[1], to[2] - from[2]]);
+  var BEAM_FROM = carPoint(0, 0.74, 2.15);
+  var BEAM_DIRECTION = carDirection(BEAM_FROM, carPoint(0, 0.74, 3.15));
+  var BEAM_SIDE = [BEAM_DIRECTION[2], 0, -BEAM_DIRECTION[0]];
+  var WALKERS = 6;
+  var WALK_SPEED2 = 0.7;
+  var DROPS2 = 1800;
+  var SLANT2 = 0.8;
+  var startWalking = [
+    set("spot", query("car", "point", rnd(-2, 2), 0, rnd(8, 18))),
+    set("goal", query("car", "point", rnd(-0.6, 0.6), 0, 2.6)),
+    behavior("walkers", "place", { index: INDEX, x: pick(variable("spot"), 0), z: pick(variable("spot"), 2), facing: 0 }),
+    behavior("walkers", "walk", { index: INDEX, to: variable("goal"), speed: WALK_SPEED2 })
+  ];
+  var HEADLIGHTS_IN_RAIN = {
+    id: "headlights_in_rain",
+    pageId: "farol",
+    team: "vehicles",
+    budget: { particles: 600, lights: 2 },
+    loop: 0,
+    view: { eye: [-2.5, 2, 5.5], target: [4, 1, 6] },
+    setup: [
+      cue("fog", { density: 0.05 }),
+      cue("headlights", { on: true, intensity: 2.4, color: 16773584 }),
+      behavior("rain", "init", { count: DROPS2, wind: SLANT2 }),
+      repeat(WALKERS, ...startWalking)
+    ],
+    timeline: [],
+    tick: [
+      behavior("rain", "update", { dt: DELTA, splash: true }),
+      emit(
+        "lit",
+        "streak",
+        600,
+        local(
+          "depth",
+          rnd(1, 13),
+          local(
+            "spread",
+            mul(variable("depth"), 0.33, sqrt(rand())),
+            local(
+              "turn",
+              rnd(0, 6.283),
+              local("base", vadd(BEAM_FROM, vscale(BEAM_DIRECTION, variable("depth")), vscale(BEAM_SIDE, mul(cos(variable("turn")), variable("spread")))), {
+                p: vwith(variable("base"), 1, add(vy(variable("base")), mul(sin(variable("turn")), variable("spread"), 0.6))),
+                v: [0.8, -14, 0],
+                sp: 0,
+                life: 0.06,
+                len: 0.035,
+                c0: 13622512,
+                a: 0.9
+              })
+            )
+          )
+        )
+      ),
+      repeat(WALKERS, when(not(query("walkers", "is_walking", INDEX)), startWalking))
+    ]
+  };
   var YAW = -Math.PI / 2;
   var COS = Math.cos(YAW);
   var SIN = Math.sin(YAW);
@@ -2772,10 +3010,6 @@ var GameVfxThree = (() => {
       fireLight(0, [vx(variable("contact")), 0.34, vz(variable("contact"))], 1.6, mul(TIME, 3))
     ]
   };
-  var CAR_ORIGIN2 = [5.6, 0, 0.8];
-  var CAR_ROTATION2 = [0, -0.4, 0];
-  var carPoint = (x, y, z) => localToWorld(CAR_ORIGIN2, CAR_ROTATION2, [x, y, z]);
-  var carDirection = (from, to) => normalized([to[0] - from[0], to[1] - from[1], to[2] - from[2]]);
   var HOOD = carPoint(0, 1.02, 1.4);
   var EXHAUST = carPoint(0.5, 0.3, -2.2);
   var EXHAUST_DIRECTION = carDirection(EXHAUST, carPoint(0.5, 0.3, -3));
@@ -2809,7 +3043,7 @@ var GameVfxThree = (() => {
       ], [fireLightOff(0)])
     ]
   };
-  var UP9 = [0, 1, 0];
+  var UP10 = [0, 1, 0];
   var doorVelocity = (side) => {
     const out = carPoint(side * 4, 3, 0.3);
     const centre = carPoint(0, 0, 0.3);
@@ -2819,7 +3053,7 @@ var GameVfxThree = (() => {
     call2("explode", vadd(query("car", "position"), [0, 0.6, 0]), 1.8, 2759188),
     cue("car_burnt"),
     behavior("car", "launch", { rise: 4.5, spin: 0.9 }),
-    repeat(scaled(30), debris({ p: vadd(query("car", "position"), [0, 1.3, 0]), dir: UP9, cone: 1.3, sp: [2, 6], size: [0.06, 6e-3, 0.06], c: 11061464, life: 20 })),
+    repeat(scaled(30), debris({ p: vadd(query("car", "position"), [0, 1.3, 0]), dir: UP10, cone: 1.3, sp: [2, 6], size: [0.06, 6e-3, 0.06], c: 11061464, life: 20 })),
     debris({ p: carPoint(0, 1, 1.4), v: [rnd(-1, 1), 9, rnd(-1, 1)], sp: 0, size: [1.6, 0.06, 1.2], c: 3808536, spin: 6, life: 20, bounce: 0.2 }),
     ...[-1, 1].map((side) => debris({ p: carPoint(side * 0.95, 0.7, 0.3), v: doorVelocity(side), sp: 0, size: [0.06, 0.7, 1.1], c: 3808536, spin: 5, life: 20, bounce: 0.2 })),
     debris({ p: carPoint(0.95, 0.38, 1.35), v: [3, 4, 2], sp: 0, size: [0.3, 0.76, 0.76], c: 1118481, spin: 8, life: 20, bounce: 0.4 })
@@ -2989,7 +3223,7 @@ var GameVfxThree = (() => {
       ])
     ]
   };
-  var WALKERS = 6;
+  var WALKERS2 = 6;
   var NEAR = 9;
   var RANGE = 7;
   var RESTING_BPM = 70;
@@ -3005,7 +3239,7 @@ var GameVfxThree = (() => {
     setup: [
       cue("zombie_visible", { index: -1, visible: false }),
       repeat(
-        WALKERS,
+        WALKERS2,
         set("startX", rnd(-4, 4)),
         set("startZ", sub(rnd(-4, -2), mul(INDEX, 0.6))),
         behavior("walkers", "place", { index: INDEX, x: variable("startX"), z: variable("startZ"), facing: 0 }),
@@ -3015,7 +3249,7 @@ var GameVfxThree = (() => {
     timeline: [],
     tick: [
       set("nearest", 99),
-      repeat(WALKERS, set("nearest", min(variable("nearest"), vdist(walkerPoint, CAMERA_POSITION)))),
+      repeat(WALKERS2, set("nearest", min(variable("nearest"), vdist(walkerPoint, CAMERA_POSITION)))),
       set("fear", clamp(div(sub(NEAR, variable("nearest")), RANGE), 0, 1)),
       set("bpm", add(RESTING_BPM, mul(BPM_RISE, variable("fear")))),
       when(lt(mod(div(mul(TIME, variable("bpm")), 60), 1), div(mul(DELTA, variable("bpm")), 60)), [screen({ set: { beat: add(0.4, mul(0.6, variable("fear"))) } })]),
@@ -3082,7 +3316,7 @@ var GameVfxThree = (() => {
     ]
   };
   var FACING4 = [0, 0, 1];
-  var UP10 = [0, 1, 0];
+  var UP11 = [0, 1, 0];
   var ORIGIN = [0, 0, 0];
   var FORWARD4 = [0, 0, -1];
   var IMPACT_MATERIALS = ["concrete", "metal", "wood", "glass", "flesh", "water"];
@@ -3212,12 +3446,148 @@ var GameVfxThree = (() => {
       team: "destruction",
       budget: { particles: 20, debris: 8 },
       loop: 2,
-      timeline: [call2("chips", ORIGIN, UP10, 8, 0.9), call2("rust_at", ORIGIN, 6)]
+      timeline: [call2("chips", ORIGIN, UP11, 8, 0.9), call2("rust_at", ORIGIN, 6)]
     }
   ];
-  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, SCRAPING_SPARKS, ENGINE_SMOKE, FUEL_LEAK, CAR_EXPLOSION, WINDSHIELD, DAMAGE_AND_BITE, INFECTION_PHASES, PANIC, BLOATER_BLINDNESS, CAMPFIRE, COUGH_AND_BREATH];
+  var PI = Math.PI;
+  var SMOKE = { color: 9079430, width: 10, height: 8, gravity: -0.08, drag: 2.2, growth: 2.1 };
+  var FLASH_SECONDS = 0.055;
+  var FLASH_RAMP = [0.6, 0.9];
+  var FLASH_OPACITY = 0.95;
+  var FLAME_COLORS = [16742946, 16760896, 13121050, 16773296];
+  var FLAME_ADDITIVE = 3;
+  var ORIGIN2 = [0, 0, 0];
+  var SIZE = variable("size");
+  var wide = (width) => mul(sub(rand(), 0.5), width);
+  var puff2 = (point, velocity, world, radius, life, opacity) => mesh({
+    shape: "sphere",
+    p: point,
+    v: velocity,
+    wv: world,
+    r: radius,
+    seg: SMOKE.width,
+    seg2: SMOKE.height,
+    life,
+    c0: SMOKE.color,
+    a: opacity,
+    fade: true,
+    lit: true,
+    g: SMOKE.gravity,
+    drag: SMOKE.drag,
+    grow: SMOKE.growth
+  });
+  var flameBit = (point, velocity, world, radius, life) => [
+    set("bitPoint", point),
+    set("bitVelocity", velocity),
+    set("bitWorld", world),
+    set("bitRadius", radius),
+    set("bitLife", life),
+    set("bitColour", floor(mul(rand(), FLAME_COLORS.length))),
+    mesh({
+      shape: "icosahedron",
+      p: variable("bitPoint"),
+      v: variable("bitVelocity"),
+      wv: variable("bitWorld"),
+      r: variable("bitRadius"),
+      seg: 1,
+      rot: [mul(rand(), 3), mul(rand(), 3), 0],
+      spin: [3, 4, 2],
+      life: variable("bitLife"),
+      c0: pick(FLAME_COLORS, variable("bitColour")),
+      add: eq(variable("bitColour"), FLAME_ADDITIVE),
+      a: 0.9,
+      fade: true,
+      g: -1.4,
+      drag: 1.4,
+      grow: 2.2
+    })
+  ];
+  var flashPiece = (shape, radius, height, width, at3, rot, color) => mesh({ shape, r: radius, ...height === void 0 ? {} : { h: height }, seg: width, seg2: shape === "sphere" ? 8 : 1, p: ORIGIN2, at: at3, rot, roll: variable("roll"), ramp: FLASH_RAMP, life: FLASH_SECONDS, c0: color, a: FLASH_OPACITY, add: true });
+  var MUZZLE_FLASH2 = {
+    id: "viewmodel_muzzle_flash",
+    pageId: "event:viewmodel_muzzle_flash",
+    team: "weapons",
+    budget: { particles: 12, lights: 1 },
+    loop: 0.1,
+    timeline: [
+      set("angles", []),
+      repeat(4, append("angles", add(div(mul(INDEX, PI), 2), mul(rand(), 0.6)))),
+      set("roll", mul(rand(), PI)),
+      flash(ORIGIN2, 16756832, mul(4, SIZE), FLASH_SECONDS, mul(2, SIZE), true, true),
+      flashPiece("cone_open", mul(0.013, SIZE), mul(0.085, SIZE), 10, [mul(0.042, SIZE), 0, 0], [0, 0, -PI / 2], 16757575),
+      repeat(
+        4,
+        set("angle", pick(variable("angles"), INDEX)),
+        flashPiece(
+          "cone",
+          mul(5e-3, SIZE),
+          mul(0.04, SIZE),
+          6,
+          [mul(0.012, SIZE), mul(cos(variable("angle")), 0.016, SIZE), mul(sin(variable("angle")), 0.016, SIZE)],
+          [variable("angle"), 0, -PI / 2],
+          16757575
+        )
+      ),
+      flashPiece("sphere", mul(0.016, SIZE), void 0, 12, [mul(8e-3, SIZE), 0, 0], [0, 0, 0], 16773568),
+      repeat(
+        6,
+        puff2(
+          ORIGIN2,
+          [add(0.15, mul(rand(), 0.35)), add(0.03, mul(rand(), 0.12)), mul(sub(rand(), 0.5), 0.14)],
+          [0, 0, 0],
+          mul(0.013, SIZE),
+          add(1.3, mul(rand(), 0.6)),
+          0.45
+        )
+      )
+    ]
+  };
+  var SMOKE_PUFF = {
+    id: "weapon_smoke_puff",
+    pageId: "event:weapon_smoke_puff",
+    team: "weapons",
+    budget: { particles: 1 },
+    loop: 0.1,
+    timeline: [puff2(ORIGIN2, void 0, [variable("vx"), variable("vy"), variable("vz")], variable("radius"), variable("life"), variable("opacity"))]
+  };
+  var BACKBLAST = {
+    id: "launcher_backblast",
+    pageId: "event:launcher_backblast",
+    team: "weapons",
+    budget: { particles: 40 },
+    loop: 0.1,
+    timeline: [
+      repeat(26, puff2(ORIGIN2, [neg(add(1.5, mul(rand(), 3))), 0, 0], [wide(1.4), wide(0.8), wide(1.4)], add(0.03, mul(rand(), 0.03)), add(1.8, mul(rand(), 1.4)), 0.5)),
+      repeat(14, ...flameBit(ORIGIN2, [neg(add(2, mul(rand(), 2))), 0, 0], [wide(1), wide(0.6), wide(1)], 0.02, 0.25))
+    ]
+  };
+  var FLAME_JET = {
+    id: "flame_jet",
+    pageId: "event:flame_jet",
+    team: "weapons",
+    budget: { particles: 30 },
+    loop: 0.1,
+    timeline: [
+      repeat(
+        floor(mul(420, variable("dt"), variable("scale"))),
+        set("speed", mul(add(2.2, mul(rand(), 1.1)), variable("scale"))),
+        ...flameBit(
+          [mul(rand(), variable("speed"), min(variable("dt"), 0.3)), 0, 0],
+          [variable("speed"), 0, 0],
+          [wide(0.35), mul(sub(rand(), 0.3), 0.3), wide(0.35)],
+          add(0.02, mul(rand(), 0.022)),
+          add(0.4, mul(rand(), 0.35))
+        )
+      ),
+      when(lt(rand(), 0.5), [
+        puff2([add(mul(1.1, variable("scale")), mul(rand(), 0.4)), 0, 0], void 0, [mul(vx(DIRECTION), 0.6), 0.35, mul(vz(DIRECTION), 0.6)], 0.03, 1.6, 0.4)
+      ])
+    ]
+  };
+  var VIEWMODEL_EFFECTS = [MUZZLE_FLASH2, SMOKE_PUFF, BACKBLAST, FLAME_JET];
+  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.map((effect) => [effect.id, effect])) };
+  var GAME_EFFECTS = { ...WORKSHOP_EFFECTS, ...Object.fromEntries([...EVENT_EFFECTS, ...VIEWMODEL_EFFECTS].map((effect) => [effect.id, effect])) };
   var LEHMER_MULTIPLIER = 16807;
   var LEHMER_MODULUS = 2147483647;
   var HASH_MIX = 2654435761;
@@ -3313,7 +3683,7 @@ var GameVfxThree = (() => {
   }
   var COLUMNS = 6;
   var ROWS = 5;
-  var ORIGIN2 = [-2.2, 0, 2.6];
+  var ORIGIN3 = [-2.2, 0, 2.6];
   var BLOCK_SIZE = [0.5, 0.44, 0.25];
   var OBJECT_ID_DRAWS2 = 4;
   var FLOOR2 = 0.13;
@@ -3356,7 +3726,7 @@ var GameVfxThree = (() => {
           const chipScale = random.between(0.8, 1.3) * scale;
           for (let draw = 0; draw < OBJECT_ID_DRAWS2; draw++) random.next();
           best.holes.push({ x: offsetX, y: offsetY, scale, chipTurn, chipScale });
-          impact(host.engine, "concrete", [ORIGIN2[0] + x, y, ORIGIN2[2] + 0.13], [0, 0, 1], 0.8);
+          impact(host.engine, "concrete", [ORIGIN3[0] + x, y, ORIGIN3[2] + 0.13], [0, 0, 1], 0.8);
         } else if (action === "collapse") {
           const { x, y } = args;
           for (const block of blocks) {
@@ -3406,7 +3776,7 @@ var GameVfxThree = (() => {
       }
     };
   }
-  var ORIGIN3 = [5.6, 0, 0.8];
+  var ORIGIN4 = [5.6, 0, 0.8];
   var MAX_TILT = 0.25;
   function createCarBehavior() {
     let y = 0;
@@ -3438,8 +3808,13 @@ var GameVfxThree = (() => {
           }
         }
       },
-      query(_host, name) {
-        if (name === "position") return [ORIGIN3[0], y, ORIGIN3[2]];
+      query(_host, name, args) {
+        if (name === "position") return [ORIGIN4[0], y, ORIGIN4[2]];
+        if (name === "point") {
+          const [x, py, z] = args;
+          const point = carPoint(x, py, z);
+          return [point[0], point[1] + y, point[2]];
+        }
         if (name === "roll") return roll;
         throw new Error(`car: unknown query ${name}`);
       },
@@ -3639,6 +4014,29 @@ var GameVfxThree = (() => {
       }
     };
   }
+  function createRainBehavior() {
+    return {
+      reset() {
+      },
+      act(host, action, args) {
+        const { engine, camera: camera2 } = host;
+        if (action === "init") {
+          const { count, wind } = args;
+          engine.rain.init(count, wind);
+        } else if (action === "update") {
+          const { dt, splash } = args;
+          engine.rain.update(dt, splash, camera2.position);
+        }
+      },
+      query(host, name) {
+        if (name === "count") return host.engine.rain.count;
+        if (name === "on") return host.engine.rain.on;
+        throw new Error(`rain: unknown query ${name}`);
+      },
+      update() {
+      }
+    };
+  }
   var WALKER_COUNT = 10;
   var ARRIVAL_DISTANCE = 0.05;
   var SWAY_AMPLITUDE = 0.04;
@@ -3704,7 +4102,8 @@ var GameVfxThree = (() => {
     blocks: () => createBlocksBehavior(),
     plate: () => createPlateBehavior(),
     cylinder: () => createCylinderBehavior(),
-    car: () => createCarBehavior()
+    car: () => createCarBehavior(),
+    rain: () => createRainBehavior()
   };
   var NOOP = () => {
   };
@@ -3775,6 +4174,8 @@ var GameVfxThree = (() => {
         return Math.abs(asNumber(first));
       case "sqrt":
         return Math.sqrt(asNumber(first));
+      case "exp":
+        return Math.exp(asNumber(first));
       case "sin":
         return Math.sin(asNumber(first));
       case "cos":
@@ -3893,7 +4294,7 @@ var GameVfxThree = (() => {
         return evaluateCall(value.$, args.map((entry) => resolve(entry, context)));
     }
   }
-  var UP11 = [0, 1, 0];
+  var UP12 = [0, 1, 0];
   var ZERO = [0, 0, 0];
   var FULL_TURN_DRAWN = 6.283;
   function scaledSizes(range, factor) {
@@ -3906,7 +4307,7 @@ var GameVfxThree = (() => {
       p: centre,
       r: radius,
       flat: true,
-      dir: options.dir ?? UP11,
+      dir: options.dir ?? UP12,
       cone: 0.35,
       sp: [0.4, 1.4],
       v: wind,
@@ -3923,7 +4324,7 @@ var GameVfxThree = (() => {
       p: centre,
       r: radius * 0.6,
       flat: true,
-      dir: UP11,
+      dir: UP12,
       cone: 0.3,
       sp: [0.3, 0.8],
       life: [0.2, 0.4],
@@ -3938,14 +4339,14 @@ var GameVfxThree = (() => {
     if (engine.quality < 2) {
       engine.emit(`${key}e`, "streak", 10 * factor, dt, () => {
         const jitter = plus(wind, engine.random.between(-0.4, 0.4), 0, engine.random.between(-0.4, 0.4));
-        return { p: centre, box: [radius, 0, radius], dir: UP11, cone: 0.5, sp: [1.5, 3.5], v: jitter, life: [0.8, 1.8], len: 0.03, c0: 16756816, c1: 6295552, g: -0.6, drag: 0.4 };
+        return { p: centre, box: [radius, 0, radius], dir: UP12, cone: 0.5, sp: [1.5, 3.5], v: jitter, life: [0.8, 1.8], len: 0.03, c0: 16756816, c1: 6295552, g: -0.6, drag: 0.4 };
       });
     }
     if (options.noSmoke) return;
     engine.emit(`${key}s`, "normal", (options.smoke || 14) * factor, dt, () => ({
       p: plus(centre, 0, 0.8 * sqrtFactor, 0),
       r: radius * 0.7,
-      dir: UP11,
+      dir: UP12,
       cone: 0.35,
       sp: [0.6, 1.4],
       v: wind,
@@ -3985,15 +4386,15 @@ var GameVfxThree = (() => {
     engine.screen.shake += 0.7 * scale;
     engine.screen.white += 0.18 * scale;
     engine.burst("add", 55 * scale, { p: point, r: 0.3 * scale, sp: [2, 7 * scale], drag: 4, life: [0.25, 0.6], size: [0.7 * scale, 1.4 * scale], grow: 1.7, c0: 16773296, c1: 10103304, fi: 0.04 });
-    engine.burst("add", 28 * scale, { p: plus(point, 0, 0.3, 0), r: 0.3, dir: UP11, cone: 0.7, sp: [2, 5 * scale], drag: 1.5, life: [0.6, 1.1], size: [0.6 * scale, 1 * scale], grow: 1.3, c0: 16760928, c1: 5902853, g: -2, fi: 0.05 });
+    engine.burst("add", 28 * scale, { p: plus(point, 0, 0.3, 0), r: 0.3, dir: UP12, cone: 0.7, sp: [2, 5 * scale], drag: 1.5, life: [0.6, 1.1], size: [0.6 * scale, 1 * scale], grow: 1.3, c0: 16760928, c1: 5902853, g: -2, fi: 0.05 });
     engine.ring([plus(point, 0, 0.05, 0), 0.3, 7 * scale, 0.55, 16767136]);
     const toCamera = normalized([cameraPosition[0] - point[0], cameraPosition[1] - point[1], cameraPosition[2] - point[2]]);
     engine.ring([plus(point, 0, 1, 0), 0.3, 5 * scale, 0.35, 16773328, toCamera]);
-    engine.burst("normal", 32 * scale, { p: plus(point, 0, 0.6, 0), r: 0.8 * scale, dir: UP11, cone: 1.1, sp: [1, 3], drag: 1.2, life: [3, 6], size: [1 * scale, 1.8 * scale], grow: 2.6, c0: 2828068, c1: 987155, a: 0.6, fi: 0.18, g: -0.35 });
+    engine.burst("normal", 32 * scale, { p: plus(point, 0, 0.6, 0), r: 0.8 * scale, dir: UP12, cone: 1.1, sp: [1, 3], drag: 1.2, life: [3, 6], size: [1 * scale, 1.8 * scale], grow: 2.6, c0: 2828068, c1: 987155, a: 0.6, fi: 0.18, g: -0.35 });
     ringOfDust(engine, point, scale);
-    if (engine.quality < 2) engine.burst("streak", 44 * scale, { p: point, dir: UP11, cone: 1.45, sp: [10, 26], life: [0.3, 0.7], len: 0.03, c0: 16760944, c1: 8396800, g: 9.8, gnd: 2 });
+    if (engine.quality < 2) engine.burst("streak", 44 * scale, { p: point, dir: UP12, cone: 1.45, sp: [10, 26], life: [0.3, 0.7], len: 0.03, c0: 16760944, c1: 8396800, g: 9.8, gnd: 2 });
     for (let index = 0; index < engine.scaled(16 * scale); index++) {
-      engine.debrisPiece({ p: point, dir: UP11, cone: 1.2, sp: [3, 9], size: [0.12, 0.06, 0.1], k: [0.6, 1.6], c: chipColor || 2762274, life: 9 });
+      engine.debrisPiece({ p: point, dir: UP12, cone: 1.2, sp: [3, 9], size: [0.12, 0.06, 0.1], k: [0.6, 1.6], c: chipColor || 2762274, life: 9 });
     }
     engine.decal([point[0], engine.context.groundAt(point[0], point[2]), point[2], 3 * scale, 657930, { grow: 0.15, life: 60 }]);
   }
@@ -4136,6 +4537,7 @@ var GameVfxThree = (() => {
       if (!def) return;
       this.schedule.clear();
       this.variables.clear();
+      for (const [name, value] of Object.entries(this.setup.values ?? {})) this.variables.set(name, value);
       for (const behavior2 of this.deps.behaviors()) behavior2.reset(this.host);
       this.time = 0;
       this.within(() => {
@@ -4194,6 +4596,10 @@ var GameVfxThree = (() => {
           return engine.spawn(step.system, this.value(step.spawn));
         case "emit":
           return engine.emit(step.key, step.system, this.value(step.rate), this.dt, () => this.value(step.spawn));
+        case "mesh": {
+          engine.mesh(this.value(step.spawn));
+          return;
+        }
         case "debris":
           return engine.debrisPiece(this.value(step.spawn));
         case "decal":
@@ -4275,7 +4681,7 @@ var GameVfxThree = (() => {
       this.index = previous;
     }
   };
-  var ORIGIN4 = [0, 0, 0];
+  var ORIGIN5 = [0, 0, 0];
   var DEFAULT_HEADING = [0, 0, -1];
   var DEFAULT_MAX_INSTANCES = 48;
   var ENDLESS_SECONDS = 60;
@@ -4320,7 +4726,7 @@ var GameVfxThree = (() => {
     }
     function placementOf(entry) {
       const origin = entry.follow ? [entry.origin[0] + positionOf2(entry.follow)[0], entry.origin[1] + positionOf2(entry.follow)[1], entry.origin[2] + positionOf2(entry.follow)[2]] : entry.origin;
-      return { origin, anchor: entry.anchor, yaw: entry.yaw };
+      return { origin, anchor: entry.anchor, yaw: entry.yaw, ...entry.orientation ? { orientation: entry.orientation } : {} };
     }
     function drawing(entry, action) {
       const context = engine.context;
@@ -4344,8 +4750,9 @@ var GameVfxThree = (() => {
           random: playOptions.seed !== void 0 ? streamOf(playOptions.seed) : void 0,
           follow: playOptions.follow,
           origin: point,
-          anchor: def.anchor ?? ORIGIN4,
+          anchor: def.anchor ?? ORIGIN5,
           yaw: yawOf(heading, playOptions.direction),
+          orientation: playOptions.orientation,
           seconds: playOptions.seconds ?? (def.loop && def.loop > 0 ? def.loop : ENDLESS_SECONDS)
         };
         playing.push(entry);
@@ -4354,7 +4761,8 @@ var GameVfxThree = (() => {
           () => instance.begin(def, paramIndex(def, playOptions.param), {
             placement: placementOf(entry),
             ...playOptions.direction ? { direction: playOptions.direction } : {},
-            ...playOptions.normal ? { normal: playOptions.normal } : {}
+            ...playOptions.normal ? { normal: playOptions.normal } : {},
+            ...playOptions.values ? { values: playOptions.values } : {}
           })
         );
         return entry.handle;
@@ -4614,15 +5022,15 @@ var GameVfxThree = (() => {
     return shock;
   }
   function pushPuffs(puffs, shock, reach, dt, age) {
-    for (const puff2 of puffs) {
-      if (puff2.ring || puff2.t > PUSH_AGE_LIMIT) continue;
-      const dx = puff2.x - shock.x;
-      const dz = puff2.z - shock.z;
+    for (const puff3 of puffs) {
+      if (puff3.ring || puff3.t > PUSH_AGE_LIMIT) continue;
+      const dx = puff3.x - shock.x;
+      const dz = puff3.z - shock.z;
       const distance = Math.hypot(dx, dz) + 1e-3;
-      if (Math.abs(distance - reach) < PUSH_BAND && puff2.y < PUSH_CEILING) {
+      if (Math.abs(distance - reach) < PUSH_BAND && puff3.y < PUSH_CEILING) {
         const strength = 4 * dt * (1 - age);
-        puff2.vx += dx / distance * strength * 6;
-        puff2.vz += dz / distance * strength * 6;
+        puff3.vx += dx / distance * strength * 6;
+        puff3.vz += dz / distance * strength * 6;
       }
     }
   }
@@ -4922,10 +5330,10 @@ var GameVfxThree = (() => {
       const life = random.between(ring2.life * 0.75, ring2.life);
       const h0 = random.between(1, 1.25);
       const hl = random.between(0.9, 1.6);
-      const puff2 = addPuff(core, random, { x, y, z, s0: spec.radius * 0.2, s1, sg: spec.radius * 0.06, gk: 3, life, h0, hl, color, kind: 0 });
-      puff2.ring = ring2;
-      puff2.ph = random.next() * Math.PI * 2;
-      puff2.th = random.next() * Math.PI * 2;
+      const puff3 = addPuff(core, random, { x, y, z, s0: spec.radius * 0.2, s1, sg: spec.radius * 0.06, gk: 3, life, h0, hl, color, kind: 0 });
+      puff3.ring = ring2;
+      puff3.ph = random.next() * Math.PI * 2;
+      puff3.th = random.next() * Math.PI * 2;
     }
     const stemCount = Math.round((spec.stem || 18) * Math.max(lod, 0.4));
     for (let index = 0; index < stemCount; index++) {
@@ -5726,7 +6134,7 @@ var GameVfxThree = (() => {
   };
   var TWO_PI_ROUNDED = 6.2832;
   var WIDE_CONE = 3.1;
-  var UP12 = [0, 1, 0];
+  var UP13 = [0, 1, 0];
   function drawRange(random, range) {
     if (Array.isArray(range)) return random.between(range[0], range[1]);
     return range || 0;
@@ -5754,7 +6162,7 @@ var GameVfxThree = (() => {
   }
   function coneDirection(random, direction, cone, out) {
     if (cone >= WIDE_CONE) return randomUnit(random, out);
-    const [dx, dy, dz] = direction ?? UP12;
+    const [dx, dy, dz] = direction ?? UP13;
     const cosTilt = 1 - random.next() * (1 - Math.cos(cone));
     const sinTilt = Math.sqrt(1 - cosTilt * cosTilt);
     const phase = random.next() * TWO_PI_ROUNDED;
@@ -5874,12 +6282,12 @@ var GameVfxThree = (() => {
     }
   };
   var CAPACITY2 = 400;
-  var UP13 = [0, 1, 0];
+  var UP14 = [0, 1, 0];
   var DEFAULT_LIFE2 = 60;
   var DEFAULT_GROW = 1.2;
   var EVAPORATION = { fuel: [6, 5], water: [40, 20] };
   function createDecal() {
-    return { on: false, x: 0, y: 0, z: 0, sx: 0, sy: 0, t: 0, life: 0, grow: 0, color: 0, normal: UP13, fluid: void 0, dryColor: -1, dryAt: 0, dryTime: 0 };
+    return { on: false, x: 0, y: 0, z: 0, sx: 0, sy: 0, t: 0, life: 0, grow: 0, color: 0, normal: UP14, fluid: void 0, dryColor: -1, dryAt: 0, dryTime: 0 };
   }
   var DecalPool = class {
     constructor(context) {
@@ -5892,7 +6300,7 @@ var GameVfxThree = (() => {
       const random = this.context.random;
       const index = this.next++ % CAPACITY2;
       const decal2 = this.decals[index];
-      const normal = options.n ?? UP13;
+      const normal = options.n ?? UP14;
       random.between(0, 6.28);
       const offset = 4e-3 + index % 40 * 4e-4;
       decal2.on = true;
@@ -5933,6 +6341,94 @@ var GameVfxThree = (() => {
       }
     }
   };
+  var CAPACITY3 = 400;
+  var IDENTITY = [0, 0, 0, 1];
+  function multiply(a, b) {
+    const [ax, ay, az, aw] = a;
+    const [bx, by, bz, bw] = b;
+    return [aw * bx + ax * bw + ay * bz - az * by, aw * by - ax * bz + ay * bw + az * bx, aw * bz + ax * by - ay * bx + az * bw, aw * bw - ax * bx - ay * by - az * bz];
+  }
+  var aboutX = (angle) => [Math.sin(angle / 2), 0, 0, Math.cos(angle / 2)];
+  var MeshPool = class {
+    constructor(capacity = CAPACITY3) {
+      __publicField(this, "capacity", capacity);
+      __publicField(this, "particles", []);
+      __publicField(this, "serial", 0);
+    }
+    get count() {
+      return this.particles.length;
+    }
+    spawn(options, frame = IDENTITY) {
+      const velocity = options.v ?? [0, 0, 0];
+      const world = options.wv ?? [0, 0, 0];
+      const particle = {
+        id: ++this.serial,
+        shape: options.shape,
+        radius: options.r,
+        height: options.h ?? 0,
+        segments: options.seg ?? 0,
+        segments2: options.seg2 ?? 0,
+        color: options.c0,
+        additive: options.add === true,
+        lit: options.lit === true,
+        x: options.p[0],
+        y: options.p[1],
+        z: options.p[2],
+        frame: options.roll ? multiply(frame, aboutX(options.roll)) : frame,
+        at: options.at ?? [0, 0, 0],
+        rx: options.rot?.[0] ?? 0,
+        ry: options.rot?.[1] ?? 0,
+        rz: options.rot?.[2] ?? 0,
+        scale: 1,
+        opacity: options.a,
+        age: 0,
+        life: options.life,
+        vx: velocity[0] + world[0],
+        vy: velocity[1] + world[1],
+        vz: velocity[2] + world[2],
+        spin: options.spin ?? [0, 0, 0],
+        gravity: options.g ?? 0,
+        drag: options.drag ?? 0,
+        grow: options.grow ?? 0,
+        ramp: options.ramp,
+        fade: options.fade === true,
+        startOpacity: options.a
+      };
+      this.particles.push(particle);
+      if (this.particles.length > this.capacity) this.particles.shift();
+      return particle;
+    }
+    update(dt) {
+      const live = this.particles;
+      for (let index = 0; index < live.length; index++) {
+        const particle = live[index];
+        particle.age += dt;
+        if (particle.ramp ? particle.age >= particle.life : particle.age > particle.life) {
+          live.splice(index--, 1);
+          continue;
+        }
+        if (particle.fade) particle.opacity = Math.max(0, particle.startOpacity * (1 - particle.age / particle.life));
+        particle.vy -= particle.gravity * dt;
+        if (particle.drag) {
+          const keep = Math.max(0, 1 - particle.drag * dt);
+          particle.vx *= keep;
+          particle.vy *= keep;
+          particle.vz *= keep;
+        }
+        particle.x += particle.vx * dt;
+        particle.y += particle.vy * dt;
+        particle.z += particle.vz * dt;
+        particle.rx += particle.spin[0] * dt;
+        particle.ry += particle.spin[1] * dt;
+        particle.rz += particle.spin[2] * dt;
+        if (particle.grow) particle.scale *= 1 + particle.grow * dt;
+        if (particle.ramp) particle.scale = particle.ramp[0] + Math.min(1, particle.age / particle.life) * particle.ramp[1];
+      }
+    }
+    clear() {
+      this.particles.length = 0;
+    }
+  };
   var DEFAULT_FADE_IN = 0.1;
   var FLOATS_PER_VECTOR = 3;
   var BYTE_MAX2 = 255;
@@ -6222,11 +6718,11 @@ var GameVfxThree = (() => {
   };
   var RING_CAPACITY = 120;
   var LIGHT_CAPACITY = 4;
-  var UP14 = [0, 1, 0];
+  var UP15 = [0, 1, 0];
   var DEFAULT_LIGHT_DISTANCE = 14;
   var WaveRingPool = class {
     constructor() {
-      __publicField(this, "rings", Array.from({ length: RING_CAPACITY }, () => ({ on: false, point: UP14, from: 0, to: 0, t: 0, duration: 1, color: 0, normal: UP14, hold: 0 })));
+      __publicField(this, "rings", Array.from({ length: RING_CAPACITY }, () => ({ on: false, point: UP15, from: 0, to: 0, t: 0, duration: 1, color: 0, normal: UP15, hold: 0 })));
       __publicField(this, "count", 0);
       __publicField(this, "next", 0);
     }
@@ -6239,7 +6735,7 @@ var GameVfxThree = (() => {
       ring2.t = 0;
       ring2.duration = duration;
       ring2.color = color;
-      ring2.normal = normal ?? UP14;
+      ring2.normal = normal ?? UP15;
       ring2.hold = hold || 0;
     }
     clear() {
@@ -6259,7 +6755,7 @@ var GameVfxThree = (() => {
   var FlashLightPool = class {
     constructor(context) {
       __publicField(this, "context", context);
-      __publicField(this, "lights", Array.from({ length: LIGHT_CAPACITY }, () => ({ x: 0, y: 0, z: 0, color: 16760944, distance: DEFAULT_LIGHT_DISTANCE, peak: 0, duration: 1, t: 0, intensity: 0 })));
+      __publicField(this, "lights", Array.from({ length: LIGHT_CAPACITY }, () => ({ x: 0, y: 0, z: 0, color: 16760944, distance: DEFAULT_LIGHT_DISTANCE, peak: 0, duration: 1, t: 0, intensity: 0, steady: false })));
       __publicField(this, "fire", [
         { x: 0, y: 0, z: 0, intensity: 0 },
         { x: 0, y: 0, z: 0, intensity: 0 }
@@ -6269,7 +6765,7 @@ var GameVfxThree = (() => {
     get lit() {
       return this.lights.filter((light) => light.intensity > 0).length;
     }
-    flash(point, color, intensity, duration, distance, force) {
+    flash(point, color, intensity, duration, distance, force, steady) {
       const { level } = this.context.quality;
       if (level >= 1 && !force) return;
       if (level >= 2 && force !== "boom") return;
@@ -6282,6 +6778,7 @@ var GameVfxThree = (() => {
       light.peak = intensity;
       light.duration = duration;
       light.t = 0;
+      light.steady = steady === true;
       light.intensity = intensity;
     }
     clear() {
@@ -6293,7 +6790,7 @@ var GameVfxThree = (() => {
         if (light.intensity <= 0) continue;
         light.t += dt;
         const age = light.t / light.duration;
-        light.intensity = age >= 1 ? 0 : light.peak * (1 - age) * (1 - age);
+        light.intensity = age >= 1 ? 0 : light.steady ? light.peak : light.peak * (1 - age) * (1 - age);
       }
     }
   };
@@ -6301,6 +6798,14 @@ var GameVfxThree = (() => {
   var FIRE_FLICKER_SWAY = 0.25;
   var FIRE_FLICKER_JITTER = 0.08;
   var LENS_FADE = 0.16;
+  function rotate(q, v) {
+    const [qx, qy, qz, qw] = q;
+    const ix = qw * v[0] + qy * v[2] - qz * v[1];
+    const iy = qw * v[1] + qz * v[0] - qx * v[2];
+    const iz = qw * v[2] + qx * v[1] - qy * v[0];
+    const iw = -qx * v[0] - qy * v[1] - qz * v[2];
+    return [ix * qw + iw * -qx + iy * -qz - iz * -qy, iy * qw + iw * -qy + iz * -qx - ix * -qz, iz * qw + iw * -qz + ix * -qy - iy * -qx];
+  }
   function workshopGround(x, z) {
     return z < -2.9 && z > -4.5 && Math.abs(x) < 13 ? 0.12 : 0;
   }
@@ -6314,6 +6819,8 @@ var GameVfxThree = (() => {
       __publicField(this, "decals");
       __publicField(this, "rings", new WaveRingPool());
       __publicField(this, "lights");
+      __publicField(this, "rain", new RainField(this));
+      __publicField(this, "meshes", new MeshPool());
       __publicField(this, "screen", createScreenState());
       __publicField(this, "lens", []);
       __publicField(this, "post", {});
@@ -6346,7 +6853,11 @@ var GameVfxThree = (() => {
     place(point) {
       const placement = this.placement;
       if (!placement) return point;
-      const { anchor, origin, yaw } = placement;
+      const { anchor, origin, yaw, orientation } = placement;
+      if (orientation) {
+        const turned = rotate(orientation, [point[0] - anchor[0], point[1] - anchor[1], point[2] - anchor[2]]);
+        return [origin[0] + turned[0], origin[1] + turned[1], origin[2] + turned[2]];
+      }
       const x = point[0] - anchor[0];
       const z = point[2] - anchor[2];
       const cos2 = Math.cos(yaw);
@@ -6357,6 +6868,7 @@ var GameVfxThree = (() => {
     turn(vector) {
       const placement = this.placement;
       if (!placement) return vector;
+      if (placement.orientation) return rotate(placement.orientation, vector);
       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]];
@@ -6385,6 +6897,14 @@ var GameVfxThree = (() => {
       }
       this.accumulators.set(key, carried);
     }
+    /** A solid particle (a cone, a sphere): the group sits at `p` turned by the placement, `v` is turned with it and `wv` is not. */
+    mesh(recipe) {
+      const placement = this.placement;
+      const options = placement ? { ...recipe, p: this.place(recipe.p), ...recipe.v ? { v: this.turn(recipe.v) } : {} } : recipe;
+      this.context.trace?.("mesh", [options]);
+      const grouped = recipe.at !== void 0 || recipe.roll !== void 0;
+      return this.meshes.spawn(options, placement && grouped ? placement.orientation ?? [0, Math.sin(placement.yaw / 2), 0, Math.cos(placement.yaw / 2)] : void 0);
+    }
     debrisPiece(recipe) {
       const options = this.placed(recipe);
       this.context.trace?.("debris", [options]);
@@ -6405,10 +6925,11 @@ var GameVfxThree = (() => {
       this.context.trace?.("ring", args);
       this.rings.add(args[0], args[1], args[2], args[3], args[4], args[5], args[6]);
     }
+    /** `steady` (a seventh number): the light holds its intensity for its duration and goes out, where the Workshop's fades with the square of its age. */
     flash(recipe) {
-      const args = this.placement ? [this.place(recipe[0]), recipe[1], recipe[2], recipe[3], recipe[4], recipe[5]] : recipe;
-      this.context.trace?.("flash", args);
-      this.lights.flash(args[0], args[1], args[2], args[3], args[4], args[5]);
+      const args = this.placement ? [this.place(recipe[0]), recipe[1], recipe[2], recipe[3], recipe[4], recipe[5], recipe[6]] : recipe;
+      this.context.trace?.("flash", args.slice(0, 6));
+      this.lights.flash(args[0], args[1], args[2], args[3], args[4], args[5], args[6]);
     }
     /** `fireLight` (W400): sways with the clock and flickers with one draw. */
     fireLight(slot, recipe, intensity, time) {
@@ -6433,6 +6954,7 @@ var GameVfxThree = (() => {
       this.debris.update(dt);
       this.decals.update(dt);
       this.rings.update(dt);
+      this.meshes.update(dt);
       this.lights.update(dt);
       updateScreen(this.screen, dt);
       for (let index = this.lens.length - 1; index >= 0; index--) {
@@ -6449,7 +6971,9 @@ var GameVfxThree = (() => {
       this.debris.clear();
       this.decals.clear();
       this.rings.clear();
+      this.meshes.clear();
       this.lights.clear();
+      this.rain.clear();
       this.accumulators.clear();
       resetScreenState(this.screen);
       this.lens.length = 0;
@@ -6595,16 +7119,16 @@ var GameVfxThree = (() => {
       },
       push(point, radius, speed) {
         spriteSystem.push(point, radius, speed);
-        for (const puff2 of core.puffs.items) {
-          const dx = puff2.x - point[0];
-          const dy = puff2.y - point[1];
-          const dz = puff2.z - point[2];
+        for (const puff3 of core.puffs.items) {
+          const dx = puff3.x - point[0];
+          const dy = puff3.y - point[1];
+          const dz = puff3.z - point[2];
           const distance = Math.sqrt(dx * dx + dy * dy + dz * dz);
           if (distance >= radius) continue;
           const strength = speed * (1 - distance / radius) / (distance + 1e-3);
-          puff2.vx += dx * strength;
-          puff2.vy += dy * strength;
-          puff2.vz += dz * strength;
+          puff3.vx += dx * strength;
+          puff3.vy += dy * strength;
+          puff3.vz += dz * strength;
         }
       },
       stop(handle) {
@@ -6621,6 +7145,12 @@ var GameVfxThree = (() => {
         camera2.y = position[1];
         camera2.z = position[2];
       },
+      setWind(next) {
+        wind.x = next[0];
+        wind.y = next[1];
+        wind.z = next[2];
+      },
+      wind: () => [wind.x, wind.y, wind.z],
       forceLod(scale) {
         core.clock.forcedLod = scale;
       },
@@ -6950,6 +7480,27 @@ var GameVfxThree = (() => {
       budget: "Up to 600 particles per building and 2 fire lights. Beyond 80 m only the smoke column and the glow of the windows remain, which become a landmark.",
       network: "A fire entity on the server per building, with a spread state."
     },
+    rain_and_puddles: {
+      name: "Rain, splashes and puddles",
+      short: "Drops with wind, splashes and rings only near the camera, lightning in the storm.",
+      cost: "\u2264 4,000 drops",
+      costNote: "splash up to 12 m",
+      paramLabel: "Intensity",
+      when: "The weather of the world. Rain raises the background noise and masks footsteps (it can be used for stealth).",
+      look: "A fine drizzle, almost vertical. Rain with splashes on the asphalt and rings in the puddles, which are dark and mirror-like. A storm with drops slanted by the wind, sheets of water passing and a double flash of lightning that lights the scene for 0.2 s and reveals the horde.",
+      budget: "Up to 4,000 drops tied to the camera in a 30 m box. Splashes and rings only within 12 m and only on what the camera sees.",
+      network: "The server sends the weather and the lightning seed, so everyone sees the same flash."
+    },
+    fog_and_ash: {
+      name: "Fog and ash",
+      short: "Low layered mist, ash falling and the lamp post with its cone of light.",
+      cost: "\u2264 120 sprites",
+      costNote: "1 cone of light",
+      when: "Before dawn, near the river and in burnt zones (ash). It cuts the sight of the zombies and of the player.",
+      look: "The engine fog plus a layer of low mist that moves slowly, fine ash falling in a spiral and the beam of the lamp posts in view. Zombie silhouettes show before their details.",
+      budget: "Up to 60 large mist sprites (half resolution) and 60 of ash. The lamp cone is an additive mesh, not real volumetric light.",
+      network: "The weather comes from the server. The density is local, by zone."
+    },
     scraping_sparks: {
       name: "Scraping sparks",
       short: "A bumper dragging on the asphalt: a river of bouncing sparks and a mark on the ground.",
@@ -7001,6 +7552,16 @@ var GameVfxThree = (() => {
       budget: "Texture only: a crack mask with 4 stages and a blood decal on the glass. Glass dust: 6 particles per blow.",
       network: "The server sends the glass health. Blood on the glass is local."
     },
+    headlights_in_rain: {
+      name: "Headlights in the rain",
+      short: "A visible beam, drops lit inside the cone and the horde walking into the light.",
+      cost: "\u2264 600 lit drops",
+      costNote: "2 spots, no shadow",
+      when: "Headlights on at night, with rain or fog.",
+      look: "Two cones of light in the air, rain drops that shine only inside the beam and zombie silhouettes that light up when they enter the light. Outside the cone the rain almost disappears.",
+      budget: "2 spotlights without shadow, 2 additive cones and up to 600 extra drops only inside the cone. Headlights of cars beyond 40 m stay as a cone only, with no real light.",
+      network: "The state of the headlights is already replicated with the car."
+    },
     damage_and_bite: {
       name: "Damage and bite",
       short: "A red edge on the side of the blow, blood on the lens and the pulse of the bite.",
@@ -7318,6 +7879,27 @@ var GameVfxThree = (() => {
       budget: "At\xE9 600 part\xEDculas por pr\xE9dio e 2 luzes de fogo. Al\xE9m de 80 m fica s\xF3 a coluna de fuma\xE7a e o brilho das janelas, que viram ponto de refer\xEAncia.",
       network: "Entidade de fogo no servidor por pr\xE9dio, com estado de espalhar."
     },
+    rain_and_puddles: {
+      name: "Chuva, respingos e po\xE7as",
+      short: "Gotas com vento, respingos e an\xE9is s\xF3 perto da c\xE2mera, rel\xE2mpago no temporal.",
+      cost: "\u2264 4.000 gotas",
+      costNote: "respingo at\xE9 12 m",
+      paramLabel: "Intensidade",
+      when: "Clima do mundo. Chuva aumenta o ru\xEDdo de fundo e mascara passos (d\xE1 para usar na furtividade).",
+      look: "Garoa fina quase vertical. Chuva com respingos no asfalto e an\xE9is nas po\xE7as, que ficam escuras e espelhadas. Temporal com gotas inclinadas pelo vento, cortinas de \xE1gua passando e rel\xE2mpago duplo que clareia a cena por 0,2 s e revela a horda.",
+      budget: "At\xE9 4.000 gotas presas \xE0 c\xE2mera numa caixa de 30 m. Respingos e an\xE9is s\xF3 a menos de 12 m e s\xF3 em cima do que a c\xE2mera v\xEA.",
+      network: "O servidor manda o clima e a semente do rel\xE2mpago, para todos verem o mesmo clar\xE3o."
+    },
+    fog_and_ash: {
+      name: "Neblina e cinzas",
+      short: "N\xE9voa rasteira em camadas, cinza caindo e o poste com cone de luz.",
+      cost: "\u2264 120 sprites",
+      costNote: "1 cone de luz",
+      when: "Madrugada, perto de rio e em zonas queimadas (cinza). Reduz a vis\xE3o dos zumbis e do jogador.",
+      look: "Neblina do motor mais uma camada de n\xE9voa baixa que se move devagar, cinza fina caindo em espiral e o feixe dos postes vis\xEDvel. Silhuetas de zumbis aparecem antes dos detalhes.",
+      budget: "At\xE9 60 sprites grandes de n\xE9voa (meia resolu\xE7\xE3o) e 60 de cinza. O cone do poste \xE9 uma malha aditiva, n\xE3o luz volum\xE9trica real.",
+      network: "Clima vem do servidor. Densidade \xE9 local por zona."
+    },
     scraping_sparks: {
       name: "Fa\xEDscas de raspagem",
       short: "Para-choque arrastando no asfalto: rio de fa\xEDscas que quicam e marca no ch\xE3o.",
@@ -7369,6 +7951,16 @@ var GameVfxThree = (() => {
       budget: "S\xF3 textura: uma m\xE1scara de rachadura com 4 est\xE1gios e um decal de sangue no vidro. P\xF3 de vidro: 6 part\xEDculas por golpe.",
       network: "O servidor manda a vida do vidro. Sangue no vidro \xE9 local."
     },
+    headlights_in_rain: {
+      name: "Far\xF3is na chuva",
+      short: "Feixe vis\xEDvel, gotas acesas dentro do cone e a horda entrando na luz.",
+      cost: "\u2264 600 gotas acesas",
+      costNote: "2 spots sem sombra",
+      when: "Far\xF3is ligados \xE0 noite, com chuva ou neblina.",
+      look: "Dois cones de luz vis\xEDveis no ar, gotas de chuva que brilham s\xF3 dentro do feixe e silhuetas de zumbi que acendem quando entram na luz. Fora do cone, a chuva quase some.",
+      budget: "2 spotlights sem sombra, 2 cones aditivos e at\xE9 600 gotas extras s\xF3 dentro do cone. Far\xF3is de carros a mais de 40 m ficam s\xF3 como cone, sem luz real.",
+      network: "Estado do farol j\xE1 \xE9 replicado com o carro."
+    },
     damage_and_bite: {
       name: "Dano e mordida",
       short: "Borda vermelha do lado do golpe, sangue na lente e o pulso da mordida.",
@@ -7559,11 +8151,11 @@ void main(){
     geometry.setAttribute("aC", attributes[2]);
     geometry.instanceCount = 0;
     const material = new THREE.ShaderMaterial({ uniforms, vertexShader: PUFF_VERTEX, fragmentShader: PUFF_FRAGMENT });
-    const mesh = new THREE.Mesh(geometry, material);
-    mesh.name = "vfx-puffs";
-    mesh.frustumCulled = false;
+    const mesh2 = new THREE.Mesh(geometry, material);
+    mesh2.name = "vfx-puffs";
+    mesh2.frustumCulled = false;
     return {
-      mesh,
+      mesh: mesh2,
       sync() {
         let n = 0;
         for (const p of pool.items) {
@@ -7604,12 +8196,12 @@ void main(){
     geometry.setAttribute("aE", attributes[2]);
     geometry.instanceCount = 0;
     const material = new THREE.ShaderMaterial({ transparent: true, depthWrite: false, blending: THREE.AdditiveBlending, vertexShader: SPARK_VERTEX, fragmentShader: SPARK_FRAGMENT });
-    const mesh = new THREE.Mesh(geometry, material);
-    mesh.name = "vfx-sparks";
-    mesh.frustumCulled = false;
-    mesh.renderOrder = 5;
+    const mesh2 = new THREE.Mesh(geometry, material);
+    mesh2.name = "vfx-sparks";
+    mesh2.frustumCulled = false;
+    mesh2.renderOrder = 5;
     return {
-      mesh,
+      mesh: mesh2,
       sync() {
         let n = 0;
         for (const s of pool.items) {
@@ -7647,12 +8239,12 @@ void main(){
     geometry.setAttribute("aC", attributes[1]);
     geometry.instanceCount = 0;
     const material = new THREE.ShaderMaterial({ transparent: true, depthWrite: false, blending: THREE.AdditiveBlending, vertexShader: GLOW_VERTEX, fragmentShader: GLOW_FRAGMENT });
-    const mesh = new THREE.Mesh(geometry, material);
-    mesh.name = "vfx-glows";
-    mesh.frustumCulled = false;
-    mesh.renderOrder = 6;
+    const mesh2 = new THREE.Mesh(geometry, material);
+    mesh2.name = "vfx-glows";
+    mesh2.frustumCulled = false;
+    mesh2.renderOrder = 6;
     return {
-      mesh,
+      mesh: mesh2,
       sync() {
         let n = 0;
         for (const g of pool.items) {
@@ -7681,14 +8273,14 @@ void main(){
     const rockMaterial = new THREE.MeshStandardMaterial({ color: 16777215, roughness: 0.85, flatShading: true });
     const plateMaterial = rockMaterial.clone();
     const make = (geometry, material) => {
-      const mesh = new THREE.InstancedMesh(geometry, material, capacity);
-      mesh.instanceMatrix.setUsage(THREE.DynamicDrawUsage);
-      mesh.castShadow = true;
-      mesh.receiveShadow = true;
-      mesh.frustumCulled = false;
-      mesh.count = 0;
-      mesh.setColorAt(0, new THREE.Color(1, 1, 1));
-      return mesh;
+      const mesh2 = new THREE.InstancedMesh(geometry, material, capacity);
+      mesh2.instanceMatrix.setUsage(THREE.DynamicDrawUsage);
+      mesh2.castShadow = true;
+      mesh2.receiveShadow = true;
+      mesh2.frustumCulled = false;
+      mesh2.count = 0;
+      mesh2.setColorAt(0, new THREE.Color(1, 1, 1));
+      return mesh2;
     };
     const rocks = make(shapes.rock, rockMaterial);
     const plates = make(shapes.plate, plateMaterial);
@@ -7707,20 +8299,20 @@ void main(){
           euler.set(chunk.rx, chunk.ry, chunk.rz);
           quaternion.setFromEuler(euler);
           matrix.compose(position.set(chunk.x, chunk.y, chunk.z), quaternion, scale.set(chunk.sx, chunk.sy, chunk.sz));
-          const mesh = chunk.plate ? plates : rocks;
+          const mesh2 = chunk.plate ? plates : rocks;
           const index = chunk.plate ? plateCount++ : rockCount++;
-          mesh.setMatrixAt(index, matrix);
+          mesh2.setMatrixAt(index, matrix);
           const color = colorOf(chunk);
-          const colors = mesh.instanceColor.array;
+          const colors = mesh2.instanceColor.array;
           colors[index * 3] = color[0];
           colors[index * 3 + 1] = color[1];
           colors[index * 3 + 2] = color[2];
         }
         rocks.count = rockCount;
         plates.count = plateCount;
-        for (const mesh of [rocks, plates]) {
-          mesh.instanceMatrix.needsUpdate = true;
-          mesh.instanceColor.needsUpdate = true;
+        for (const mesh2 of [rocks, plates]) {
+          mesh2.instanceMatrix.needsUpdate = true;
+          mesh2.instanceColor.needsUpdate = true;
         }
         return rockCount + plateCount;
       },
@@ -7910,28 +8502,28 @@ void main(){
         position.setXYZ(index, worldX, (options.ground?.heightAt(worldX, worldZ) ?? 0) + mark.lift, worldZ);
       }
       geometry.computeVertexNormals();
-      const mesh = new THREE.Mesh(geometry, material);
-      mesh.receiveShadow = true;
-      return mesh;
+      const mesh2 = new THREE.Mesh(geometry, material);
+      mesh2.receiveShadow = true;
+      return mesh2;
     }
     function addRock(mark) {
-      const mesh = new THREE.Mesh(mark.plate ? options.plateGeometry : options.rockGeometry, rockMaterial(mark.color));
-      mesh.position.set(mark.x, mark.y, mark.z);
-      mesh.scale.set(mark.scale[0], mark.scale[1], mark.scale[2]);
-      mesh.rotation.set(mark.rotation[0], mark.rotation[1], mark.rotation[2]);
-      mesh.castShadow = true;
-      mesh.receiveShadow = true;
-      return mesh;
+      const mesh2 = new THREE.Mesh(mark.plate ? options.plateGeometry : options.rockGeometry, rockMaterial(mark.color));
+      mesh2.position.set(mark.x, mark.y, mark.z);
+      mesh2.scale.set(mark.scale[0], mark.scale[1], mark.scale[2]);
+      mesh2.rotation.set(mark.rotation[0], mark.rotation[1], mark.rotation[2]);
+      mesh2.castShadow = true;
+      mesh2.receiveShadow = true;
+      return mesh2;
     }
     function addBlood(mark) {
-      const mesh = new THREE.Mesh(bloodGeometry, bloodMaterial);
-      mesh.position.set(mark.x, mark.y, mark.z);
-      mesh.scale.set(mark.scaleX, 1, mark.scaleZ);
-      mesh.rotation.y = mark.rotation;
-      mesh.receiveShadow = true;
-      mesh.scale.multiplyScalar(0.05);
-      blood.push({ mesh, scaleX: mark.scaleX, scaleZ: mark.scaleZ, age: 0 });
-      return mesh;
+      const mesh2 = new THREE.Mesh(bloodGeometry, bloodMaterial);
+      mesh2.position.set(mark.x, mark.y, mark.z);
+      mesh2.scale.set(mark.scaleX, 1, mark.scaleZ);
+      mesh2.rotation.y = mark.rotation;
+      mesh2.receiveShadow = true;
+      mesh2.scale.multiplyScalar(0.05);
+      blood.push({ mesh: mesh2, scaleX: mark.scaleX, scaleZ: mark.scaleZ, age: 0 });
+      return mesh2;
     }
     function build(mark) {
       if (mark.kind === "scorch") return conform(mark, scorchMaterials[mark.variant]);
@@ -8153,6 +8745,75 @@ void main() {
     };
   }
 
+  // src/mesh-layer.ts
+  var SPHERE_DEFAULT_WIDTH = 8;
+  var SPHERE_DEFAULT_HEIGHT = 6;
+  function geometryOf(THREE, particle) {
+    switch (particle.shape) {
+      case "cone":
+        return new THREE.ConeGeometry(particle.radius, particle.height, particle.segments || void 0, particle.segments2 || 1, false);
+      case "cone_open":
+        return new THREE.ConeGeometry(particle.radius, particle.height, particle.segments || void 0, particle.segments2 || 1, true);
+      case "sphere":
+        return new THREE.SphereGeometry(particle.radius, particle.segments || SPHERE_DEFAULT_WIDTH, particle.segments2 || SPHERE_DEFAULT_HEIGHT);
+      case "icosahedron":
+        return new THREE.IcosahedronGeometry(particle.radius, particle.segments);
+    }
+  }
+  function materialOf(THREE, particle) {
+    if (particle.lit) return new THREE.MeshStandardMaterial({ color: particle.color, roughness: 1, metalness: 0, transparent: true, opacity: particle.opacity, depthWrite: false });
+    return new THREE.MeshBasicMaterial({ color: particle.color, transparent: true, opacity: particle.opacity, depthWrite: false, ...particle.additive ? { blending: THREE.AdditiveBlending } : {} });
+  }
+  function createMeshLayer(THREE, pool) {
+    const group = new THREE.Group();
+    group.name = "workshop-meshes";
+    const drawn = /* @__PURE__ */ new Map();
+    const frame = new THREE.Quaternion();
+    const euler = new THREE.Euler();
+    const turn = new THREE.Quaternion();
+    const offset = new THREE.Vector3();
+    function release(mesh2) {
+      mesh2.removeFromParent();
+      mesh2.geometry.dispose();
+      mesh2.material.dispose();
+    }
+    return {
+      group,
+      sync() {
+        const live = /* @__PURE__ */ new Set();
+        for (const particle of pool.particles) {
+          live.add(particle.id);
+          let mesh2 = drawn.get(particle.id);
+          if (!mesh2) {
+            mesh2 = new THREE.Mesh(geometryOf(THREE, particle), materialOf(THREE, particle));
+            mesh2.frustumCulled = false;
+            mesh2.renderOrder = particle.additive ? 5 : 3;
+            drawn.set(particle.id, mesh2);
+            group.add(mesh2);
+          }
+          frame.set(particle.frame[0], particle.frame[1], particle.frame[2], particle.frame[3]);
+          offset.set(particle.at[0], particle.at[1], particle.at[2]).multiplyScalar(particle.scale).applyQuaternion(frame);
+          mesh2.position.set(particle.x + offset.x, particle.y + offset.y, particle.z + offset.z);
+          turn.setFromEuler(euler.set(particle.rx, particle.ry, particle.rz));
+          mesh2.quaternion.copy(frame).multiply(turn);
+          mesh2.scale.setScalar(particle.scale);
+          mesh2.material.opacity = particle.opacity;
+        }
+        for (const [id, mesh2] of drawn) {
+          if (live.has(id)) continue;
+          release(mesh2);
+          drawn.delete(id);
+        }
+        return pool.count;
+      },
+      dispose() {
+        for (const mesh2 of drawn.values()) release(mesh2);
+        drawn.clear();
+        group.removeFromParent();
+      }
+    };
+  }
+
   // src/shaders/workshop-sprite.ts
   var WORKSHOP_SPRITE_VERTEX = `attribute float size;attribute float alpha;attribute vec3 pcol;varying vec3 vC;varying float vA;uniform float uScale;
 void main(){vC=pcol;vA=alpha;vec4 mv=modelViewMatrix*vec4(position,1.);gl_PointSize=clamp(size*uScale/-mv.z,1.,512.);gl_Position=projectionMatrix*mv;}`;
@@ -8231,13 +8892,37 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       }
     };
   }
+  function rainLayer(THREE, rain) {
+    const geometry = new THREE.BufferGeometry();
+    const position = new THREE.BufferAttribute(rain.positions, 3).setUsage(THREE.DynamicDrawUsage);
+    geometry.setAttribute("position", position);
+    geometry.setDrawRange(0, 0);
+    const material = new THREE.LineBasicMaterial({ color: 10466255, transparent: true, opacity: 0.35, depthWrite: false });
+    const lines = new THREE.LineSegments(geometry, material);
+    lines.frustumCulled = false;
+    lines.name = "workshop-rain";
+    return {
+      object: lines,
+      sync() {
+        const drawn = rain.on && rain.count > 0;
+        lines.visible = drawn;
+        geometry.setDrawRange(0, drawn ? rain.count * 2 : 0);
+        position.needsUpdate = true;
+        return drawn;
+      },
+      dispose() {
+        geometry.dispose();
+        material.dispose();
+      }
+    };
+  }
   function debrisLayer(THREE, pool) {
     const geometry = new THREE.BoxGeometry(1, 1, 1);
     const material = new THREE.MeshStandardMaterial({ color: 16777215, roughness: 0.45, metalness: 0.25, flatShading: true });
-    const mesh = new THREE.InstancedMesh(geometry, material, DEBRIS_CAPACITY);
-    mesh.instanceMatrix.setUsage(THREE.DynamicDrawUsage);
-    mesh.frustumCulled = false;
-    mesh.name = "workshop-debris";
+    const mesh2 = new THREE.InstancedMesh(geometry, material, DEBRIS_CAPACITY);
+    mesh2.instanceMatrix.setUsage(THREE.DynamicDrawUsage);
+    mesh2.frustumCulled = false;
+    mesh2.name = "workshop-debris";
     const euler = new THREE.Euler();
     const quaternion = new THREE.Quaternion();
     const position = new THREE.Vector3();
@@ -8245,16 +8930,16 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     const matrix = new THREE.Matrix4();
     const colour = new THREE.Color();
     const hidden = new THREE.Matrix4().makeScale(0, 0, 0);
-    for (let index = 0; index < DEBRIS_CAPACITY; index++) mesh.setMatrixAt(index, hidden);
-    mesh.setColorAt(0, colour.setHex(16777215));
+    for (let index = 0; index < DEBRIS_CAPACITY; index++) mesh2.setMatrixAt(index, hidden);
+    mesh2.setColorAt(0, colour.setHex(16777215));
     return {
-      object: mesh,
+      object: mesh2,
       sync() {
         let drawn = false;
         for (let index = 0; index < DEBRIS_CAPACITY; index++) {
           const piece = pool.pieces[index];
           if (!piece.on) {
-            mesh.setMatrixAt(index, hidden);
+            mesh2.setMatrixAt(index, hidden);
             continue;
           }
           drawn = true;
@@ -8262,11 +8947,11 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
           euler.set(piece.rx, piece.ry, piece.rz);
           quaternion.setFromEuler(euler);
           matrix.compose(position.set(piece.x, piece.y, piece.z), quaternion, scale.set(piece.sx * shrink, piece.sy * shrink, piece.sz * shrink));
-          mesh.setMatrixAt(index, matrix);
-          mesh.setColorAt(index, colour.setHex(piece.color));
+          mesh2.setMatrixAt(index, matrix);
+          mesh2.setColorAt(index, colour.setHex(piece.color));
         }
-        mesh.instanceMatrix.needsUpdate = true;
-        if (mesh.instanceColor) mesh.instanceColor.needsUpdate = true;
+        mesh2.instanceMatrix.needsUpdate = true;
+        if (mesh2.instanceColor) mesh2.instanceColor.needsUpdate = true;
         return drawn;
       },
       dispose() {
@@ -8323,11 +9008,11 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     const dryMesh = new THREE.InstancedMesh(geometry, dry, DECAL_CAPACITY);
     const group = new THREE.Group();
     group.name = "workshop-decals";
-    for (const mesh of [wetMesh, dryMesh]) {
-      mesh.frustumCulled = false;
-      mesh.renderOrder = 1;
-      mesh.instanceMatrix.setUsage(THREE.DynamicDrawUsage);
-      group.add(mesh);
+    for (const mesh2 of [wetMesh, dryMesh]) {
+      mesh2.frustumCulled = false;
+      mesh2.renderOrder = 1;
+      mesh2.instanceMatrix.setUsage(THREE.DynamicDrawUsage);
+      group.add(mesh2);
     }
     const hidden = new THREE.Matrix4().makeScale(0, 0, 0);
     const colour = new THREE.Color();
@@ -8364,13 +9049,13 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
           quaternion.multiply(turn.setFromAxisAngle(forward, index * 2.399963));
           const offset = 4e-3 + index % 40 * 4e-4;
           matrix.compose(position.set(decal2.x + normal.x * offset, decal2.y + normal.y * offset, decal2.z + normal.z * offset), quaternion, scale.set(look.sx, look.sy, 1));
-          const mesh = look.dried ? dryMesh : wetMesh;
-          mesh.setMatrixAt(index, matrix);
-          mesh.setColorAt(index, colour);
+          const mesh2 = look.dried ? dryMesh : wetMesh;
+          mesh2.setMatrixAt(index, matrix);
+          mesh2.setColorAt(index, colour);
         }
-        for (const mesh of [wetMesh, dryMesh]) {
-          mesh.instanceMatrix.needsUpdate = true;
-          if (mesh.instanceColor) mesh.instanceColor.needsUpdate = true;
+        for (const mesh2 of [wetMesh, dryMesh]) {
+          mesh2.instanceMatrix.needsUpdate = true;
+          if (mesh2.instanceColor) mesh2.instanceColor.needsUpdate = true;
         }
         return drawn;
       },
@@ -8384,10 +9069,10 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
   function ringLayer(THREE, pool) {
     const geometry = new THREE.RingGeometry(0.86, 1, 40);
     const material = new THREE.MeshBasicMaterial({ color: 16777215, transparent: true, blending: THREE.AdditiveBlending, depthWrite: false, side: THREE.DoubleSide });
-    const mesh = new THREE.InstancedMesh(geometry, material, RING_CAPACITY3);
-    mesh.frustumCulled = false;
-    mesh.instanceMatrix.setUsage(THREE.DynamicDrawUsage);
-    mesh.name = "workshop-rings";
+    const mesh2 = new THREE.InstancedMesh(geometry, material, RING_CAPACITY3);
+    mesh2.frustumCulled = false;
+    mesh2.instanceMatrix.setUsage(THREE.DynamicDrawUsage);
+    mesh2.name = "workshop-rings";
     const hidden = new THREE.Matrix4().makeScale(0, 0, 0);
     const colour = new THREE.Color();
     const normal = new THREE.Vector3();
@@ -8396,16 +9081,16 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     const position = new THREE.Vector3();
     const scale = new THREE.Vector3();
     const matrix = new THREE.Matrix4();
-    mesh.setColorAt(0, colour.setHex(0));
-    for (let index = 0; index < RING_CAPACITY3; index++) mesh.setMatrixAt(index, hidden);
+    mesh2.setColorAt(0, colour.setHex(0));
+    for (let index = 0; index < RING_CAPACITY3; index++) mesh2.setMatrixAt(index, hidden);
     return {
-      object: mesh,
+      object: mesh2,
       sync() {
         let drawn = false;
         for (let index = 0; index < RING_CAPACITY3; index++) {
           const ring2 = pool.rings[index];
           if (!ring2.on) {
-            mesh.setMatrixAt(index, hidden);
+            mesh2.setMatrixAt(index, hidden);
             continue;
           }
           drawn = true;
@@ -8413,11 +9098,11 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
           const radius = ring2.from + (ring2.to - ring2.from) * (1 - Math.pow(1 - k, 2));
           quaternion.setFromUnitVectors(forward, normal.set(ring2.normal[0], ring2.normal[1], ring2.normal[2]));
           matrix.compose(position.set(ring2.point[0], ring2.point[1], ring2.point[2]), quaternion, scale.set(radius, radius, 1));
-          mesh.setMatrixAt(index, matrix);
-          mesh.setColorAt(index, colour.setHex(ring2.color).multiplyScalar(ring2.hold ? ring2.hold : 1 - k));
+          mesh2.setMatrixAt(index, matrix);
+          mesh2.setColorAt(index, colour.setHex(ring2.color).multiplyScalar(ring2.hold ? ring2.hold : 1 - k));
         }
-        mesh.instanceMatrix.needsUpdate = true;
-        if (mesh.instanceColor) mesh.instanceColor.needsUpdate = true;
+        mesh2.instanceMatrix.needsUpdate = true;
+        if (mesh2.instanceColor) mesh2.instanceColor.needsUpdate = true;
         return drawn;
       },
       dispose() {
@@ -8433,11 +9118,14 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       spriteLayer(THREE, engine.add, true, 1, pointScale),
       spriteLayer(THREE, engine.normal, false, 0.55, pointScale),
       streakLayer(THREE, engine.streaks),
+      rainLayer(THREE, engine.rain),
       debrisLayer(THREE, engine.debris),
       decalLayer(THREE, engine.decals),
       ringLayer(THREE, engine.rings)
     ];
     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);
@@ -8446,6 +9134,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       sync() {
         let drawCalls = 0;
         for (const layer2 of layers) if (layer2.sync()) drawCalls++;
+        drawCalls += meshes.sync();
         engine.lights.lights.forEach((source, index) => {
           const light = flashLights[index];
           light.position.set(source.x, source.y, source.z);
@@ -8462,6 +9151,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       },
       dispose() {
         for (const layer2 of layers) layer2.dispose();
+        meshes.dispose();
         group.clear();
       }
     };
@@ -8580,8 +9270,10 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         return world.play(request.effect, request.point, {
           ...request.direction ? { direction: request.direction } : {},
           ...request.normal ? { normal: request.normal } : {},
+          ...request.orientation ? { orientation: request.orientation } : {},
           ...request.seed !== void 0 ? { seed: request.seed } : {},
-          ...request.param !== void 0 ? { param: request.param } : {}
+          ...request.param !== void 0 ? { param: request.param } : {},
+          ...request.values ? { values: request.values } : {}
         });
       },
       stop: (handle) => world.stop(handle),
@@ -9002,8 +9694,8 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     const uv = geometry.attributes.uv;
     for (let index = 0; index < position.count; index++) uv.setXY(index, position.getX(index) / metres, position.getZ(index) / metres);
     const material = options.material ?? new THREE.MeshStandardMaterial({ color: 2829359, roughness: 0.93, flatShading: true });
-    const mesh = new THREE.Mesh(geometry, material);
-    mesh.receiveShadow = true;
+    const mesh2 = new THREE.Mesh(geometry, material);
+    mesh2.receiveShadow = true;
     let version = -1;
     function sync() {
       if (field.version === version) return false;
@@ -9014,7 +9706,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       return true;
     }
     return {
-      mesh,
+      mesh: mesh2,
       sync,
       dispose() {
         geometry.dispose();