7c65c61
@@ -41,7 +41,7 @@
function fixture(): { dir: string; entries: Entry[]; source: (n: string, t: stri
test("the entry table is what the app ships today, each with the size it may not pass", () => {
  expect(ENTRIES).toEqual([
    { name: "app", entry: "src/client/main.ts", ceiling: { raw: 98_000, gzip: 39_000 } },
    { name: "app", entry: "src/client/main.ts", ceiling: { raw: 103_000, gzip: 41_000 } },
    { name: "range", entry: "src/range/main.ts", ceiling: { raw: 37_000, gzip: 15_500 } },
    { name: "example", entry: "src/example/main.ts", ceiling: { raw: 23_500, gzip: 10_200 } },
  ]);
@@ -188,6 +188,43 @@
test("a 64 Hz tick with ten bodies stays well inside the frame budget", () => {
  expect(alive).toBe(10);
}, PATIENCE);
/**
 * The same tick with smoke standing in the round: ten clouds, one per body,
 * which is the most this game can have at once and far more than a round ever
 * does. It is measured against the *same* ceiling as the plain tick, because
 * what #165 promised is that a cloud does not buy a sight test a second price:
 * `canSee` traces the level's fifty-odd boxes first, as it always has, and then
 * runs `segmentSphere` over the clouds — a dot product and at most one square
 * root each, with no allocation — and in a round nobody smoked the loop is a
 * length check on an empty array and costs nothing measurable at all.
 *
 * Measured on the machine that wrote this, idle: a plain tick 0.102 ms, this
 * one 0.107 ms. Ten clouds cost about **0.005 ms a tick** — three hundredths of
 * one per cent of the 15.625 ms a frame has, and a twentieth of what a tick
 * already cost — and both are nearly ten times under the 1.0 ms ceiling, which
 * did not move for any of this.
 */
test("a tick with ten clouds of smoke standing is still well inside the budget", () => {
  useShipped();
  let clouds = 0;
  const each = measure("a 64 Hz tick with ten clouds standing", TICK_CEILING, () => {
    const world = liveRound(7);
    // One cloud on each body, opened a moment ago so every one of them is at
    // its full radius for the whole batch rather than growing out of nothing.
    for (const p of world.players)
      world.clouds.push({ pos: [p.pos[0], p.pos[1], p.pos[2] + 58], born: world.time - 2, owner: p.id });
    const batch = timed(TICKS, () => {
      for (let i = 0; i < TICKS; i++) update(world, TICK, NO_INPUT);
    });
    clouds = world.clouds.length;
    return batch;
  });
  expect(each).toBeLessThan(TICK_CEILING);
  // The ticks that were measured really did have ten clouds standing in them.
  expect(clouds).toBe(10);
}, PATIENCE);
/**
 * The guard's own guard. A ceiling nothing can reach is a green light wired to
 * nothing: a loop the JIT lifted out, a clock read twice in a row, a batch that
@@ -198,6 +198,18 @@
export function createAudio(device: SoundDevice = createSoundDevice()): Audio {
        device.tone({ frequency: 260, slideTo: 150, gain: 0.16 * volume, length: 0.08, pan });
        return;
      }
      if (sound === "smoke") {
        // The canister opening: no bang at all. A long, soft, wide hiss that
        // fades away rather than cracks — it is the one grenade noise in this
        // game that is a *process* and not an event, and it is quiet, because
        // what a smoke costs you is what you can see and never what you hear.
        // It carries like a footstep does and not like a blast: a cloud across
        // the map is not information anybody should get for free.
        const soft = attenuate(far, BOMB_EARSHOT, BOMB_CLOSE);
        device.noiseBurst({ frequency: 3200, gain: 0.2 * soft, length: 1.4, q: 0.5, rate: 0.9, pan });
        device.tone({ frequency: 420, slideTo: 210, gain: 0.1 * soft, length: 0.9, pan });
        return;
      }
      if (sound === "flash") {
        // The flash: the opposite noise to the blast in every way. A bright,
        // tight crack with no body under it and a ring above it that climbs
@@ -19,12 +19,13 @@
test("the bindings are the ones the keyboard has always had", () => {
  expect(CS_KEYS.KeyB).toBe("buy");
  expect(CS_KEYS.KeyG).toBe("grenade");
  expect(CS_KEYS.KeyT).toBe("flash");
  expect(CS_KEYS.KeyV).toBe("smoke");
  expect(CS_KEYS.Tab).toBe("scoreboard");
  expect(CS_KEYS.Digit1).toBe("slot1");
  expect(CS_KEYS.Digit3).toBe("slot3");
  expect(CS_MOUSE[0]).toBe("fire");
  expect(CS_MOUSE[2]).toBe("scope");
  expect([...CS_TAP]).toEqual(["jump", "reload", "buy", "grenade", "flash"]);
  expect([...CS_TAP]).toEqual(["jump", "reload", "buy", "grenade", "flash", "smoke"]);
  // F is the page's, not the world's: `main.ts` hears it on `onAction` and asks
  // the browser for the screen, and nothing about an `Input` changes for it.
  expect(CS_KEYS.KeyF).toBe("fullscreen");
@@ -13,7 +13,8 @@
export const CS_KEYS: Record<string, string> = {
  KeyW: "forward", KeyS: "back", KeyA: "left", KeyD: "right",
  ArrowUp: "forward", ArrowDown: "back", ArrowLeft: "left", ArrowRight: "right",
  Space: "jump", ControlLeft: "duck", KeyC: "duck", ShiftLeft: "walk",
  KeyR: "reload", KeyE: "use", KeyG: "grenade", KeyT: "flash", KeyB: "buy", Tab: "scoreboard",
  KeyR: "reload", KeyE: "use", KeyG: "grenade", KeyT: "flash", KeyV: "smoke",
  KeyB: "buy", Tab: "scoreboard",
  Digit1: "slot1", Digit2: "slot2", Digit3: "slot3",
  // Neither of these is a thing the world knows about: `main.ts` hears them on
  // `onAction`, and `readIntent` below never sees either. F asks the browser for
@@ -28,7 +29,7 @@
export const CS_KEYS: Record<string, string> = {
export const CS_MOUSE: Record<number, string> = { 0: "fire", 2: "scope" };
/** On-screen buttons that are a tap, not a hold. */
export const CS_TAP = ["jump", "reload", "buy", "grenade", "flash"] as const;
export const CS_TAP = ["jump", "reload", "buy", "grenade", "flash", "smoke"] as const;
export type Intent = {
  input: Input;
@@ -55,9 +56,11 @@
export function readIntent(held: ReadonlySet<string>, stick: { x: number; y: num
    use: down("use"),
    fire: down("fire"),
    scope: down("scope"),
    // Two pockets, two keys. Both held is the flash, because the one you just
    // reached for is the one you meant; releasing it throws the HE still held.
    throwing: down("flash") ? "flash" : down("grenade") ? "he" : null,
    // Three pockets, three keys, read newest-reach-first: the one nearest the
    // front of this list wins while more than one is held, because the one you
    // just reached for is the one you meant, and releasing it throws whichever
    // of the others is still down.
    throwing: down("smoke") ? "smoke" : down("flash") ? "flash" : down("grenade") ? "he" : null,
    switchTo: null,
  };
  return {
@@ -19,6 +19,13 @@
 * — the arena's, the trainer's — behave exactly as they did before, down to the
 * coin flip, because `usePlan` was never called on them.
 *
 * Smoke is handled in the same layer, and deliberately not in the policy. A bot
 * cannot see through a cloud because `canSee` says so, which is one change in
 * one function and covers the shooting; what it cannot answer is the walking,
 * so `skirt` below bends the next step of a path around a cloud rather than
 * into it. Both are scripted, both are outside the network, and the shipped
 * weights are the same eight kilobytes they were.
 *
 * The weights are not in here and are not imported: they arrive as data. In a
 * browser `src/client/main.ts` downloads `weights.json` as this game's own
 * asset and calls `usePolicy` before Play is pressable; in Bun
@@ -38,6 +45,7 @@
import { CS_HULL } from "./movement.ts";
import { observe, OBS_SIZE, type Memory } from "./observe.ts";
import { SHAPE } from "./packed.ts";
import { ease, grip, gripRate, sprayPull } from "./spray.ts";
import { cloudRadius } from "./grenade.ts";
import { FLASH, WEAPONS, type WeaponId } from "./weapons.ts";
import { buy } from "./economy.ts";
import type { Input, Player, World } from "./world.ts";
@@ -430,6 +438,74 @@
function pickTarget(world: World, bot: Player, brain: BotBrain): Player | null {
  return best;
}
// --- smoke ----------------------------------------------------------------
/**
 * How far outside a cloud a bot aims to walk, in units. A hull's width, so it
 * skirts the fringe of one rather than clipping through it — and so that a
 * diversion is a visible step around something and not a shuffle along its
 * edge.
 */
const SMOKE_CLEARANCE = CS_HULL.radius * 2;
/**
 * Where this bot should walk instead of straight at `step`, given the clouds
 * standing in the round.
 *
 * A cloud is not a wall — a body walks through one exactly as it walks through
 * air, and it should, because walking through smoke is half of what smoke is
 * for — but it *is* a wall to this bot's eyes: `canSee` refuses a line through
 * one, so a bot that strolls into a cloud arrives blind at whatever is waiting
 * on the other side and has given away the fight it was walking to. So the
 * scripted layer treats it as something to go around, and the policy is told
 * nothing: the shipped weights, `OBS_SIZE` and every head are untouched by all
 * of this.
 *
 * Two cases and no third. Standing in one, the shortest way out is straight
 * away from the middle, and that is where the bot walks. Heading into one, the
 * step is pushed sideways to whichever edge is nearer — the tangent, plus the
 * clearance — so the path bends around the cloud and rejoins itself. A cloud
 * behind the bot, beside the walk, or past the end of this step is left alone,
 * which is every cloud on most ticks; a round nobody smoked never reaches here
 * at all, because the caller checks the list is empty first.
 *
 * The step comes back unchanged when there is nothing to do, so the common case
 * allocates nothing.
 */
export function skirt(world: World, bot: Player, step: Vec3): Vec3 {
  for (const cloud of world.clouds) {
    const radius = cloudRadius(cloud, world.time);
    if (radius <= 0) continue;
    const keep = radius + SMOKE_CLEARANCE;
    const cx = cloud.pos[0] - bot.pos[0];
    const cy = cloud.pos[1] - bot.pos[1];
    const here = Math.hypot(cx, cy);
    if (here < keep) {
      // Inside it, or in its fringe: out, by the shortest line there is. Dead
      // in the middle there is no such line, so the bot keeps walking rather
      // than picking a direction out of nothing.
      if (here < 1e-6) continue;
      return [bot.pos[0] - (cx / here) * keep, bot.pos[1] - (cy / here) * keep, step[2]];
    }
    const dx = step[0] - bot.pos[0];
    const dy = step[1] - bot.pos[1];
    const len = Math.hypot(dx, dy);
    if (len < 1e-6) continue;
    const ux = dx / len, uy = dy / len;
    // How far along the walk the cloud sits, and how far off to one side.
    const along = cx * ux + cy * uy;
    if (along <= 0 || along > len + keep) continue;
    const off = cx * -uy + cy * ux;
    if (Math.abs(off) >= keep) continue;
    // Around the near edge: the perpendicular, away from the side the cloud is
    // on, by just enough to put the walk on the tangent.
    const side = off >= 0 ? -1 : 1;
    const push = (keep - Math.abs(off)) * side;
    return [step[0] + -uy * push, step[1] + ux * push, step[2]];
  }
  return step;
}
/** An enemy shooting nearby is a direction to look, even through a wall. */
function listen(world: World, bot: Player, brain: BotBrain): void {
  for (const other of world.players) {
@@ -659,7 +735,11 @@
export function botThink(world: World, bot: Player, dt: number): Input {
  const next = brain.path[brain.step];
  if (next !== undefined) {
    if (dist([bot.pos[0], bot.pos[1], 0], [next[0], next[1], 0]) < 48) brain.step += 1;
    const aim = aimAt(bot, [next[0], next[1], bot.pos[2] + 48]);
    // The path is A*'s and it knows nothing about smoke, which is right: the
    // cells are still walkable and a cloud is gone in fifteen seconds. What
    // bends is the *step*, here and only while there is a cloud to bend it.
    const walk = world.clouds.length === 0 ? next : skirt(world, bot, next);
    const aim = aimAt(bot, [walk[0], walk[1], bot.pos[2] + 48]);
    const look = brain.suspect !== null ? aimAt(bot, brain.suspect) : { yaw: aim.yaw, pitch: 0 };
    turnTowards(bot, { yaw: look.yaw, pitch: clamp(look.pitch, -20, 20) }, brain.aimSpeed * 0.5, dt);
    const off = angleDelta(bot.yaw, aim.yaw);
@@ -21,7 +21,7 @@
const buyer = (over: Partial<Buyer> = {}): Buyer => ({
  armor: 0, helmet: false, defuseKit: false,
  weapon: "usp", primary: null, secondary: "usp",
  ammo: { knife: { mag: 0, reserve: 0 }, usp: emptyAmmo("usp") },
  pocket: { he: 0, flash: 0 },
  pocket: { he: 0, flash: 0, smoke: 0 },
  ...over,
});
@@ -25,11 +25,12 @@
export const emptyAmmo = (id: WeaponId): Ammo =>
  ({ mag: WEAPONS[id].magazine, reserve: WEAPONS[id].reserve });
/**
 * How many of each thrown weapon a player may carry into a round. One HE and
 * one flashbang — two grenades, bought separately in the freeze, each refused
 * once the pocket holds its limit, and both gone with the body that held them.
 * How many of each thrown weapon a player may carry into a round. One HE, one
 * flashbang and one smoke — three grenades, bought separately in the freeze,
 * each refused once the pocket holds its limit, and all gone with the body that
 * held them.
 */
export const CARRY: Record<ThrownId, number> = { he: 1, flash: 1 };
export const CARRY: Record<ThrownId, number> = { he: 1, flash: 1, smoke: 1 };
export type BuyItem = WeaponId | "armor" | "helmet" | "kit";
@@ -370,7 +370,12 @@
test("a bot walks a map nobody wrote, on that map's own cells", () => {
 * field list still comes to the digest this line held before,
 * 48a1d4466065e045b8933b3fbf5ece767a825a60165e6455b4e310a8d7dd5cae.
 */
const GENERATED_ROUND = "d7bd4969d00345feff718f37a6ed13ff6967f8884ca716bc639bff63f085d82e";
// Re-pinned for #165, which put a smoke grenade in the game: the hash moved
// and the play did not. A pocket is three counts now rather than two, a
// grenade's kind is an index into three rather than a flag, and every tick
// carries however many clouds are standing — and nothing in this run throws
// anything, so `clouds` is empty on all 640 ticks of it.
const GENERATED_ROUND = "619ce3102805d11dc40e8d545267e99034bfb3bdab2961202703423a87f6e500";
test("a seeded round on a generated map plays exactly as it played", () => {
  const level = generateLevel(5);
@@ -458,7 +458,7 @@
test("a flash is bought alongside the HE, one of each, and thrown on its own key
  expect(buy(world, world.me, "he")).toBe(true);
  expect(buy(world, world.me, "flash")).toBe(true);
  // Carried alongside, not instead of: both are in the pocket at once.
  expect(world.me.pocket).toEqual({ he: CARRY.he, flash: CARRY.flash });
  expect(world.me.pocket).toEqual({ he: CARRY.he, flash: CARRY.flash, smoke: 0 });
  expect(world.me.money).toBe(5000 - HE.price - FLASH.price);
  // One of each a round: the second of either is refused and costs nothing.
  expect(buy(world, world.me, "flash")).toBe(false);
@@ -472,7 +472,7 @@
test("a flash is bought alongside the HE, one of each, and thrown on its own key
  for (let t = 0; t < 32; t++) update(world, TICK, { ...NO_INPUT, throwing: "flash" });
  expect(world.grenades.length).toBe(1);
  expect(world.grenades[0]?.weapon).toBe("flash");
  expect(world.me.pocket).toEqual({ he: 1, flash: 0 });
  expect(world.me.pocket).toEqual({ he: 1, flash: 0, smoke: 0 });
});
/** Everyone but `p` put out of the round, so only the flash can change anything. */
@@ -1,10 +1,11 @@
/**
 * The thrown grenade: a body, a fuse, and whatever it does when the fuse runs
 * out. Two kinds are thrown today — the HE and the flashbang — and the only
 * thing in this file that knows which is `Grenade.weapon`: the flight, the
 * bounce, the fuse and the sounds are one piece of machinery both use, and what
 * arrives at the far end is `blastHits` for one and `flashHits` for the other.
 * A third kind is a row in `weapons.ts` and a function here.
 * out. Three kinds are thrown today — the HE, the flashbang and the smoke — and
 * the only thing in this file that knows which is `Grenade.weapon`: the flight,
 * the bounce, the fuse and the sounds are one piece of machinery all three use,
 * and what arrives at the far end is `blastHits` for one, `flashHits` for
 * another and `cloudFrom` for the third. A fourth kind is a row in `weapons.ts`
 * and a function here.
 *
 * There is no solver in this file. A grenade in flight is a `Body` like a
 * player is, and it is moved by the same `move` in `src/engine/physics.ts` —
@@ -17,11 +18,17 @@
 * 64 Hz `world.ts` steps at — so it is the same number of ticks on a phone as
 * on a desktop, and the same number in a replay as in a match.
 *
 * Neither kind reaches anything it cannot see. `blastHits` and `flashHits` both
 * trace from the middle of the detonation through the engine's own `visible`,
 * so a wall, a crate or a corner takes all of it: a grenade cannot kill through
 * a wall here and a flash cannot blind through one, which are the properties
 * the two tests of that name hold.
 * Neither of the first two reaches anything it cannot see. `blastHits` and
 * `flashHits` both trace from the middle of the detonation through the engine's
 * own `visible`, so a wall, a crate or a corner takes all of it: a grenade
 * cannot kill through a wall here and a flash cannot blind through one, which
 * are the properties the two tests of that name hold.
 *
 * The smoke is the odd one and it is odd in the other direction: it reaches
 * nobody at all, and what it leaves behind outlives it. `cloudFrom` turns a
 * spent canister into a `Cloud` — a ball with a clock — which the world keeps
 * and `canSee` in `src/client/world.ts` traces against. Nothing about a cloud
 * is drawing: it is the same ball on the screen and in the simulation.
 */
import {
@@ -30,7 +37,10 @@
import {
} from "../engine/index.ts";
import { hitboxes, type Actor } from "./combat.ts";
import { CS_HULL, NADE_HULL, NADE_MOVE } from "./movement.ts";
import { blastDamage, blindSeconds, fuseOf, WEAPONS, throughArmor, type ThrownId } from "./weapons.ts";
import {
  blastDamage, blindSeconds, fuseOf, SMOKE, WEAPONS, throughArmor,
  type Smoke, type ThrownId,
} from "./weapons.ts";
/** A grenade in the world: a body, which kind it is, whose it is, and how long it has left. */
export type Grenade = Body & {
@@ -66,11 +76,11 @@
const HAND = 18;
/**
 * The sounds a grenade makes, in the order one round of it happens. The first
 * two belong to every thrown thing; the last of them is the kind's own — the
 * HE's `blast`, the flashbang's `flash` — which is why this is one widening
 * type and not a second one per grenade.
 * two belong to every thrown thing; the rest are each a kind's own — the HE's
 * `blast`, the flashbang's `flash`, the canister's `smoke` — which is why this
 * is one widening type and not a second one per grenade.
 */
export type GrenadeSound = "throw" | "bounce" | "blast" | "flash";
export type GrenadeSound = "throw" | "bounce" | "blast" | "flash" | "smoke";
/**
 * Below this the knock of a bounce is not worth a sound: a grenade rolling to
@@ -132,6 +142,44 @@
export function stepGrenade(g: Grenade, dt: number, boxes: Box[]): boolean {
  );
}
/**
 * How slowly a grenade has to be moving, in u/s, to count as having stopped.
 * A shell settling on concrete never quite reaches zero — the solver leaves it
 * a fraction of a unit a second — so "at rest" is a small number and not one.
 */
const REST_SPEED = 20;
/**
 * How many seconds past its fuse a smoke will wait for the floor before it
 * opens anyway. A canister thrown off a ledge, wedged in a corner or bouncing
 * down a long stair is still a grenade somebody threw, and one that never opens
 * is worse than one that opens in the air. Two seconds is longer than any throw
 * on any map this game generates takes to settle.
 */
const REST_PATIENCE = 2;
/** Is this grenade lying still enough for a cloud to grow where it stopped? */
export const atRest = (g: Grenade): boolean =>
  g.onGround && Math.hypot(g.vel[0], g.vel[1], g.vel[2]) < REST_SPEED;
/**
 * Has this one's fuse run out — has it done whatever it does yet?
 *
 * For the HE and the flashbang this is the comparison it has always been: zero
 * on the fuse is the tick it goes off, in the air or on the floor, because a
 * blast and a flash happen wherever the thing happens to be.
 *
 * A smoke is different in the one way that matters to a round: a cloud grows
 * where the canister *stopped*, so a fuse that runs out in mid-flight is held
 * — the fuse keeps burning negative, which is what makes the wait a number the
 * digest can see — until the thing is on the floor and still, or until
 * `REST_PATIENCE` seconds have gone by and it opens where it is.
 */
export function spent(g: Grenade): boolean {
  if (g.weapon !== "smoke") return g.fuse <= 0;
  return g.fuse <= -REST_PATIENCE || (g.fuse <= 0 && atRest(g));
}
/** The middle of the explosion: the middle of the grenade, not its feet. */
export const blastCentre = (g: Grenade): Vec3 => [g.pos[0], g.pos[1], g.pos[2] + NADE_HULL.stand / 2];
@@ -238,3 +286,71 @@
export function flashHits(g: Grenade, actors: Looker[], boxes: Box[]): Blinded[]
  }
  return blinded;
}
// --- the cloud ------------------------------------------------------------
/**
 * A cloud of smoke standing in the world: where its middle is, when it opened,
 * and whose canister it was. Everything else about it — how wide it is right
 * now, whether it is still there at all — is arithmetic on `born` and the
 * world's clock, which is why there is no radius on this record and no tick of
 * a cloud anywhere in the game. A cloud is not stepped; it is *read*.
 */
export type Cloud = {
  pos: Vec3;
  /** The simulated second the canister opened. */
  born: number;
  /** The player id that threw it. Nothing reads it yet; the feed will. */
  owner: number;
};
/**
 * How high above the canister the middle of the ball sits, in units. A smoke
 * lying on the floor with its middle at its own height would be a ball half
 * buried in concrete and a hole a crouching body could see under; lifting it
 * most of a standing hull puts the bottom of the ball on the floor and the top
 * of it over a head, which is the wall a smoke is supposed to be.
 */
const CLOUD_LIFT = 58;
/** The cloud a spent canister leaves behind, opening at `time`. */
export const cloudFrom = (g: Grenade, time: number): Cloud => ({
  pos: [g.pos[0], g.pos[1], g.pos[2] + CLOUD_LIFT],
  born: time,
  owner: g.owner,
});
/**
 * How wide this cloud is at `time`, in units, and zero once it is gone —
 *
 *     r(age) = radius · age / grow                  age < grow
 *            = radius                               grow ≤ age < life − fade
 *            = radius · (life − age) / fade         life − fade ≤ age < life
 *            = 0                                    age < 0 or age ≥ life
 *
 * One number, read by three callers that must never disagree: the sight test in
 * `world.ts`, the ball `scene.ts` places, and the wash `hud.ts` puts over the
 * screen when your eye is inside it. A cloud that blocked a bot's line for a
 * second longer than it was drawn would be exactly the bug this shape rules
 * out.
 *
 * The default is the one smoke grenade in the table. It is an argument because
 * a test wants to say "a cloud this wide" without reaching for the weapon.
 */
/**
 * Is this cloud over? Asked by the world's housekeeping rather than by the
 * radius above, because the two differ at exactly one instant and it is the
 * instant that matters: a cloud is *born* at radius zero and is not gone, and a
 * prune written against the radius would drop every cloud on the tick it opened.
 */
export const cloudGone = (cloud: Cloud, time: number, smoke: Smoke = SMOKE.smoke): boolean =>
  time - cloud.born >= smoke.life;
export function cloudRadius(cloud: Cloud, time: number, smoke: Smoke = SMOKE.smoke): number {
  const age = time - cloud.born;
  if (age < 0 || age >= smoke.life) return 0;
  if (age < smoke.grow) return smoke.radius * (age / smoke.grow);
  const left = smoke.life - age;
  if (left < smoke.fade) return smoke.radius * (left / smoke.fade);
  return smoke.radius;
}
@@ -616,12 +616,12 @@
test("the pocket line names each grenade you are carrying, and both at once", ()
  const none = draw(scene());
  expect(words(none).some((t) => t.includes("HE"))).toBe(false);
  const both = draw(scene((w) => {
    (w.me as Player).pocket = { he: 1, flash: 1 };
    (w.me as Player).pocket = { he: 1, flash: 1, smoke: 0 };
  }));
  const named = words(both).find((t) => t.includes("HE")) ?? "";
  expect(named).toContain("HE");
  expect(named).toContain("flash");
  const only = draw(scene((w) => { (w.me as Player).pocket = { he: 0, flash: 1 }; }));
  const only = draw(scene((w) => { (w.me as Player).pocket = { he: 0, flash: 1, smoke: 0 }; }));
  const line = words(only).find((t) => t.includes("flash")) ?? "";
  expect(line).not.toContain("HE");
});
@@ -30,7 +30,7 @@
import { BLUE, CROSSHAIR, CT_COLOR, GREY, RED, T_COLOR, teamColor, WHITE } from
import { inaccuracy, WEAPONS } from "./weapons.ts";
import { useProgress } from "./bomb.ts";
import { scoreLines } from "./summary.ts";
import { currentWeapon, type Player, type World } from "./world.ts";
import { currentWeapon, eyePos, insideSmoke, type Player, type World } from "./world.ts";
/**
 * Everything this module asks of the thing it draws on. Nothing else: it is the
@@ -100,6 +100,22 @@
export const whiteout = (blind: number): number => PEAK * Math.min(1, blind / WH
const PEAK = 0.92;
const WHITEOUT_FADE = 0.9;
/**
 * How much grey is over the world when the eye is inside a cloud of smoke.
 *
 * It is a constant and not a ramp, on purpose: the simulation's answer inside a
 * cloud is a flat *no* — `canSee` refuses a line that meets the ball at all, so
 * a bot one unit inside one is as blind as a bot in the middle — and a wash
 * that faded with depth would be the screen disagreeing with the round. Like
 * the white-out above it stops short of 1, so the crosshair and the world are a
 * ghost behind it rather than gone; unlike the white-out it does not fade,
 * because a cloud does not fade while you are standing in it.
 *
 * From outside, a cloud is a ball `scene.ts` places and this draws nothing at
 * all. The two are the same fact from the two sides of one surface.
 */
export const FOG = 0.9;
/**
 * Paint the HUD for this frame. `view` is whose eyes the camera is in — you, or
 * the player you are watching once you are dead — and it is what every number
@@ -171,6 +187,16 @@
export function drawHud(
    ctx.fillRect(0, 0, width, height);
  }
  // --- and in the smoke: the same idea from inside a cloud instead of outside
  // one. The ball `scene.ts` draws is opaque and its far faces are culled, so
  // an eye within it would otherwise see straight through the thing that is
  // blocking every sightline in the simulation. Which eye is the view's, so a
  // spectator sees the fog the body they are watching is standing in.
  if (view.alive && insideSmoke(world, eyePos(view))) {
    ctx.fillStyle = `rgba(196,200,208,${FOG})`;
    ctx.fillRect(0, 0, width, height);
  }
  const scale = ui.scale;
  const big = ui.font(30);
  const mid = ui.font(19);
@@ -216,6 +242,7 @@
export function drawHud(
    weapon.name +
      (view.pocket.he > 0 ? "  ·  HE" : "") +
      (view.pocket.flash > 0 ? "  ·  flash" : "") +
      (view.pocket.smoke > 0 ? "  ·  smoke" : "") +
      (view.hasBomb ? "  ·  bomb" : ""),
    width - pad, height - pad - Math.round(30 * scale),
    { align: "right", font: small, fill: GREY },
@@ -958,7 +958,8 @@
test("every mesh name a scene of this game can place is handed in at constructio
  // table misses is an exception on the frame a player first holds that gun.
  const meshes = gameMeshes();
  expect(Object.keys(meshes).sort()).toEqual([
    "bomb", "flash", "grenade", "knife", "level", "pistol", "player", "rifle", "smg", "sniper",
    "bomb", "cloud", "flash", "grenade", "knife", "level", "pistol", "player", "rifle", "smg",
    "smoke", "sniper",
  ]);
  // Every kind a weapon can be, and the kind `scene.ts` falls back to.
  for (const weapon of Object.values(WEAPONS)) expect(meshes[weapon.kind]).toBeDefined();
@@ -1171,8 +1171,10 @@
export function boot(host: Host): Frame {
export function gameMeshes(level: Level = DE_FORGE): Record<string, Mesh> {
  const kinds = new Set(Object.values(WEAPONS).map((weapon) => weapon.kind));
  // `grenade` arrives as a weapon kind and is the HE's body in the world; the
  // flashbang shares that kind and needs its own shell, so it is named here.
  const names = ["level", "player", "bomb", "flash", ...kinds];
  // flashbang and the smoke share that kind and need their own shells, so they
  // are named here — and so is `cloud`, which is no weapon at all but the ball
  // a spent smoke leaves standing.
  const names = ["level", "player", "bomb", "flash", "smoke", "cloud", ...kinds];
  return Object.fromEntries(names.map((name) => [name, meshFor(name, level)]));
}
@@ -58,11 +58,19 @@
export function bombMesh(): Mesh {
 *
 * The flashbang is the same shell in a different shape: taller, narrower and
 * banded top and bottom, the way CS's is, so the two are told apart in the air
 * at a glance. Both are the one recipe because both are one thrown thing.
 * at a glance. The smoke is the squat one — a fat canister with a vent collar
 * — which is CS's shape too. All three are the one recipe because all three are
 * one thrown thing.
 */
export function grenadeMesh(kind: "he" | "flash" = "he"): Mesh {
export function grenadeMesh(kind: "he" | "flash" | "smoke" = "he"): Mesh {
  const b = builder();
  const SHELL = 7, BAND = 8;
  if (kind === "smoke") {
    cube(b, 0, 0, 3.5, 7, 7, 8, SHELL); // the fat canister
    cube(b, 0, 0, 7, 8, 8, 2, BAND); // the vent collar at its top
    cube(b, 0, 0, 8.5, 2.5, 2.5, 2, BAND); // the spoon on top
    return finish(b);
  }
  if (kind === "flash") {
    cube(b, 0, 0, 3, 5, 5, 10, SHELL); // the canister
    cube(b, 0, 0, 1, 6, 6, 2, BAND); // the band around its foot
@@ -76,6 +84,60 @@
export function grenadeMesh(kind: "he" | "flash" = "he"): Mesh {
  return finish(b);
}
/**
 * The radius the cloud mesh below is built at, in units. A mesh is uploaded
 * once and a cloud grows, so the ball is built at one size and the scene sets
 * `size` to the radius it wants over this one — which also stretches the
 * texture as it grows, which is what billowing looks like from outside.
 */
export const CLOUD_MESH_RADIUS = 64;
/**
 * The lumps a cloud is built of, as [x, y, z, radius] in units of the ball's
 * own radius. Nine of them: one filling the middle and eight around it at a
 * little under the full radius, in two staggered rings so the silhouette is
 * bumpy from every side and from above. Written down rather than generated
 * because it is nine rows and a reader can see the shape.
 */
const PUFFS: [number, number, number, number][] = [
  [0, 0, 0, 0.78],
  [0.52, 0.18, 0.1, 0.52],
  [-0.46, 0.34, -0.06, 0.55],
  [0.14, -0.55, 0.12, 0.5],
  [-0.2, -0.44, -0.2, 0.47],
  [0.3, 0.42, -0.34, 0.45],
  [-0.38, -0.12, 0.42, 0.46],
  [0.08, 0.2, 0.56, 0.44],
  [-0.1, 0.5, 0.3, 0.42],
];
/**
 * A cloud of smoke: nine overlapping cubes about the origin, at
 * `CLOUD_MESH_RADIUS`, on the sand layer. It is the *same ball* the sight test
 * in `src/client/world.ts` traces against — one mesh, opaque, drawn in the pass
 * that was already there, with no blending and no sorting — which is the whole
 * argument for drawing it this way: what you cannot see past on the screen and
 * what a bot cannot see past in the simulation are the same sphere, to the unit.
 *
 * Opaque means the inside of one is not drawn at all — the far faces are culled
 * — so being inside a cloud is drawn by `src/client/hud.ts` instead, as a wash
 * over the world. Outside it is a solid mass; inside it is fog. Two drawings of
 * one fact, and neither of them a new pass.
 *
 * There is no tenth material for it: the sand layer is smooth fbm noise with no
 * seam and no straight line in it, and the tint `scene.ts` places it with turns
 * that sand into a cool pale grey. The lighting the renderer already does — a
 * hemisphere ambient plus one sun — is what makes the lumps read as lumps.
 */
export function cloudMesh(): Mesh {
  const b = builder();
  const SAND = 0;
  const r = CLOUD_MESH_RADIUS;
  for (const [x, y, z, size] of PUFFS)
    cube(b, x * r, y * r, z * r, size * 2 * r, size * 2 * r, size * 2 * r, SAND);
  return finish(b);
}
/**
 * A first-person weapon, in view space: X right, Y up, Z back, so the barrel
 * runs down -Z and the model needs no rotation at all.
@@ -100,7 +162,8 @@
export function viewModelMesh(kind: string): Mesh {
/**
 * A mesh by the name a scene calls it: `level`, `player`, `bomb`, `grenade`,
 * `flash`, or a weapon kind for the gun in your hands. `main.ts` builds one of each at start-up and
 * `flash`, `smoke`, `cloud`, or a weapon kind for the gun in your hands.
 * `main.ts` builds one of each at start-up and
 * hands them to the engine's renderer, which keeps them by name and never
 * learns what a name is made of — that is this file, and this is the one line a
 * second game's model table would replace.
@@ -114,5 +177,7 @@
export function meshFor(name: string, level: Level): Mesh {
  if (name === "bomb") return bombMesh();
  if (name === "grenade") return grenadeMesh();
  if (name === "flash") return grenadeMesh("flash");
  if (name === "smoke") return grenadeMesh("smoke");
  if (name === "cloud") return cloudMesh();
  return viewModelMesh(name);
}
@@ -29,11 +29,13 @@
import { DE_FORGE } from "./map.ts";
import { SHORT } from "./match.ts";
import { CHECKPOINT_CHARS } from "../engine/index.ts";
import {
  compare, digest, fold, reader, snapshot, TICK, TICKS_PER_SECOND,
  compare, digest, fold, reader, snapshot, SMOKE_SCRIPT, TICK, TICKS_PER_SECOND,
  withoutEntropy, type Pin, type Run,
} from "./replay.ts";
import { colOf, rowOf, walkable, type Level } from "./level.ts";
import { createWorld, type Player } from "./world.ts";
import { createWorld, update, type Player } from "./world.ts";
import { cloudRadius } from "./grenade.ts";
import { SMOKE } from "./weapons.ts";
import { createArena, reset, stepInput } from "../rl/arena.ts";
import { useShipped } from "./shipped.ts";
@@ -49,7 +51,18 @@
const SECONDS = 40;
const TICKS = SECONDS * TICKS_PER_SECOND;
/**
 * Forty seconds of a five-a-side round on de_forge, seed 7. Re-pinned for #185,
 * Forty seconds of a five-a-side round on de_forge, seed 7. Re-pinned for #165,
 * which put a smoke grenade in the game, and for the reason #164 and #142 were
 * re-pinned before it: what moved is the *hash*, not the play. A pocket is
 * three counts now rather than two, a live grenade's kind is an index into
 * three rather than a flag, and a tick carries however many clouds are standing
 * with the radius of each — so every second of every run differs from the
 * numbers before it. Nothing in this script throws anything and the bots buy no
 * grenades, so `clouds` is empty on all 2,560 ticks of this run and `smoke` is
 * zero in all ten pockets. The run *with* a smoke in it is SMOKE_ROUND below,
 * and that one is new rather than moved.
 *
 * Before that it was re-pinned for #185,
 * and this time the *play* moved, on purpose: a bot whose gun has nothing left
 * in it now puts it away and takes out the next thing that can fire. The first
 * twenty-three seconds are the same to the bit — the pistol round is fought
@@ -90,18 +103,18 @@
const TICKS = SECONDS * TICKS_PER_SECOND;
 * anything: the bots buy no grenades and the scripted person never presses
 * either key, so no flash goes off and no `blind` is ever non-zero here.
 */
const ROUND = "7a7f4535278c1daa96c1adf3fe72bffeb957a332b08e469c160304b3e936b359";
const ROUND = "2baf12fbafbff25007a9147511d1307ee9f4d5cf7d0b2473d7dae4fea876490e";
const ROUND_SECONDS = [
  "5978706f2efd", "aa6aa9a5a3c9", "f822e864db93", "6f1cf4de1926",
  "25923b9cb132", "83b06bc2430e", "b97f8d621af5", "c1b94afedda0",
  "700c15a0f6c1", "32921cefb2ff", "8241df979380", "c815eb110a37",
  "95d7115059f4", "e131dfcfdb54", "a56027278fc7", "3e66ed95e89c",
  "df1d01273592", "392385270f63", "c41cf61d1f0f", "e5a9d02a9e68",
  "88d708808f5f", "b956000db9df", "c04cbb5e0444", "32c110c9cfad",
  "5aa46f32cacc", "7b21f3168603", "ec5690d1c569", "33df275c9fe8",
  "6552dd9625ab", "93098f77ddc6", "bcaa4f830efc", "8ddf93ee8995",
  "71fb5532c520", "a0e5a420db35", "778f27867fca", "3c9a93e518d4",
  "0ef3e79c0406", "0dc24683c2de", "e7f34118de6e", "d66ce8d2348e",
  "c858433691b7", "d46389733924", "1d2038791546", "318d01ffb6a5",
  "0fab6fec7329", "46cbc192435f", "db863794da65", "0e5d2d2d2685",
  "c693a6f1b5b1", "dd5ba820b82f", "6a9d536dc726", "3e3b6bf68300",
  "49e7ea12852b", "088f53f05a7b", "ff5cfd8a23ee", "79b70ab03724",
  "458b377ac8b0", "81c86e729615", "7db95c82ca95", "9ce89515f860",
  "74b44ef7c080", "1c8476381a49", "e4716444e2e0", "4b6a1819fbae",
  "13a62553b5fe", "ca237b750358", "d2bb12aba939", "86eb5bef3ba7",
  "ad7857be9d5b", "db763c785460", "8f761bbb7fd6", "7f701a5bf90f",
  "30e1a75cffa6", "2ed2a01fb154", "aebb3d0af576", "297ffec85d70",
  "357635b90451", "168bd830c746", "c8eaf7365264", "5b20351850e8",
];
/**
@@ -114,20 +127,65 @@
const ROUND_SECONDS = [
 * this code still folds to
 * 37ea4cc90ecb55e2489ee1f219654b563a16e93893a6222c6e17f23f56b3c5d3.
 */
const DUEL = "bffdda30cf85fd8b2ea4840ad4b53e8041054411fcb2d6adcd7537be8f1ebbef";
const DUEL = "0a9868af8d274a54cb508e272550a536daa70da43320e410d71e0955603aabc1";
const DUEL_SECONDS = [
  "f3d6534f1590", "3f1e2479a841", "43b52fff16ef", "bd2c6c29eaf3",
  "0c965cb1929c", "7572a5087ec4", "c4b9c83c357b", "b352f5a86d06",
  "1e533cbaf327", "090b9d34147d", "a2f17103d7cf", "6831ee8d38c1",
  "258eb2af7c8b", "9bb124c5f5fd", "fdac71af56c4", "1ae133a994ad",
  "1d96558e6129", "989f1591cc59", "03836444fe3d", "2442e7241118",
  "4795750cc613", "8c40d6315858", "6da5618d9b4d", "217b93298e47",
  "49c8cc22abaa", "1f1706709ae2", "faa170572b54", "bd67caf0320a",
  "a89d510d047b", "645baf0eb839", "36eaedb9bb79", "ddc41eb233e9",
  "45377fd1cdea", "b0796f4fa162", "02afbd2180fd", "02bd15880c74",
  "4649a72e207a", "78940559b08f", "2144ea37bcab", "ebd6cf00bfa7",
  "5801e5552f24", "8c954aa18e59", "e0d4012395e3", "d728c9517bef",
  "90f577fd6976", "0581ff4913f0", "859b91e38680", "95ebb3020bff",
  "188efe0ff806", "40545e6cbbaa", "6a79b15e9ef7", "3d26abcb945d",
  "b476b2f78f25", "f239dbac03b0", "4b43967f5fbd", "8ea790547f96",
  "dbfe8a84389c", "bfaf7863d538", "5b4b77f9e81c", "fcb9d1c161df",
  "65e9a1323500", "526ef5ca58a8", "b31de7c52e5c", "1b6f694361a1",
  "943f03fe6d87", "f50bd6603e42", "2dd50a989a7c", "dd2d7e769b47",
  "2b347f3641c6", "ce95dda16049", "9ebf2b4b63ff", "ee506214e211",
  "4226cac848e4", "a846c73a59ad", "20351bc13ff8", "6ececa0d6d2d",
  "b2e941ea7c88", "41fe8a636cee", "b4b9ff99eecf", "89e11246d8a2",
];
/**
 * Thirty seconds of the same round with a smoke grenade thrown into it: seed 7
 * on de_forge again, so the only difference between this and the pin above is
 * the canister. `SMOKE_SCRIPT` in `replay.ts` says what the person does; what
 * matters is the shape of what follows, and it is in the checkpoints.
 *
 * The first second is the freeze before either script has bought anything and
 * hashes identically to ROUND's; second 2 is where the two part, because the
 * two scripts buy different things. The canister is thrown at tick 640, its
 * fuse runs out a second and a half later and it opens once it has come to
 * rest; from there the ball grows over a second and a half, stands for eleven,
 * and thins away over two and a half, and the round plays on for six more
 * seconds with the sightline back — because a bot that cannot see through a
 * cloud picks another fight and walks another way, and one that can goes back
 * to picking the first.
 *
 * This is the pin the whole issue is about. The cloud's own arithmetic is
 * tested in `grenade.test.ts` and the sight test in `world.test.ts`; what only a
 * digest can hold is that a cloud standing in a round *changes the round*, tick
 * for tick, and goes on changing it the same way tomorrow.
 */
const SMOKE_SECONDS_LONG = 30;
const SMOKE_TICKS = SMOKE_SECONDS_LONG * TICKS_PER_SECOND;
const SMOKE_ROUND = "6484de2cd2ba8f6b9beba2620c1432f9701b64eea95b0710674cc9e2cf59b841";
const SMOKE_ROUND_SECONDS: readonly string[] = [
  "c858433691b7", "ae8816aaf901", "28196227d006", "5dd7f1376bf8",
  "764ca02fa9f0", "5ffb3df0e281", "1bd6a3521cb1", "59fde5add12d",
  "6c43f1cba43b", "78791606a640", "37beb5da7147", "18f2f45184e2",
  "c83eb155baee", "c3d81a2d00f8", "961ca06c12b0", "3e98ea17a149",
  "de868179bf35", "6134bc3a91eb", "66705f6c4e85", "41500f852715",
  "82b63aa21f80", "7221bbca2d61", "4bf7ac3920dc", "d9f786de91cf",
  "a6197ae41785", "a6a828c675b7", "bf6377ccc22d", "d8a7a7d93b84",
  "64b65f8f4879", "cb3d1576cec1",
];
const SMOKE_PIN: Pin = {
  label: "round with a smoke in it", constant: "SMOKE_ROUND",
  digest: SMOKE_ROUND, seconds: SMOKE_ROUND_SECONDS,
};
/** The smoked round, exactly as its pin was taken. */
const smokeRun = (): Run =>
  withoutEntropy(() =>
    digest(createWorld(DE_FORGE, SHORT, "me", "ct", 5, 7), SMOKE_TICKS, SMOKE_SCRIPT));
const ROUND_PIN: Pin = { label: "ten-bot round", constant: "ROUND", digest: ROUND, seconds: ROUND_SECONDS };
const DUEL_PIN: Pin = { label: "arena duel", constant: "DUEL", digest: DUEL, seconds: DUEL_SECONDS };
@@ -161,6 +219,37 @@
test("a seeded ten-bot round plays exactly as it played", () => {
  expect(run.seconds).toEqual(ROUND_SECONDS);
});
test("a seeded round with a smoke grenade thrown into it plays exactly as it played", () => {
  const run = smokeRun();
  must(run, SMOKE_PIN);
  expect(run.digest).toBe(SMOKE_ROUND);
  expect(run.ticks).toBe(SMOKE_TICKS);
  expect(run.seconds).toEqual([...SMOKE_ROUND_SECONDS]);
  // The same seed on the same map: the first second, before either script has
  // bought anything, is the same second to the character. Everything after the
  // cloud opens is not, which is the whole claim — a cloud changes what a round
  // does, and goes on changing it the same way.
  expect(run.seconds[0]).toBe(ROUND_SECONDS[0]);
  expect(run.seconds[12]).not.toBe(ROUND_SECONDS[12]);
});
/** A cloud really did stand in the pinned run, rather than the script missing. */
test("the smoked round has a cloud standing in it, and it is gone by the end", () => {
  const stood = withoutEntropy(() => {
    const world = createWorld(DE_FORGE, SHORT, "me", "ct", 5, 7);
    const next = reader(SMOKE_SCRIPT);
    let widest = 0;
    for (let tick = 0; tick < SMOKE_TICKS; tick++) {
      update(world, TICK, next(tick, world, world.me));
      for (const cloud of world.clouds) widest = Math.max(widest, cloudRadius(cloud, world.time));
    }
    return { widest, left: world.clouds.length, pocket: world.me.pocket.smoke };
  });
  expect(stood.widest).toBeCloseTo(SMOKE.smoke.radius, 3);
  expect(stood.left).toBe(0);
  expect(stood.pocket).toBe(0);
});
test("a seeded duel in the training arena plays exactly as it played", () => {
  const run = duelRun();
  must(run, DUEL_PIN);
@@ -228,26 +317,26 @@
const OPEN_MAP = "f5ec0f03c150cdbc92359df63271653c6a2be8c0f485bdf86d028f636eacd9
const OPEN_MAP_BANDS: readonly string[] = [
  "f6fa28441414", "aab631e1a5fa", "ebc69b760b9d", "db19d9a43600",
];
const OPEN_ROUND = "b5d418adfbadc051285a06177f7e97ad15ce5ffde347cf8e51f47da76ea9e496";
const OPEN_ROUND = "0e66a5e70cb3a08e2223ae783e71eadcd2921ab72c24ade58ad273f46949c792";
const OPEN_ROUND_SECONDS: readonly string[] = [
  "1ad83b1cc8ed", "230f205bffb1", "9a22187ee262", "b1a1b9f147cb",
  "52bd60b8b4c1", "219b9ec017a2", "e143e86a3980", "3f54189e301c",
  "6499a8a1375d", "a87763d45101", "a012a6608bfe", "81b538e9769f",
  "bcd612a208ca", "a45c2ba991f2", "cc2cf4a19c6a", "0b095af1719b",
  "5fda5a176d18", "366a4f144a4e", "09fa64b30ca6", "066be5b8acf8",
  "6d0fbacbd279", "1f2bb687d697", "1e9a0750ec3a", "31e71073342a",
  "eb30f1715453", "95ae3acb2964", "818975909e82", "f1ee5d766f18",
  "bb0c65852bf7", "7b9793596110", "29feef4fb8f3", "137e09c5c485",
  "e82aa824dc98", "495ca8c2ef53", "c2b9abc2c229", "ef673bdf0f71",
  "271dff4a23ae", "a7b9a6f6d084", "0437a724cd8e", "ab60865f4146",
];
const TIGHT_MAP = "4bd818fd2e654f16fb41b6bd718951acbb22ac24572162a2be348e7edfcccc15";
const TIGHT_MAP_BANDS: readonly string[] = [
  "1ca81af8ea02", "c4888f792a55", "d08dbb1ee415", "1efd9cc4a8e9",
];
const TIGHT_ROUND = "b283d2d6cf8b2c82d80e3d2f8e1b9bfb8f731dd70009310b12a930a056876223";
const TIGHT_ROUND = "794c2c6cbb53f2fb6290641e3b7d584c4ef77967c26bab3253550086e6be105d";
const TIGHT_ROUND_SECONDS: readonly string[] = [
  "1ad83b1cc8ed", "230f205bffb1", "9a22187ee262", "b1a1b9f147cb",
  "52bd60b8b4c1", "219b9ec017a2", "e143e86a3980", "8c22014cab10",
  "6707adad67e0", "79b78073cafe", "b8a200b895d9", "40375defc572",
  "6e4039ce2f67", "e7a50e9bb180", "0e56112c62be", "e2d9f7b0b01b",
  "5e358b1dce56", "04a9df6200ea", "a575c4789200", "a32602bcecdf",
  "6d0fbacbd279", "1f2bb687d697", "1e9a0750ec3a", "31e71073342a",
  "eb30f1715453", "95ae3acb2964", "818975909e82", "185485d36211",
  "24dcd109d121", "005682b4d399", "1d865b0a75a8", "2bf98b93a745",
  "e0785e7358eb", "29d2cda90977", "3a93a3ee310e", "ddf65d1e134e",
  "c914eacf7106", "88d6ad2428e3", "16d50610dbdb", "7e2e5a7f5f7d",
];
const OPEN: Generated = {
@@ -10,9 +10,9 @@
 * and updates the constant in the same pull.
 *
 * What is hashed is the simulation and nothing else — PLAYER_FIELDS,
 * GRENADE_FIELDS and MATCH_FIELDS below are the whole list. Effects, the kill feed and the
 * messages are presentation: they would make the digest fragile and would
 * catch nothing the state does not already catch.
 * GRENADE_FIELDS, CLOUD_FIELDS and MATCH_FIELDS below are the whole list.
 * Effects, the kill feed and the messages are presentation: they would make the
 * digest fragile and would catch nothing the state does not already catch.
 *
 * The folding itself is `src/engine/digest.ts`, because the range needed the
 * same instrument and may not import this file. What stays here is what is the
@@ -23,7 +23,8 @@
import { compare as complain, fold as foldTicks, quantise } from "../engine/index.ts";
import { buy, type BuyItem } from "./economy.ts";
import { NO_INPUT, update, type Input, type Player, type World } from "./world.ts";
import type { Grenade } from "./grenade.ts";
import { cloudRadius, type Cloud, type Grenade } from "./grenade.ts";
import type { ThrownId } from "./weapons.ts";
import type { MatchState, Phase } from "./match.ts";
export const TICK = 1 / 64;
@@ -57,6 +58,7 @@
export const PLAYER_FIELDS: { name: string; of: (p: Player) => number }[] = [
  // What is in each pocket: bought, thrown, and lost with the body that held it.
  { name: "he", of: (p) => p.pocket.he },
  { name: "flash", of: (p) => p.pocket.flash },
  { name: "smoke", of: (p) => p.pocket.smoke },
  // How long this body cannot see for. It is simulation, not presentation: the
  // white-out a person gets and the shaky hands a bot gets are both read off it.
  { name: "blind", of: (p) => p.blind },
@@ -77,7 +79,28 @@
export const GRENADE_FIELDS: { name: string; of: (g: Grenade) => number }[] = [
  { name: "fuse", of: (g) => g.fuse },
  // Which kind it is — an HE and a flashbang fly identically and end very
  // differently, so two otherwise equal ticks are not the same state.
  { name: "kind", of: (g) => (g.weapon === "flash" ? 1 : 0) },
  { name: "kind", of: (g) => KINDS.indexOf(g.weapon) },
];
/** The order a grenade's kind is hashed in. Widened by a new thrown weapon. */
const KINDS: ThrownId[] = ["he", "flash", "smoke"];
/**
 * Everything hashed about a cloud of smoke standing in the round: where it is,
 * and how wide it is on this tick. The radius rather than the second it opened
 * because the radius is what the simulation *acts* on — `canSee` traces against
 * exactly this number — and because it moves every tick while the cloud grows
 * and again while it thins, so a cloud that opened a tick early or late is a
 * different run from the second it opened.
 *
 * Like the grenades, the count goes in first: a tick with one cloud standing
 * and a tick with none are different states and hash differently.
 */
export const CLOUD_FIELDS: { name: string; of: (c: Cloud, world: World) => number }[] = [
  { name: "pos.x", of: (c) => c.pos[0] },
  { name: "pos.y", of: (c) => c.pos[1] },
  { name: "pos.z", of: (c) => c.pos[2] },
  { name: "radius", of: (c, world) => cloudRadius(c, world.time) },
];
/** Everything hashed about the match. */
@@ -94,6 +117,8 @@
export function snapshot(world: World): string {
  for (const p of world.players) for (const field of PLAYER_FIELDS) parts.push(quantise(field.of(p)));
  parts.push(quantise(world.grenades.length));
  for (const g of world.grenades) for (const field of GRENADE_FIELDS) parts.push(quantise(field.of(g)));
  parts.push(quantise(world.clouds.length));
  for (const c of world.clouds) for (const field of CLOUD_FIELDS) parts.push(quantise(field.of(c, world)));
  for (const field of MATCH_FIELDS) parts.push(quantise(field.of(world.match)));
  return `${parts.join(",")}\n`;
}
@@ -150,6 +175,47 @@
export const SCRIPT: Beat[] = [
  { atTick: 2496, input: {} },
];
/**
 * Thirty seconds with a smoke grenade in them. The script above throws nothing
 * — the bots buy no grenades and the scripted person never presses a throw key
 * — so before this every pinned run in this repository had an empty `clouds`
 * list on every tick, and the one thing in the simulation that can take a
 * sightline away was pinned by nothing at all.
 *
 * This one buys a smoke in the freeze, walks out of spawn and throws it at
 * tick 640 — four seconds into the live round, which is early enough that the
 * cloud is standing while the two sides are still walking towards each other.
 * From there the fuse, the canister settling, the ball growing over a second
 * and a half, fifteen seconds of it standing between whoever is on either side
 * of it, and the two and a half seconds of it thinning away are all inside the
 * run: the last second of the cloud is second 24, and the six after it are the
 * round playing on with the sightline back.
 *
 * What it pins is not the cloud's arithmetic, which has its own tests. It is
 * that a cloud *changes the round* — a bot that cannot see through one picks
 * another fight, walks another way, and everything downstream of that moves
 * with it.
 */
export const SMOKE_SCRIPT: Beat[] = [
  { atTick: 0, input: {} },
  { atTick: 64, input: {}, buy: "smoke" }, // 300 of the 800 start money
  { atTick: 512, input: { forward: 1 } }, // the round goes live
  { atTick: 608, input: { forward: 1, side: 1 } },
  // One press of the throw key, one canister out of the pocket.
  { atTick: 640, input: { forward: 1, throwing: "smoke" } },
  { atTick: 648, input: { forward: 1 } },
  { atTick: 832, input: { forward: 1, side: -1 } },
  { atTick: 960, input: { fire: true } },
  { atTick: 976, input: {} },
  { atTick: 1088, input: { reload: true } },
  { atTick: 1096, input: { forward: 1 } },
  { atTick: 1280, input: { use: true } },
  { atTick: 1408, input: { forward: 1, duck: true } },
  { atTick: 1536, input: { forward: -1 } },
  { atTick: 1792, input: { side: 1, walk: true } },
  { atTick: 1920, input: {} },
];
/**
 * A cursor over the script: hand it a tick and it returns the input held at
 * that tick, taking any buy on the way past. The input is a fresh object each
@@ -222,6 +288,7 @@
export function compare(run: Run, pin: Pin): string | null {
      hashes:
        `${PLAYER_FIELDS.map((f) => f.name).join(", ")} per player, ` +
        `${GRENADE_FIELDS.map((f) => f.name).join(", ")} per live grenade, ` +
        `${CLOUD_FIELDS.map((f) => f.name).join(", ")} per standing cloud, ` +
        `and ${MATCH_FIELDS.map((f) => f.name).join(", ")}`,
      every: TICKS_PER_SECOND,
      unit: "second",
@@ -21,6 +21,8 @@
import {
  clamp, createScene as createPooledScene, effectAt, hullHeight, nextInstance, pushLine, resetScene,
  type Camera, type Scene as Frame, type Vec3,
} from "../engine/index.ts";
import { cloudRadius } from "./grenade.ts";
import { CLOUD_MESH_RADIUS } from "./models.ts";
import { CS_HULL } from "./movement.ts";
import { FLASH, HE, WEAPONS } from "./weapons.ts";
import type { Player, World } from "./world.ts";
@@ -51,12 +53,16 @@
export const LINE_CAPACITY = 4096;
/**
 * Instances one frame may place: the level, every other living player and the
 * bomb, which is eleven in the 5v5 `main.ts` starts. The pool is built at this
 * size once and never grows, so the headroom is for a bigger match rather than
 * for a busy frame; past it a player is simply not drawn, which is the engine's
 * bomb, which is eleven in the 5v5 `main.ts` starts, plus whatever is thrown —
 * up to three grenades in the air per body, and up to one cloud of smoke per
 * body standing for fifteen seconds. Ten clouds and ten bodies is thirty-one
 * before a single grenade is in the air, which is what moved this number from
 * 32 to 48: a frame in which a whole side smoked a site at once was already
 * dropping instances at the old cap. The pool is built at this size once and
 * never grows; past it a thing is simply not drawn, which is the engine's
 * policy at a cap and the same one `LINE_CAPACITY` has always had.
 */
export const INSTANCE_CAPACITY = 32;
export const INSTANCE_CAPACITY = 48;
/** How long a blast is drawn for, in seconds, and in how many spokes. */
const BLAST_SECONDS = 0.45;
@@ -74,6 +80,18 @@
const TEAM_TINT: Record<string, Tint> = {
};
const WHITE: Tint = [1, 1, 1];
/**
 * What a cloud is tinted. The mesh is painted with the sand layer — smooth fbm
 * noise, no seam and no straight line — and sand is (196, 174, 132), so these
 * three numbers are what turn it into a cool pale grey of about (210, 214, 224)
 * before the renderer's light touches it. Brighter than white on blue on
 * purpose: smoke lit from a sky is cooler than the ground it is standing on.
 */
const SMOKE_TINT: Tint = [1.07, 1.23, 1.7];
/** Which body a thrown thing is drawn as, by kind. */
const GRENADE_MESH: Record<string, string> = { he: "grenade", flash: "flash", smoke: "smoke" };
const ORIGIN: Vec3 = [0, 0, 0];
/**
@@ -108,14 +126,22 @@
export function createScene(): Scene {
  };
}
/** One mesh placed, or nothing at all once the pool is spent. */
function place(scene: Scene, mesh: string, pos: Vec3, yaw: number, scale: number, tint: Tint): void {
/**
 * One mesh placed, or nothing at all once the pool is spent. `size` is how big
 * the mesh stands beside the size it was built at, and is 1 for every model in
 * this game but the cloud, which is one ball uploaded once and drawn at
 * whatever radius it has grown to.
 */
function place(
  scene: Scene, mesh: string, pos: Vec3, yaw: number, scale: number, tint: Tint, size = 1,
): void {
  const into = nextInstance(scene);
  if (into === null) return;
  into.mesh = mesh;
  into.pos[0] = pos[0]; into.pos[1] = pos[1]; into.pos[2] = pos[2];
  into.yaw = yaw;
  into.scale = scale;
  into.size = size;
  into.tint[0] = tint[0]; into.tint[1] = tint[1]; into.tint[2] = tint[2];
}
@@ -153,7 +179,22 @@
export function buildScene(world: World, camera: Camera, into: Scene, view: Play
  // the yaw is the simulated time, so a frame decides nothing and a paused
  // one turns it no further.
  for (const g of world.grenades)
    place(into, g.weapon === "flash" ? "flash" : "grenade", g.pos, g.onGround ? 0 : world.time * 540, 1, WHITE);
    place(into, GRENADE_MESH[g.weapon] ?? "grenade", g.pos, g.onGround ? 0 : world.time * 540, 1, WHITE);
  // Every cloud standing, as the ball the simulation traces against: the same
  // centre and the same radius `canSee` reads, so what fills the screen and
  // what takes a sightline away are one object. It is opaque and it is drawn in
  // the pass that was already here — no blend, no sort, no second texture — and
  // being *inside* one is drawn by `hud.ts` instead, because the far faces of a
  // ball you are standing in are culled and there is nothing left to see.
  for (const cloud of world.clouds) {
    const radius = cloudRadius(cloud, world.time);
    if (radius <= 0) continue;
    // A yaw off its own position, so two clouds on one site are not one mesh
    // stamped twice. It is a fact about where it opened and never about the
    // frame, so a paused game turns it no further.
    place(into, "cloud", cloud.pos, (cloud.pos[0] + cloud.pos[1] * 3) % 360, 1, SMOKE_TINT,
      radius / CLOUD_MESH_RADIUS);
  }
  // --- tracers, sparks and the planted bomb's beam, all as lines
  // Read by index, oldest first: the effects are the engine's ring and a
@@ -191,6 +232,9 @@
export function buildScene(world: World, camera: Camera, into: Scene, view: Play
      // radius — which is why the reach is read off the weapon and not typed
      // twice — but it never brightens the screen from out here: what it costs
      // the person looking at it is `blind` in the simulation, and the HUD's.
      // A smoke has no star: the cloud it leaves is the drawing, and a flare
      // of light where a canister opened would say the wrong thing entirely.
      if (effect.weapon === "smoke") continue;
      const flash = effect.weapon === "flash";
      const seconds = flash ? FLASH_SECONDS : BLAST_SECONDS;
      if (age >= seconds) continue;
@@ -105,9 +105,9 @@
test("the flashbang is in the table with its own numbers, and no bullet ones", (
  expect(FLASH.magazine).toBe(0);
  expect(FLASH.blast).toBeUndefined();
  expect(HE.flash).toBeUndefined();
  // Both are thrown, and nothing else in the table is.
  // All three are thrown, and nothing else in the table is.
  expect(Object.values(WEAPONS).filter((w) => isThrown(w.id)).map((w) => w.id).sort())
    .toEqual(["flash", "he"]);
    .toEqual(["flash", "he", "smoke"]);
  // Adding it did not move a gun's spray: the patterns are seeded by index and
  // the thrown weapons are last, so the AK's tenth bullet is the AK's tenth.
  expect(recoilOffset("ak47", 9)).toEqual(recoilOffset("ak47", 9));
@@ -19,13 +19,15 @@
import { clamp, rng } from "../engine/index.ts";
export type WeaponId =
  | "knife" | "glock" | "usp" | "deagle" | "mp9" | "ak47" | "m4a4" | "awp" | "he" | "flash";
  | "knife" | "glock" | "usp" | "deagle" | "mp9" | "ak47" | "m4a4" | "awp"
  | "he" | "flash" | "smoke";
/** The weapons that are thrown rather than fired: the two kinds in a pocket. */
export type ThrownId = "he" | "flash";
/** The weapons that are thrown rather than fired: the three kinds in a pocket. */
export type ThrownId = "he" | "flash" | "smoke";
/** Is this a weapon somebody throws? Narrows the id as well as answering. */
export const isThrown = (id: WeaponId): id is ThrownId => id === "he" || id === "flash";
export const isThrown = (id: WeaponId): id is ThrownId =>
  id === "he" || id === "flash" || id === "smoke";
/**
 * What a thrown weapon does when its fuse runs out. Only the HE has one,
@@ -51,6 +53,27 @@
export type Flash = {
  awayAngle: number; // degrees; at or past this it went off behind you and is nothing
};
/**
 * What a smoke grenade does when its fuse runs out: it takes *sight*, and not
 * from one body at one instant like a flash does but from everybody, for as
 * long as the cloud stands. These five numbers are the whole of it — no hit
 * point, no armour and nobody to credit.
 *
 * The cloud is a ball, and that is a decision rather than a shortcut: a ball is
 * the one shape a sight test can be answered against for a dot product and a
 * square root (`segmentSphere` in `src/engine/trace.ts`), and a sight test is
 * already on the hot path ten times a tick. What it costs is measured in
 * `src/budget.test.ts`.
 */
export type Smoke = {
  fuse: number; // seconds from leaving the hand to the canister opening
  radius: number; // units; the ball, once it has grown
  grow: number; // seconds from the pop to the full radius
  /** Seconds from the pop to nothing at all, the thinning below included. */
  life: number;
  fade: number; // seconds of that life it spends shrinking back to nothing
};
export type Weapon = {
  id: WeaponId;
  name: string;
@@ -75,6 +98,8 @@
export type Weapon = {
  blast?: Blast;
  /** Set on the flashbang, and on nothing else. */
  flash?: Flash;
  /** Set on the smoke grenade, and on nothing else. */
  smoke?: Smoke;
};
/** The HE grenade, by the name everything that throws one calls it. */
@@ -89,8 +114,28 @@
export const HE: Weapon & { blast: Blast } = { id: "he", name: "HE Grenade", kin
 */
export const FLASH: Weapon & { flash: Flash } = { id: "flash", name: "Flashbang", kind: "grenade", team: "both", price: 200, damage: 0, armorPenetration: 0, rangeModifier: 1, rpm: 0, magazine: 0, reserve: 0, reloadTime: 0, killReward: 300, carrySpeed: 245, spread: 0, moveSpread: 0, recoil: 0, automatic: false, flash: { fuse: 1.6, radius: 1200, maxBlind: 1.6, fullAngle: 30, awayAngle: 135 } };
/** The fuse on a thrown weapon, in seconds: the one number both kinds have. */
export const fuseOf = (weapon: Weapon): number => weapon.blast?.fuse ?? weapon.flash?.fuse ?? 0;
/**
 * The smoke grenade. CS's $300, and the only thing in this table that changes
 * how a round is *played* rather than how a fight ends: a ball 180 units across
 * the radius — about three and a half metres, wide enough to cover a doorway or
 * the mouth of a site and not a whole room — standing for fifteen seconds,
 * which is a quarter of a round and long enough to take a sightline out of the
 * fight it was going to decide.
 *
 * It grows over a second and a half rather than appearing, and spends its last
 * two and a half shrinking back to nothing, so there is no tick at which a
 * sightline blinks shut or blinks open: what the screen shows and what
 * `canSee` answers are the same radius, read off the same clock.
 *
 * The fuse is the HE's 1.5 seconds, but it is not the whole story — a smoke
 * opens where the canister *stopped*, so `spent` in `src/client/grenade.ts`
 * holds it until the thing has come to rest.
 */
export const SMOKE: Weapon & { smoke: Smoke } = { id: "smoke", name: "Smoke Grenade", kind: "grenade", team: "both", price: 300, damage: 0, armorPenetration: 0, rangeModifier: 1, rpm: 0, magazine: 0, reserve: 0, reloadTime: 0, killReward: 300, carrySpeed: 245, spread: 0, moveSpread: 0, recoil: 0, automatic: false, smoke: { fuse: 1.5, radius: 180, grow: 1.5, life: 15, fade: 2.5 } };
/** The fuse on a thrown weapon, in seconds: the one number all three kinds have. */
export const fuseOf = (weapon: Weapon): number =>
  weapon.blast?.fuse ?? weapon.flash?.fuse ?? weapon.smoke?.fuse ?? 0;
const WEAPON_LIST: Weapon[] = [
  { id: "knife", name: "Knife", kind: "knife", team: "both", price: 0, damage: 55, armorPenetration: 0.85, rangeModifier: 1, rpm: 240, magazine: 0, reserve: 0, reloadTime: 0, killReward: 1500, carrySpeed: 250, spread: 0, moveSpread: 0, recoil: 0, automatic: true },
@@ -104,15 +149,17 @@
const WEAPON_LIST: Weapon[] = [
  { id: "ak47", name: "AK-47", kind: "rifle", team: "t", price: 2700, damage: 36, armorPenetration: 0.775, rangeModifier: 0.98, rpm: 600, magazine: 30, reserve: 90, reloadTime: 2.5, killReward: 300, carrySpeed: 215, spread: 0.16, moveSpread: 3.4, recoil: 1.5, automatic: true },
  { id: "m4a4", name: "M4A4", kind: "rifle", team: "ct", price: 3100, damage: 33, armorPenetration: 0.7, rangeModifier: 0.97, rpm: 666, magazine: 30, reserve: 90, reloadTime: 3.1, killReward: 300, carrySpeed: 225, spread: 0.15, moveSpread: 3.2, recoil: 1.25, automatic: true },
  { id: "awp", name: "AWP", kind: "sniper", team: "both", price: 4750, damage: 115, armorPenetration: 0.975, rangeModifier: 0.99, rpm: 41, magazine: 10, reserve: 30, reloadTime: 3.7, killReward: 100, carrySpeed: 200, spread: 0.05, moveSpread: 12, recoil: 3.5, zoom: 40, automatic: false },
  // The thrown weapons. Their bullet numbers are the empty ones — neither is
  // ever held, fired or reloaded — and everything they do is in `blast` and
  // `flash`: CS's $300 HE, 98 hit points at the centre falling off over 350
  // units on a 1.5-second fuse with armour stopping about half of it, and CS's
  // $200 flashbang, which takes sight instead. They are last in the list on
  // The thrown weapons. Their bullet numbers are the empty ones — none of them
  // is ever held, fired or reloaded — and everything they do is in `blast`,
  // `flash` and `smoke`: CS's $300 HE, 98 hit points at the centre falling off
  // over 350 units on a 1.5-second fuse with armour stopping about half of it;
  // CS's $200 flashbang, which takes sight for a moment; and CS's $300 smoke,
  // which takes a sightline for fifteen seconds. They are last in the list on
  // purpose: the spray patterns below are seeded by index, so a thrown weapon
  // added here never moves a gun's pattern.
  HE,
  FLASH,
  SMOKE,
];
export const WEAPONS: Record<WeaponId, Weapon> = Object.fromEntries(
@@ -7,10 +7,16 @@
import { SHORT } from "./match.ts";
import { WEAPONS } from "./weapons.ts";
import { buy } from "./economy.ts";
import {
  applyInput, createWorld, currentWeapon, EFFECT_CAPACITY, NO_INPUT, shoot, startRound, update,
  applyInput, canSee, createWorld, currentWeapon, EFFECT_CAPACITY, eyePos, insideSmoke, NO_INPUT,
  shoot, startRound, throwOne, update,
  type Input, type Player, type Sound, type World,
} from "./world.ts";
import { effectAt, pushEffect, type Burst, type SoundDevice, type Tone, type Vec3 } from "../engine/index.ts";
import { cloudRadius, type Cloud } from "./grenade.ts";
import { SMOKE } from "./weapons.ts";
import { CS_HULL } from "./movement.ts";
import {
  effectAt, eyeHeight, pushEffect, type Burst, type SoundDevice, type Tone, type Vec3,
} from "../engine/index.ts";
const TICK = 1 / 64;
const run = (world: World, seconds: number, input: Input = NO_INPUT): void => {
@@ -324,3 +330,70 @@
test("a match plays itself to the end inside its own time", () => {
  expect(world.match.matchWinner).not.toBe(null);
  expect(Math.max(world.match.score.t, world.match.score.ct)).toBe(2);
});
// --- smoke ----------------------------------------------------------------
/**
 * A cloud standing between two bodies, placed by hand rather than thrown: what
 * is under test here is the sight rule, and a throw is `grenade.test.ts`'s.
 */
const BOX = DE_FORGE;
const smoked = (world: World, at: Vec3, agoSeconds = SMOKE.smoke.grow): void => {
  world.clouds.push({ pos: at, born: world.time - agoSeconds, owner: 0 });
};
test("a cloud takes a sightline away, and gives it back when it has thinned out", () => {
  const world = createWorld(BOX, SHORT, "me", "ct", 2, 5);
  const [a, b] = world.players as [Player, Player];
  a.pos = [0, 0, 0];
  b.pos = [400, 0, 0];
  a.alive = b.alive = true;
  expect(canSee(world, a, b)).toBe(true);
  // Halfway between them, grown: neither can see the other, either way round.
  smoked(world, [200, 0, eyeHeight(a, CS_HULL)]);
  expect(canSee(world, a, b)).toBe(false);
  expect(canSee(world, b, a)).toBe(false);
  // And a body standing in one is blind in every direction, which is the whole
  // of why `segmentSphere` answers a start inside the ball with "yes".
  a.pos = [200, 0, 0];
  expect(canSee(world, a, b)).toBe(false);
  expect(insideSmoke(world, eyePos(a))).toBe(true);
  // Past the end of its life it is nothing at all: the line is back.
  (world.clouds[0] as { born: number }).born = world.time - SMOKE.smoke.life;
  a.pos = [0, 0, 0];
  expect(canSee(world, a, b)).toBe(true);
});
test("a cloud beside the line, behind the eye or past the target is not in the way", () => {
  const world = createWorld(BOX, SHORT, "me", "ct", 2, 5);
  const [a, b] = world.players as [Player, Player];
  a.pos = [0, 0, 0];
  b.pos = [400, 0, 0];
  const eye = eyeHeight(a, CS_HULL);
  for (const at of [[200, 400, eye], [-400, 0, eye], [900, 0, eye]] as Vec3[]) {
    world.clouds = [];
    smoked(world, at);
    expect(canSee(world, a, b)).toBe(true);
  }
});
test("a smoke grenade waits to come to rest, then stands its stated life", () => {
  const world = createWorld(BOX, SHORT, "me", "ct", 2, 9);
  world.match.phase = "live";
  const me = world.me;
  me.pocket.smoke = 1;
  expect(throwOne(world, me, "smoke")).toBe(true);
  // It is still a grenade while its fuse burns, and no cloud exists yet.
  for (let i = 0; i < Math.round(SMOKE.smoke.fuse * 64); i++) update(world, 1 / 64, NO_INPUT);
  expect(world.clouds.length).toBe(0);
  // It opens once it has settled, and the ball grows from nothing.
  for (let i = 0; i < 64 * 2; i++) update(world, 1 / 64, NO_INPUT);
  expect(world.grenades.length).toBe(0);
  expect(world.clouds.length).toBe(1);
  const cloud = world.clouds[0] as Cloud;
  expect(cloudRadius(cloud, cloud.born + SMOKE.smoke.grow)).toBeCloseTo(SMOKE.smoke.radius, 6);
  // And it is gone by the end of its life, list and all.
  for (let i = 0; i < 64 * (SMOKE.smoke.life + 1); i++) update(world, 1 / 64, NO_INPUT);
  expect(world.clouds.length).toBe(0);
});
@@ -8,7 +8,9 @@
 * the one thing in a round that is not a person: `src/client/grenade.ts` says
 * how one flies and what its blast reaches, and what a blast *means* — the
 * damage, the hit marker, the line in the feed — is here with every other kind
 * of harm.
 * of harm. One of the three leaves something behind: a smoke grenade opens into
 * a `Cloud`, the world keeps the list of them, and `canSee` at the foot of this
 * file is where a cloud stops being a picture and becomes a wall.
 *
 * The simulation runs at a fixed 64 ticks a second and knows nothing about
 * WebGL, so it can be stepped in a test without a browser.
@@ -18,14 +20,15 @@
import { beepDue, dropBomb, giveBomb, newBomb, updateBomb, type Bomb } from "./b
import { applyDamage, applyHit, traceBullet, type Actor } from "./combat.ts";
import { emptyAmmo, type Ammo } from "./economy.ts";
import {
  blastCentre, blastHits, flashHits, stepGrenade, throwGrenade, THROW_LIFT,
  type Grenade, type GrenadeSound,
  blastCentre, blastHits, cloudFrom, cloudGone, cloudRadius, flashHits, spent, stepGrenade,
  throwGrenade, THROW_LIFT,
  type Cloud, type Grenade, type GrenadeSound,
} from "./grenade.ts";
import type { Level } from "./level.ts";
import type { RoundPlan } from "../plan/plan.ts";
import {
  angleVectors, angleDelta, clamp, createEffects, dist, expireEffects, eyeHeight, hullHeight, move,
  normalize, pushEffect, rng, sub, visible,
  normalize, pushEffect, rng, segmentSphere, sub, visible,
  type Body, type Effects, type Vec3, type Wish,
} from "../engine/index.ts";
import * as rules from "./match.ts";
@@ -53,7 +56,7 @@
export type Player = Actor & Body & {
  /**
   * What is in the pocket, by kind: at most `CARRY[kind]` of each, thrown one
   * at a time. A pocket rather than a count because a flashbang is carried
   * alongside the HE and not instead of it.
   * alongside the HE and the smoke, and not instead of either.
   */
  pocket: Record<ThrownId, number>;
  /**
@@ -172,6 +175,15 @@
export type World = {
  effects: Effects<Effect>;
  /** Every grenade in the air or on the floor right now, oldest first. */
  grenades: Grenade[];
  /**
   * Every cloud of smoke standing right now, oldest first. It is simulation and
   * not decoration: `canSee` below traces against these, so a cloud in this
   * list is a wall to everybody's eyes and a cloud out of it is not. A round
   * nobody threw a smoke in keeps an empty array, and every loop over it is a
   * length check — which is what makes the sight test cost the same as it
   * always did in the rounds that are most of them.
   */
  clouds: Cloud[];
  feed: FeedEntry[];
  messages: { at: number; text: string }[];
  /**
@@ -213,7 +225,7 @@
function makePlayer(id: number, team: Team, name: string, bot: boolean): Player
    money: 800,
    weapon: secondary, primary: null, secondary,
    ammo: { knife: { mag: 0, reserve: 0 }, [secondary]: emptyAmmo(secondary) },
    defuseKit: false, hasBomb: false, pocket: { he: 0, flash: 0 }, blind: 0,
    defuseKit: false, hasBomb: false, pocket: { he: 0, flash: 0, smoke: 0 }, blind: 0,
    nextShotAt: 0, reloadUntil: 0, shotIndex: 0, lastShotAt: -99, scoped: false,
    firedThisPress: false, threwThisPress: null,
    punch: [0, 0], stride: 0,
@@ -261,7 +273,8 @@
export function createWorld(
  const world: World = {
    match, players, me, time: 0,
    bomb: newBomb(),
    effects: createEffects<Effect>(EFFECT_CAPACITY), grenades: [], feed: [], messages: [], plan: null,
    effects: createEffects<Effect>(EFFECT_CAPACITY), grenades: [], clouds: [],
    feed: [], messages: [], plan: null,
    random, level, bombPlanted: false, pendingBuy: false,
  };
  startRound(world);
@@ -354,7 +367,7 @@
export function startRound(world: World): void {
    p.health = 100;
    // A grenade survives the round its owner did, like their gun does; one they
    // died holding is left on the floor with them.
    if (!p.alive) p.pocket = { he: 0, flash: 0 };
    if (!p.alive) p.pocket = { he: 0, flash: 0, smoke: 0 };
    p.alive = true;
    // A flash does not carry into the next round, however late it went off.
    p.blind = 0;
@@ -379,6 +392,10 @@
export function startRound(world: World): void {
  if (carrier !== undefined) world.bomb = giveBomb(carrier);
  world.bombPlanted = false;
  world.grenades = [];
  // A cloud does not outlive the round it was thrown in, however late it
  // opened: fifteen seconds of smoke standing through the next freeze would be
  // one side starting a round blind for something nobody did.
  world.clouds = [];
  world.feed = [];
  for (const p of world.players) if (p.bot) botBuy(world, p);
}
@@ -535,8 +552,11 @@
export function throwOne(world: World, p: Player, kind: ThrownId = "he"): boolea
function detonate(world: World, g: Grenade): void {
  const centre = blastCentre(g);
  record(world, { kind: "blast", at: world.time, pos: centre, weapon: g.weapon });
  heard(world, centre, g.weapon === "flash" ? "flash" : "blast", g.owner);
  heard(world, centre, g.weapon === "flash" ? "flash" : g.weapon === "smoke" ? "smoke" : "blast", g.owner);
  if (g.weapon === "flash") return blind(world, g);
  // A smoke hurts nobody and reaches nobody. What it does is *stay*: the
  // canister is spent, and the cloud it left is a thing the round now has.
  if (g.weapon === "smoke") return void world.clouds.push(cloudFrom(g, world.time));
  explode(world, g, centre);
}
@@ -574,18 +594,38 @@
function blind(world: World, g: Grenade): void {
  }
}
/** Every live grenade, one tick older: moved, heard, and detonated on time. */
/**
 * Every live grenade, one tick older: moved, heard, and detonated on time.
 *
 * "On time" is `spent` in `grenade.ts` rather than a zero on the fuse, because
 * a smoke waits for the floor. The list is filtered by the same question, so a
 * canister still rolling with its fuse past zero stays in the round instead of
 * disappearing on the tick it was supposed to open.
 */
function updateGrenades(world: World, dt: number): void {
  if (world.grenades.length === 0) return;
  let spent = false;
  let any = false;
  for (const g of world.grenades) {
    if (stepGrenade(g, dt, world.level.boxes)) heard(world, g.pos, "bounce", g.owner);
    if (g.fuse <= 0) {
    if (spent(g)) {
      detonate(world, g);
      spent = true;
      any = true;
    }
  }
  if (spent) world.grenades = world.grenades.filter((g) => g.fuse > 0);
  if (any) world.grenades = world.grenades.filter((g) => !spent(g));
}
/**
 * Clouds that have thinned away to nothing, dropped. A cloud at zero radius
 * blocks nothing and is drawn as nothing — `cloudRadius` answers the same
 * question every reader asks — so this is housekeeping and not a rule: what it
 * buys is that the loop in `canSee` stays short in a round where ten smokes
 * have been thrown over two minutes.
 */
function expireClouds(world: World): void {
  if (world.clouds.length === 0) return;
  if (world.clouds.some((cloud) => cloudGone(cloud, world.time)))
    world.clouds = world.clouds.filter((cloud) => !cloudGone(cloud, world.time));
}
// --- the bomb -------------------------------------------------------------
@@ -693,7 +733,7 @@
export function update(world: World, dt: number, input: Input): void {
        p.armor = 0;
        p.helmet = false;
        p.defuseKit = false;
        p.pocket = { he: 0, flash: 0 };
        p.pocket = { he: 0, flash: 0, smoke: 0 };
        p.secondary = p.team === "t" ? "glock" : "usp";
        p.ammo = { knife: { mag: 0, reserve: 0 }, [p.secondary]: emptyAmmo(p.secondary) };
        p.weapon = p.secondary;
@@ -719,6 +759,10 @@
export function update(world: World, dt: number, input: Input): void {
  // After everyone has moved, so a grenade is solved against where people
  // ended the tick rather than where they started it.
  updateGrenades(world, dt);
  // And the clouds the spent ones left, once they have thinned to nothing. A
  // cloud born on this very tick survives it: it is at zero radius and not at
  // the end of its life, which is the one instant the two differ at.
  expireClouds(world);
  // Once a tick, and not once per player: `bombTick` runs ten times and the
  // fuse is one clock.
  bombBeep(world, dt);
@@ -728,11 +772,49 @@
export function update(world: World, dt: number, input: Input): void {
  expireEffects(world.effects, world.time, EFFECT_LIFE);
}
/** Is `target` visible to `from`, eye to eye? Used by bots and by the HUD. */
/**
 * Is `target` visible to `from`, eye to eye? The one question the whole game
 * asks about sight: the bots pick their fights with it, a bot deciding whether
 * it is safe to cut a wire asks it, and the observation the policy is handed
 * carries its answer. So this is the single place a cloud has to be accounted
 * for, and it is.
 *
 * Two walls, in the order that costs least. The level first — fifty-odd boxes
 * through the engine's `visible`, which is the test this has always been — and
 * then the clouds, which in most rounds is an empty array and a length check.
 * Neither is cheaper to skip: a wall is still a wall inside a smoke.
 *
 * A cloud is solid to sight and not translucent: a line that clips the edge of
 * the ball is blocked exactly as one through the middle is. That is the
 * approximation this issue was allowed to make and it is the one that keeps the
 * test cheap — `segmentSphere` is a dot product and at most one square root —
 * and it is also what makes a body *standing in* a cloud blind in every
 * direction, which is what a smoke is for.
 */
export function canSee(world: World, from: Player, target: Player): boolean {
  return visible(eyePos(from), eyePos(target), world.level.boxes);
  const eye = eyePos(from);
  const at = eyePos(target);
  if (!visible(eye, at, world.level.boxes)) return false;
  return !throughSmoke(world, eye, at);
}
/**
 * Does the line from `eye` to `at` pass through any cloud standing right now?
 * Separate from `canSee` because a cloud is a fact about a *line* and not about
 * two players: the HUD asks it about the camera, and a test asks it about two
 * points nobody is standing on.
 */
export function throughSmoke(world: World, eye: Vec3, at: Vec3): boolean {
  for (const cloud of world.clouds) {
    if (segmentSphere(eye, at, cloud.pos, cloudRadius(cloud, world.time))) return true;
  }
  return false;
}
/** Is this point inside a cloud — is an eye here in the fog? */
export const insideSmoke = (world: World, at: Vec3): boolean =>
  world.clouds.some((cloud) => dist(at, cloud.pos) < cloudRadius(cloud, world.time));
export const facing = (p: Player, target: Vec3): number => {
  const to = sub(target, eyePos(p));
  const yaw = (Math.atan2(to[1], to[0]) * 180) / Math.PI;
@@ -176,6 +176,12 @@
index is carried so the thing you hit knows what it is made of — and a `Hit`
carries the fraction along the segment, the point, the normal and the thing that
was hit, which is whatever you put in the list.
And one shape that is not a box: `segmentSphere` answers whether a segment meets
a ball, for a dot product and at most one square root, with no allocation and no
hit record — it is in the way or it is not. It is what a cloud of smoke is made
of in the shooter, where it sits on the hot path of "can A see B" ten times a
tick, and it is the reason that question is still cheap with smoke in the round.
A shot in the example is one ray and one box, and it is the whole of hitscan:
`src/range/targets.ts` does the same against a list with `traceWorld`. A miss is
still a shot the player saw leave the barrel, so the tracer is written before the
@@ -19,7 +19,7 @@
export {
export type { Mat4, Vec3 } from "./math.ts";
/** Rays against axis-aligned boxes, and the `Box` they are traced against. */
export { rayBox, segmentLength, traceWorld, visible } from "./trace.ts";
export { rayBox, segmentLength, segmentSphere, traceWorld, visible } from "./trace.ts";
export type { Box, Hit } from "./trace.ts";
/**
@@ -1,5 +1,5 @@
{
  "version": "0.1.0",
  "version": "0.2.0",
  "names": [
    "Activations",
    "Adam",
@@ -161,6 +161,7 @@
    "sample",
    "scale",
    "segmentLength",
    "segmentSphere",
    "softmax",
    "stuck",
    "sub",
@@ -1,6 +1,13 @@
/**
 * Rays against boxes. Bullets are hitscan, sight is a ray, and both ask the
 * same question: what is the first thing between here and there.
 * Rays against boxes, and a segment against a sphere. Bullets are hitscan,
 * sight is a ray, and both ask the same question: what is the first thing
 * between here and there.
 *
 * A box is what a level is built of and a sphere is what a cloud is: the
 * shooter's smoke grenade is a ball nothing can see through, and a ball is the
 * one shape a segment can be tested against for the price of a dot product and
 * at most one square root — which is why it is here rather than approximated
 * out of boxes.
 */
import { sub, length, type Vec3 } from "./math.ts";
@@ -62,4 +69,45 @@
export function traceWorld(from: Vec3, to: Vec3, boxes: Box[]): Hit | null {
export const visible = (from: Vec3, to: Vec3, boxes: Box[]): boolean =>
  traceWorld(from, to, boxes) === null;
/**
 * Does the segment `from → to` meet the ball of radius `radius` about `centre`?
 * A segment and not a ray: a sphere behind you or past the far end is not in
 * the way, and both of those are cases a plain quadratic answers wrongly.
 *
 * The arithmetic, with `d = to − from` and `f = from − centre`:
 *
 *     |f + t·d|² = r²   →   (d·d)t² + 2(f·d)t + (f·f − r²) = 0
 *
 * `c = f·f − r²` at or below zero is a start already inside the ball, which is
 * a meeting whatever the roots say — and it is the case that is asked most, so
 * it is answered first and without the square root. Otherwise the ball is
 * entered at the smaller root, and the segment meets it exactly when that root
 * lies in [0, 1]: `t < 0` is a ball behind the eye and `t > 1` one past the
 * target. A degenerate segment — both ends the same point — has `a = 0`, and
 * the `c ≤ 0` answer above has already covered the only way it can meet.
 *
 * Nothing is allocated and nothing is returned but a boolean: what is wanted of
 * a cloud is whether it is in the way, never where it was entered.
 */
export function segmentSphere(from: Vec3, to: Vec3, centre: Vec3, radius: number): boolean {
  if (radius <= 0) return false;
  const fx = (from[0] as number) - (centre[0] as number);
  const fy = (from[1] as number) - (centre[1] as number);
  const fz = (from[2] as number) - (centre[2] as number);
  const c = fx * fx + fy * fy + fz * fz - radius * radius;
  if (c <= 0) return true;
  const dx = (to[0] as number) - (from[0] as number);
  const dy = (to[1] as number) - (from[1] as number);
  const dz = (to[2] as number) - (from[2] as number);
  const a = dx * dx + dy * dy + dz * dz;
  if (a <= 0) return false;
  const half = fx * dx + fy * dy + fz * dz;
  // The ball is wholly behind the eye: the near root cannot be positive.
  if (half >= 0) return false;
  const disc = half * half - a * c;
  if (disc < 0) return false;
  const t = (-half - Math.sqrt(disc)) / a;
  return t <= 1;
}
export const segmentLength = (from: Vec3, to: Vec3): number => length(sub(to, from));
@@ -449,6 +449,22 @@
export type Game = {
 * raw and 2,873 gzipped to spare, so no ceiling moved. Neither other bundle
 * changed a byte: nothing outside `src/client/` and `src/pages/game.ts` did.
 * Measured 2026-09-21.
 * #165 put the third grenade in the game — a smoke, which is the first thing
 * here that changes what a bot can *see*: a canister that waits until it has
 * come to rest, a `Cloud` the world keeps, `segmentSphere` behind the engine's
 * door, the ball `canSee` traces against, the lumpy mesh it is drawn as, the
 * wash the HUD puts over an eye inside one, the step `bots.ts` bends around
 * one, a sound, a key and a row in the weapon table. The app grew 3,067 raw /
 * 1,107 gzipped bytes for all of it: 95,598 → 98,665 raw and 37,788 → 38,895
 * gzipped. That is 665 bytes past the raw half of the 98,000 / 39,000 #214
 * brought *down*, and the gzipped half had 105 left, which is not headroom
 * anybody can land a feature in — so the ceiling is 103,000 / 41,000 here,
 * today's size plus about four per cent of raw and five of gzip, on the same
 * reasoning #164, #185 and #148 raised the last three. Neither other bundle
 * moved a byte: the range is 34,810 raw / 14,568 gzipped, the same numbers
 * #216 measured, and nothing outside `src/client/`, `src/engine/trace.ts` and
 * `src/pages/game.ts` changed — the range and the example ship no world, no
 * weapons and no cloud. Measured 2026-09-21.
 */
export const GAMES: readonly Game[] = [
  {
@@ -456,7 +472,7 @@
export const GAMES: readonly Game[] = [
    href: "/",
    label: "cs",
    entry: "src/client/main.ts",
    ceiling: { raw: 98_000, gzip: 39_000 },
    ceiling: { raw: 103_000, gzip: 41_000 },
    assets: [
      {
        name: "weights",
@@ -274,7 +274,7 @@
const menu = (visitor: Who, asked: Asked): string => `
      <div class="row"><button type="button" class="primary" id="play" disabled>Play</button></div>
      <p class="hint" id="prep">Preparing textures…</p>
      <p class="hint"><kbd>WASD</kbd> move · <kbd>Space</kbd> jump · <kbd>Ctrl</kbd> crouch · <kbd>Shift</kbd> walk ·
        mouse to aim and fire · <kbd>R</kbd> reload · <kbd>G</kbd> throw an HE · <kbd>T</kbd> throw a flashbang ·
        mouse to aim and fire · <kbd>R</kbd> reload · <kbd>G</kbd> throw an HE · <kbd>T</kbd> throw a flashbang · <kbd>V</kbd> throw a smoke ·
        <kbd>E</kbd> plant or defuse · <kbd>B</kbd> buy ·
        <kbd>1</kbd><kbd>2</kbd><kbd>3</kbd> guns · <kbd>Tab</kbd> scores · <kbd>F</kbd> full screen ·
        <kbd>Esc</kbd> or <kbd>P</kbd> pause</p>
@@ -420,6 +420,7 @@
export function gamePage(
          { action: "reload", label: "reload" },
          { action: "grenade", label: "nade" },
          { action: "flash", label: "flash" },
          { action: "smoke", label: "smoke" },
          { action: "buy", label: "buy" },
          { action: "fire", label: "fire" },
        ],
@@ -447,7 +448,12 @@
export function gamePage(
      the centre falling off over 350 units, on a 1.5-second fuse, and only to what it can see —
      and a flashbang thrown the same way, which takes sight rather than health: up to 1.6 seconds
      of it, by the angle you were looking at it from and how far away it went off, and none at all
      through a wall or over your shoulder.
      through a wall or over your shoulder, and a smoke grenade, which is the one that changes how
      a round is played: it opens where the canister came to rest and stands a ball 180 units
      across for fifteen seconds, growing and thinning on the round's own clock. It blocks sight in
      the simulation and not only on the screen — the one function that answers "can this body see
      that one" traces the ball, so a bot behind smoke is as blind as you are and will not shoot
      what it cannot see, and it walks around a cloud rather than into one.
      Everything you see is generated — the map, the textures, the models and the sounds — so the
      whole game is one small download and no asset files.</p>
    ${policyHtml(card)}
		@@ -41,7 +41,7 @@ function fixture(): { dir: string; entries: Entry[]; source: (n: string, t: stri
41	41
42	42	test("the entry table is what the app ships today, each with the size it may not pass", () => {
43	43	expect(ENTRIES).toEqual([
44		{ name: "app", entry: "src/client/main.ts", ceiling: { raw: 98_000, gzip: 39_000 } },
	44	{ name: "app", entry: "src/client/main.ts", ceiling: { raw: 103_000, gzip: 41_000 } },
45	45	{ name: "range", entry: "src/range/main.ts", ceiling: { raw: 37_000, gzip: 15_500 } },
46	46	{ name: "example", entry: "src/example/main.ts", ceiling: { raw: 23_500, gzip: 10_200 } },
47	47	]);
		@@ -188,6 +188,43 @@ test("a 64 Hz tick with ten bodies stays well inside the frame budget", () => {
188	188	expect(alive).toBe(10);
189	189	}, PATIENCE);
190	190
	191	/**
	192	* The same tick with smoke standing in the round: ten clouds, one per body,
	193	* which is the most this game can have at once and far more than a round ever
	194	* does. It is measured against the same ceiling as the plain tick, because
	195	* what #165 promised is that a cloud does not buy a sight test a second price:
	196	* `canSee` traces the level's fifty-odd boxes first, as it always has, and then
	197	* runs `segmentSphere` over the clouds — a dot product and at most one square
	198	* root each, with no allocation — and in a round nobody smoked the loop is a
	199	* length check on an empty array and costs nothing measurable at all.
	200	*
	201	* Measured on the machine that wrote this, idle: a plain tick 0.102 ms, this
	202	* one 0.107 ms. Ten clouds cost about 0.005 ms a tick — three hundredths of
	203	* one per cent of the 15.625 ms a frame has, and a twentieth of what a tick
	204	* already cost — and both are nearly ten times under the 1.0 ms ceiling, which
	205	* did not move for any of this.
	206	*/
	207	test("a tick with ten clouds of smoke standing is still well inside the budget", () => {
	208	useShipped();
	209	let clouds = 0;
	210	const each = measure("a 64 Hz tick with ten clouds standing", TICK_CEILING, () => {
	211	const world = liveRound(7);
	212	// One cloud on each body, opened a moment ago so every one of them is at
	213	// its full radius for the whole batch rather than growing out of nothing.
	214	for (const p of world.players)
	215	world.clouds.push({ pos: [p.pos[0], p.pos[1], p.pos[2] + 58], born: world.time - 2, owner: p.id });
	216	const batch = timed(TICKS, () => {
	217	for (let i = 0; i < TICKS; i++) update(world, TICK, NO_INPUT);
	218	});
	219	clouds = world.clouds.length;
	220	return batch;
	221	});
	222
	223	expect(each).toBeLessThan(TICK_CEILING);
	224	// The ticks that were measured really did have ten clouds standing in them.
	225	expect(clouds).toBe(10);
	226	}, PATIENCE);
	227
191	228	/**
192	229	* The guard's own guard. A ceiling nothing can reach is a green light wired to
193	230	* nothing: a loop the JIT lifted out, a clock read twice in a row, a batch that
		@@ -198,6 +198,18 @@ export function createAudio(device: SoundDevice = createSoundDevice()): Audio {
198	198	device.tone({ frequency: 260, slideTo: 150, gain: 0.16 * volume, length: 0.08, pan });
199	199	return;
200	200	}
	201	if (sound === "smoke") {
	202	// The canister opening: no bang at all. A long, soft, wide hiss that
	203	// fades away rather than cracks — it is the one grenade noise in this
	204	// game that is a process and not an event, and it is quiet, because
	205	// what a smoke costs you is what you can see and never what you hear.
	206	// It carries like a footstep does and not like a blast: a cloud across
	207	// the map is not information anybody should get for free.
	208	const soft = attenuate(far, BOMB_EARSHOT, BOMB_CLOSE);
	209	device.noiseBurst({ frequency: 3200, gain: 0.2 * soft, length: 1.4, q: 0.5, rate: 0.9, pan });
	210	device.tone({ frequency: 420, slideTo: 210, gain: 0.1 * soft, length: 0.9, pan });
	211	return;
	212	}
201	213	if (sound === "flash") {
202	214	// The flash: the opposite noise to the blast in every way. A bright,
203	215	// tight crack with no body under it and a ring above it that climbs
		@@ -19,12 +19,13 @@ test("the bindings are the ones the keyboard has always had", () => {
19	19	expect(CS_KEYS.KeyB).toBe("buy");
20	20	expect(CS_KEYS.KeyG).toBe("grenade");
21	21	expect(CS_KEYS.KeyT).toBe("flash");
	22	expect(CS_KEYS.KeyV).toBe("smoke");
22	23	expect(CS_KEYS.Tab).toBe("scoreboard");
23	24	expect(CS_KEYS.Digit1).toBe("slot1");
24	25	expect(CS_KEYS.Digit3).toBe("slot3");
25	26	expect(CS_MOUSE[0]).toBe("fire");
26	27	expect(CS_MOUSE[2]).toBe("scope");
27		expect([...CS_TAP]).toEqual(["jump", "reload", "buy", "grenade", "flash"]);
	28	expect([...CS_TAP]).toEqual(["jump", "reload", "buy", "grenade", "flash", "smoke"]);
28	29	// F is the page's, not the world's: `main.ts` hears it on `onAction` and asks
29	30	// the browser for the screen, and nothing about an `Input` changes for it.
30	31	expect(CS_KEYS.KeyF).toBe("fullscreen");
		@@ -13,7 +13,8 @@ export const CS_KEYS: Record<string, string> = {
13	13	KeyW: "forward", KeyS: "back", KeyA: "left", KeyD: "right",
14	14	ArrowUp: "forward", ArrowDown: "back", ArrowLeft: "left", ArrowRight: "right",
15	15	Space: "jump", ControlLeft: "duck", KeyC: "duck", ShiftLeft: "walk",
16		KeyR: "reload", KeyE: "use", KeyG: "grenade", KeyT: "flash", KeyB: "buy", Tab: "scoreboard",
	16	KeyR: "reload", KeyE: "use", KeyG: "grenade", KeyT: "flash", KeyV: "smoke",
	17	KeyB: "buy", Tab: "scoreboard",
17	18	Digit1: "slot1", Digit2: "slot2", Digit3: "slot3",
18	19	// Neither of these is a thing the world knows about: `main.ts` hears them on
19	20	// `onAction`, and `readIntent` below never sees either. F asks the browser for
		@@ -28,7 +29,7 @@ export const CS_KEYS: Record<string, string> = {
28	29	export const CS_MOUSE: Record<number, string> = { 0: "fire", 2: "scope" };
29	30
30	31	/** On-screen buttons that are a tap, not a hold. */
31		export const CS_TAP = ["jump", "reload", "buy", "grenade", "flash"] as const;
	32	export const CS_TAP = ["jump", "reload", "buy", "grenade", "flash", "smoke"] as const;
32	33
33	34	export type Intent = {
34	35	input: Input;
		@@ -55,9 +56,11 @@ export function readIntent(held: ReadonlySet<string>, stick: { x: number; y: num
55	56	use: down("use"),
56	57	fire: down("fire"),
57	58	scope: down("scope"),
58		// Two pockets, two keys. Both held is the flash, because the one you just
59		// reached for is the one you meant; releasing it throws the HE still held.
60		throwing: down("flash") ? "flash" : down("grenade") ? "he" : null,
	59	// Three pockets, three keys, read newest-reach-first: the one nearest the
	60	// front of this list wins while more than one is held, because the one you
	61	// just reached for is the one you meant, and releasing it throws whichever
	62	// of the others is still down.
	63	throwing: down("smoke") ? "smoke" : down("flash") ? "flash" : down("grenade") ? "he" : null,
61	64	switchTo: null,
62	65	};
63	66	return {
		@@ -19,6 +19,13 @@
19	19	* — the arena's, the trainer's — behave exactly as they did before, down to the
20	20	* coin flip, because `usePlan` was never called on them.
21	21	*
	22	* Smoke is handled in the same layer, and deliberately not in the policy. A bot
	23	* cannot see through a cloud because `canSee` says so, which is one change in
	24	* one function and covers the shooting; what it cannot answer is the walking,
	25	* so `skirt` below bends the next step of a path around a cloud rather than
	26	* into it. Both are scripted, both are outside the network, and the shipped
	27	* weights are the same eight kilobytes they were.
	28	*
22	29	* The weights are not in here and are not imported: they arrive as data. In a
23	30	* browser `src/client/main.ts` downloads `weights.json` as this game's own
24	31	* asset and calls `usePolicy` before Play is pressable; in Bun
		@@ -38,6 +45,7 @@ import { CS_HULL } from "./movement.ts";
38	45	import { observe, OBS_SIZE, type Memory } from "./observe.ts";
39	46	import { SHAPE } from "./packed.ts";
40	47	import { ease, grip, gripRate, sprayPull } from "./spray.ts";
	48	import { cloudRadius } from "./grenade.ts";
41	49	import { FLASH, WEAPONS, type WeaponId } from "./weapons.ts";
42	50	import { buy } from "./economy.ts";
43	51	import type { Input, Player, World } from "./world.ts";
		@@ -430,6 +438,74 @@ function pickTarget(world: World, bot: Player, brain: BotBrain): Player \| null {
430	438	return best;
431	439	}
432	440
	441	// --- smoke ----------------------------------------------------------------
	442
	443	/**
	444	* How far outside a cloud a bot aims to walk, in units. A hull's width, so it
	445	* skirts the fringe of one rather than clipping through it — and so that a
	446	* diversion is a visible step around something and not a shuffle along its
	447	* edge.
	448	*/
	449	const SMOKE_CLEARANCE = CS_HULL.radius * 2;
	450
	451	/**
	452	* Where this bot should walk instead of straight at `step`, given the clouds
	453	* standing in the round.
	454	*
	455	* A cloud is not a wall — a body walks through one exactly as it walks through
	456	* air, and it should, because walking through smoke is half of what smoke is
	457	* for — but it is a wall to this bot's eyes: `canSee` refuses a line through
	458	* one, so a bot that strolls into a cloud arrives blind at whatever is waiting
	459	* on the other side and has given away the fight it was walking to. So the
	460	* scripted layer treats it as something to go around, and the policy is told
	461	* nothing: the shipped weights, `OBS_SIZE` and every head are untouched by all
	462	* of this.
	463	*
	464	* Two cases and no third. Standing in one, the shortest way out is straight
	465	* away from the middle, and that is where the bot walks. Heading into one, the
	466	* step is pushed sideways to whichever edge is nearer — the tangent, plus the
	467	* clearance — so the path bends around the cloud and rejoins itself. A cloud
	468	* behind the bot, beside the walk, or past the end of this step is left alone,
	469	* which is every cloud on most ticks; a round nobody smoked never reaches here
	470	* at all, because the caller checks the list is empty first.
	471	*
	472	* The step comes back unchanged when there is nothing to do, so the common case
	473	* allocates nothing.
	474	*/
	475	export function skirt(world: World, bot: Player, step: Vec3): Vec3 {
	476	for (const cloud of world.clouds) {
	477	const radius = cloudRadius(cloud, world.time);
	478	if (radius <= 0) continue;
	479	const keep = radius + SMOKE_CLEARANCE;
	480	const cx = cloud.pos[0] - bot.pos[0];
	481	const cy = cloud.pos[1] - bot.pos[1];
	482	const here = Math.hypot(cx, cy);
	483	if (here < keep) {
	484	// Inside it, or in its fringe: out, by the shortest line there is. Dead
	485	// in the middle there is no such line, so the bot keeps walking rather
	486	// than picking a direction out of nothing.
	487	if (here < 1e-6) continue;
	488	return [bot.pos[0] - (cx / here) * keep, bot.pos[1] - (cy / here) * keep, step[2]];
	489	}
	490	const dx = step[0] - bot.pos[0];
	491	const dy = step[1] - bot.pos[1];
	492	const len = Math.hypot(dx, dy);
	493	if (len < 1e-6) continue;
	494	const ux = dx / len, uy = dy / len;
	495	// How far along the walk the cloud sits, and how far off to one side.
	496	const along = cx * ux + cy * uy;
	497	if (along <= 0 \|\| along > len + keep) continue;
	498	const off = cx * -uy + cy * ux;
	499	if (Math.abs(off) >= keep) continue;
	500	// Around the near edge: the perpendicular, away from the side the cloud is
	501	// on, by just enough to put the walk on the tangent.
	502	const side = off >= 0 ? -1 : 1;
	503	const push = (keep - Math.abs(off)) * side;
	504	return [step[0] + -uy * push, step[1] + ux * push, step[2]];
	505	}
	506	return step;
	507	}
	508
433	509	/** An enemy shooting nearby is a direction to look, even through a wall. */
434	510	function listen(world: World, bot: Player, brain: BotBrain): void {
435	511	for (const other of world.players) {
		@@ -659,7 +735,11 @@ export function botThink(world: World, bot: Player, dt: number): Input {
659	735	const next = brain.path[brain.step];
660	736	if (next !== undefined) {
661	737	if (dist([bot.pos[0], bot.pos[1], 0], [next[0], next[1], 0]) < 48) brain.step += 1;
662		const aim = aimAt(bot, [next[0], next[1], bot.pos[2] + 48]);
	738	// The path is A*'s and it knows nothing about smoke, which is right: the
	739	// cells are still walkable and a cloud is gone in fifteen seconds. What
	740	// bends is the step, here and only while there is a cloud to bend it.
	741	const walk = world.clouds.length === 0 ? next : skirt(world, bot, next);
	742	const aim = aimAt(bot, [walk[0], walk[1], bot.pos[2] + 48]);
663	743	const look = brain.suspect !== null ? aimAt(bot, brain.suspect) : { yaw: aim.yaw, pitch: 0 };
664	744	turnTowards(bot, { yaw: look.yaw, pitch: clamp(look.pitch, -20, 20) }, brain.aimSpeed * 0.5, dt);
665	745	const off = angleDelta(bot.yaw, aim.yaw);
		@@ -21,7 +21,7 @@ const buyer = (over: Partial<Buyer> = {}): Buyer => ({
21	21	armor: 0, helmet: false, defuseKit: false,
22	22	weapon: "usp", primary: null, secondary: "usp",
23	23	ammo: { knife: { mag: 0, reserve: 0 }, usp: emptyAmmo("usp") },
24		pocket: { he: 0, flash: 0 },
	24	pocket: { he: 0, flash: 0, smoke: 0 },
25	25	...over,
26	26	});
27	27
		@@ -25,11 +25,12 @@ export const emptyAmmo = (id: WeaponId): Ammo =>
25	25	({ mag: WEAPONS[id].magazine, reserve: WEAPONS[id].reserve });
26	26
27	27	/**
28		* How many of each thrown weapon a player may carry into a round. One HE and
29		* one flashbang — two grenades, bought separately in the freeze, each refused
30		* once the pocket holds its limit, and both gone with the body that held them.
	28	* How many of each thrown weapon a player may carry into a round. One HE, one
	29	* flashbang and one smoke — three grenades, bought separately in the freeze,
	30	* each refused once the pocket holds its limit, and all gone with the body that
	31	* held them.
31	32	*/
32		export const CARRY: Record<ThrownId, number> = { he: 1, flash: 1 };
	33	export const CARRY: Record<ThrownId, number> = { he: 1, flash: 1, smoke: 1 };
33	34
34	35	export type BuyItem = WeaponId \| "armor" \| "helmet" \| "kit";
35	36
		@@ -370,7 +370,12 @@ test("a bot walks a map nobody wrote, on that map's own cells", () => {
370	370	* field list still comes to the digest this line held before,
371	371	* 48a1d4466065e045b8933b3fbf5ece767a825a60165e6455b4e310a8d7dd5cae.
372	372	*/
373		const GENERATED_ROUND = "d7bd4969d00345feff718f37a6ed13ff6967f8884ca716bc639bff63f085d82e";
	373	// Re-pinned for #165, which put a smoke grenade in the game: the hash moved
	374	// and the play did not. A pocket is three counts now rather than two, a
	375	// grenade's kind is an index into three rather than a flag, and every tick
	376	// carries however many clouds are standing — and nothing in this run throws
	377	// anything, so `clouds` is empty on all 640 ticks of it.
	378	const GENERATED_ROUND = "619ce3102805d11dc40e8d545267e99034bfb3bdab2961202703423a87f6e500";
374	379
375	380	test("a seeded round on a generated map plays exactly as it played", () => {
376	381	const level = generateLevel(5);
		@@ -458,7 +458,7 @@ test("a flash is bought alongside the HE, one of each, and thrown on its own key
458	458	expect(buy(world, world.me, "he")).toBe(true);
459	459	expect(buy(world, world.me, "flash")).toBe(true);
460	460	// Carried alongside, not instead of: both are in the pocket at once.
461		expect(world.me.pocket).toEqual({ he: CARRY.he, flash: CARRY.flash });
	461	expect(world.me.pocket).toEqual({ he: CARRY.he, flash: CARRY.flash, smoke: 0 });
462	462	expect(world.me.money).toBe(5000 - HE.price - FLASH.price);
463	463	// One of each a round: the second of either is refused and costs nothing.
464	464	expect(buy(world, world.me, "flash")).toBe(false);
		@@ -472,7 +472,7 @@ test("a flash is bought alongside the HE, one of each, and thrown on its own key
472	472	for (let t = 0; t < 32; t++) update(world, TICK, { ...NO_INPUT, throwing: "flash" });
473	473	expect(world.grenades.length).toBe(1);
474	474	expect(world.grenades[0]?.weapon).toBe("flash");
475		expect(world.me.pocket).toEqual({ he: 1, flash: 0 });
	475	expect(world.me.pocket).toEqual({ he: 1, flash: 0, smoke: 0 });
476	476	});
477	477
478	478	/** Everyone but `p` put out of the round, so only the flash can change anything. */