# val

Five attackers with the spike, five defenders, abilities on cooldown. First to 13.

A 5v5 played in a browser, from inside the player's head — the map is a tile
grid and the view is a raycaster over it, so there is no 3D library and no
dependency at all. One match is always running on the server: open the page
and you are given a seat in the round that is happening, taken from a bot
where it stands. When a match ends it shows the result for a few seconds and
starts a new one, so nobody ever arrives at a frozen board.

## What is real

Everything that decides a round is computed on the server and only the
server:

- **Movement, shooting and hit detection.** The client sends intent — a
  direction, an angle, a held key — never a position. Damage is by hit
  location (how close the ray passes the target) with falloff and armour:
  a Vandal head shot kills through full armour at any range, a Phantom's
  does not past fifteen metres.
- **Line of sight.** A snapshot only carries the enemies that viewer can
  see. A wall of the map blocks the sight line, a smoke blocks it, a flash
  blinds by the angle you were facing, and a blinded player is sent no
  enemies at all. A dead player watches through their living team mates'
  eyes rather than through walls, so dying is not a wallhack to call out.
  No spawn can see the other spawn: mid is staggered on purpose. A patched
  client learns nothing a plain one does not.
- **The spike.** 100s round, 4s plant, 45s fuse, 7s defuse with a
  checkpoint at 3.5s — a defender killed past half way leaves the defuse
  half done for the next one.
- **Credits.** 800 to start, 9,000 cap, +200 a kill, +300 to the team on a
  plant, loss bonus 1,900 / 2,400 / 2,900. A buy you cannot afford is
  refused server-side.
- **Bots** fill every empty seat and use their kit: smokes on the way in,
  flashes before the entry, a recon dart, a molly on the planted spike.

Agents: Ember, Veil, Sable, Mender, Rook — two basics bought with credits
(charges last the round), a free signature on a cooldown, and an ultimate
paid for with ult points from kills, plants and the two orbs on the map.

Guns: Classic, Ghost, Sheriff, Spectre, Phantom, Vandal, Operator.

## What is not

- The view is a raycaster: walls are one tile tall and flat-shaded, there is
  no looking up or down, and everything that is not a wall — bodies, the
  spike, ability zones — is a flat billboard scaled by distance and clipped
  against the walls.
- One map, one match at a time, ten seats. There is no matchmaking, no
  ranking and no account: your seat belongs to a session cookie.
- No overtime — first to 13 ends it at 12–12 too.
- Sight is a full circle rather than a view cone — you are drawn what is in
  front of you, but the server reveals anything you have line of sight to,
  so a team mate behind you still appears on the minimap. The world has no
  vertical, so the hit location comes from how precisely the shot passes
  the target.
- Assists are counted as a field but never awarded.
- The live match lives in memory and is gone if the process restarts; only
  finished match results are written to SQLite under `FORGE_APP_DATA`.

## Playing

Click the view to capture the mouse, then WASD move and the mouse looks;
**Esc** gives the pointer back. Click fires, **R** reloads, **F** plants and
defuses (hold it), **C / Q / E / X** cast, **B** opens the buy, **Tab**
holds the big map open, **V** swaps to the top-down view and **H** or **?**
brings back the how-to-play card. On a phone it stays top-down: the left
thumb walks and the right thumb aims and fires.

```sh
PORT=8080 FORGE_APP_DATA=./data bun run src/server.ts   # run it here
bun test                                                # the check every pull runs
VAL_URL=http://127.0.0.1:8080 bun run src/tty.ts        # the terminal interface
```

The terminal plays the same match over the same socket: it draws the grid,
the scoreboard and the round, and takes a seat. The exact command that
reaches it is in `FORGE_APP_SSH` when the app runs, and the page prints it.

The forge sets `PORT`, `FORGE_APP_DATA`, `FORGE_APP_ENV`, `FORGE_APP_URL`,
`FORGE_APP_SSH` and `FORGE_APP_COMMIT` when it starts the app; `forge.json`
says how.

## Shape

`src/map.ts` the grid and its geometry · `src/weapons.ts` the damage table ·
`src/economy.ts` credits · `src/abilities.ts` the agent kits ·
`src/match.ts` the round loop (`tick(state, dt)` is the whole game and takes
no clock) · `src/bots.ts` the seats nobody is in · `src/arena.ts` the one
live match and its sockets · `src/server.ts` the door · `static/` the browser client —
`val.js` wires the socket, the keys and the HUD, `raycast.js` is the ray
maths, `scene.js` the first-person view, `topdown.js` the minimap,
`gun.js`, `beep.js`, `steer.js` and `prompt.js` the rest; the server bundles
them into one content-named file at start-up. The rules are pure functions and the tests play whole matches
headlessly.