# gizgame/net

the parts of a networked game that do not depend on the wire. The server is the authority: it runs the simulation at a fixed tick, takes each player's inputs (with their sequence numbers) and sends each player the state of what is near it (Interest). A state is records, one a replicated entity, and an input is a record too: each goes on the wire as its gizlang/wire bytes, or a record as the game's own quantized bytes (Writer); a player gets only what changed since the state it acknowledged (delta). A client predicts its own player with the same systems (Predictor) and replays its unacknowledged inputs over each state it gets, so its moves answer at once and still end where the server says. A shot is judged as the shooter saw it: the server keeps the targets of the last ticks (History) and rewinds to the tick the shooter's input names (lag compensation). Messages are bytes (encode, decode); Server and Client run a game of the game's Rules over them, and gizapp/netplay carries them on a WebSocket.

```gizlang
import * as Net from "gizgame/net";
```

## Types

### `Writer`

```gizlang
class Writer { out: bytes = b""; unsigned(v: i64): Writer { Text.writeUVarint(this.out, u64(v)); return this; } signed(v: i64): Writer { Text.writeVarint(this.out, v); return this; } real(v: f64, step: f64): Writer { return this.signed(i64(Math.round(v/step))); } bytes(b: bytes): Writer { this.unsigned(b.length); this.out+ = b; return this; } text(s: string): Writer { return this.bytes(utf8(s)); } }
```

Bytes written a value at a time: unsigned and signed (zigzag) varints of gizlang/text, and quantized reals.

- `out`: `bytes`

### `Reader`

```gizlang
class Reader { private data: bytes; at: i64 = 0; constructor(data: bytes) { this.data = data; } done(): bool { return this.at> = this.data.length; } unsigned(): i64 throws string { let r: Text.VarintUnsigned; try { r = Text.readUVarint(this.data, this.at, 63); } catch { throw "A message ends early"; } this.at = r.next; return i64(r.value); } signed(): i64 throws string { let r: Text.VarintSigned; try { r = Text.readVarint(this.data, this.at, 64); } catch { throw "A message ends early"; } this.at = r.next; return r.value; } real(step: f64): f64 throws string { return f64(this.signed())*step; } bytes(): bytes throws string { const n = this.unsigned(); if (n> this.data.length-this.at) { throw "A message ends early"; } const out = this.data.slice(this.at, this.at+n); this.at+ = n; return out; } text(): string throws string { return string(this.bytes()); } }
```

The reader of what a Writer wrote; reading past the end fails ("A message ends early").

- `data`: `bytes`
- `at`: `i64`

### `Message`

```gizlang
type Message = { kind: i64; player: i64; tick: i64; sequence: i64; base: i64; text: string; data: bytes; }
```

A message of any kind; the fields its kind does not use keep the values of message.

- `kind`: `i64`
- `player`: `i64`
- `tick`: `i64`
- `sequence`: `i64`
- `base`: `i64`
- `text`: `string`
- `data`: `bytes`

### `State`

```gizlang
type State = Map<i64, bytes>
```

A state: each replicated entity's record by its ID.

### `Interest`

```gizlang
class Interest { private cell: f64; private cells = new Map<string, Vec<i64>>(); private where = new Map<i64, string>(); constructor(cell: f64) { this.cell = cell; } private key(x: i64, z: i64): string { return `${x }, ${ z }`; } set(id: i64, x: f64, z: f64): void { const k = this.key(i64(Math.floor(x/this.cell)), i64(Math.floor(z/this.cell))); const old = this.where.get(id); if (old !== undefined && old! === k) { return; } if (old !== undefined) { this.cells.set(old!, (this.cells.get(old!) ?? []).filter(o => o !== id)); } let list = this.cells.get(k) ?? []; list.push(id); this.cells.set(k, list); this.where.set(id, k); } remove(id: i64): void { const old = this.where.get(id); if (old === undefined) { return; } this.cells.set(old!, (this.cells.get(old!) ?? []).filter(o => o !== id)); this.where.delete(id); } around(x: f64, z: f64, radius: f64): Vec<i64> { const cx = i64(Math.floor(x/this.cell)); const cz = i64(Math.floor(z/this.cell)); const n = i64(Math.ceil(radius/this.cell)); let out: Vec<i64> = []; for (const dz of range(-n, n+1)) { for (const dx of range(-n, n+1)) { for (const id of this.cells.get(this.key(cx+dx, cz+dz)) ?? []) { out.push(id); } } } return out.toSorted((a, b) => a <b); } }
```

Who is where on x, z, in cells of CELL meters: what a player is near is what it is sent.

- `cell`: `f64`
- `cells`: `_gizlang_sdk_collections.Map<string, Vec<i64>>`
- `where`: `_gizlang_sdk_collections.Map<i64, string>`

### `Target`

```gizlang
type Target = { id: i64; center: Point3; radius: f64; }
```

A target as a shot meets it: its ID and a sphere (a hitbox).

- `id`: `i64`
- `center`: `gizlang_geometry.Point3`
- `radius`: `f64`

### `History`

```gizlang
class History { private ticks: Vec<i64> = []; private frames: Vec<Vec<Target>> = []; private most: i64; constructor(most: i64 = 16) { this.most = most; } record(tick: i64, targets: Vec<Target>): void { this.ticks.push(tick); this.frames.push(targets); if (this.ticks.length> this.most) { this.ticks.splice(0, 1); this.frames.splice(0, 1); } } at(tick: i64): Vec<Target> { for (const k of range(0, this.ticks.length)) { if (this.ticks[k] === tick) { return this.frames[k]; } } return this.frames.length> 0 ? (tick <this.ticks[0] ? this.frames[0]: this.frames[this.frames.length-1]): []; } shot(tick: i64, origin: Point3, direction: Point3, farthest: f64, shooter: i64): Target | undefined { let best: Target | undefined = undefined; let nearest = farthest; for (const t of this.at(tick)) { if (t.id === shooter) { continue; } const m = sub(origin, t.center); const b = dot(m, direction); const c = dot(m, m)-t.radius*t.radius; if (c> 0.0 && b> 0.0) { continue; } const disc = b*b-c; if (disc <0.0) { continue; } const d = Math.max(0.0, -b-Math.sqrt(disc)); if (d <nearest) { nearest = d; best = t; } } return best; } }
```

The targets of the last TICKS ticks, for judging a shot at the tick its shooter saw.

- `ticks`: `Vec<i64>`
- `frames`: `Vec<Vec<M186.Target>>`
- `most`: `i64`

### `Pending`

```gizlang
type Pending<I> = { sequence: i64; input: I; }
```

An input I of the client's own player, kept until the server has taken it.

Opaque: create and use it through this module's functions.

### `Predictor`

```gizlang
class Predictor<S, I> { state: S; private pending: Vec<Pending<I>> = []; private step: (s: S, input: I) => S; constructor(state: S, step: (s: S, input: I) => S) { this.state = state; this.step = step; } predict(sequence: i64, input: I): void { this.pending.push({ sequence, input }); this.state = this.step(this.state, input); } reconcile(authority: S, taken: i64): void { this.pending = this.pending.filter(p => p.sequence> taken); let s = authority; for (const p of this.pending) { s = this.step(s, p.input); } this.state = s; } waiting(): i64 { return this.pending.length; } }
```

A client's prediction of its own player of state S: STEP applies one input I to S (the systems the server runs on
it). Each input applies at once; a server state takes the place of the prediction and the inputs the server has not
taken apply again on top.

Opaque: create and use it through this module's functions.

### `Shot`

```gizlang
type Shot = { origin: Point3; direction: Point3; farthest: f64; }
```

A shot an input fires: from ORIGIN along the unit DIRECTION, as far as FARTHEST (where the world stops it).

- `origin`: `gizlang_geometry.Point3`
- `direction`: `gizlang_geometry.Point3`
- `farthest`: `f64`

### `Rules`

```gizlang
type Rules<P, I> = { spawn: (player: i64) => P; idle: I; step: (p: P, input: I, dt: f64) => P; where: (p: P) => Point3; aim?: (p: P, input: I) => Shot | undefined; hurt?: (target: P, shooter: i64) => P; credit?: (shooter: P, before: P, after: P) => P; radius?: f64; write?: (p: P) => bytes; read?: (b: bytes) => P throws string; }
```

A game's players of record P and their inputs of record I, as Server and Client run them. SPAWN makes player N's
record, IDLE is the input of a tick with none (and the shape of every input), and STEP applies one input for DT
seconds: the server runs it, and the client predicts with the same function. WHERE is where a record stands. When
shots matter, AIM is the shot an input fires, HURT what a hit does to its target, CREDIT what the shooter gets for it
(the target before and after the hit), and RADIUS the hitbox around a record's WHERE. Records and inputs go on the
wire as gizlang/wire writes them; WRITE and READ, when given, are a record's own smaller bytes (Writer's quantized
reals).

Opaque: create and use it through this module's functions.

### `Sent`

```gizlang
type Sent = { player: i64; message: bytes; }
```

A message for PLAYER, as a tick gives it.

- `player`: `i64`
- `message`: `bytes`

### `Server`

```gizlang
class Server<P, I> { hz: f64; tick: i64 = 0; private rules: Rules<P, I>; private wire: Codec<P, I>; private reach: f64; private players = new Map<i64, P>(); private inputs = new Map<i64, Vec<Message>>(); private taken = new Map<i64, i64>(); private acked = new Map<i64, i64>(); private sent = new Map<i64, Map<i64, State>>(); private welcomes: Vec<i64> = []; private driven = new Set<i64>(); private next: i64 = 0; private interest: Interest; private history: History; constructor(hz: f64, rules: Rules<P, I>, reach: f64 = 80.0) throws string { this.wire = new Codec<P, I>(rules); this.hz = hz; this.rules = rules; this.reach = reach; this.interest = new Interest(reach*0.5); this.history = new History(i64(hz)); } seated(): Vec<i64> { return this.players.keys().toSorted((a, b) => a <b); } player(n: i64): P | undefined { return this.players.get(n); } join(driven: bool = false): i64 { const n = this.next; this.next+ = 1; const p = this.rules.spawn(n); this.players.set(n, p); this.inputs.set(n, []); this.taken.set(n, -1); this.acked.set(n, -1); if (driven) { this.driven.add(n); } else { this.sent.set(n, new Map<i64, State>()); this.welcomes.push(n); } const at = this.rules.where(p); this.interest.set(n, at.x, at.z); return n; } leave(n: i64): void { this.players.delete(n); this.inputs.delete(n); this.taken.delete(n); this.acked.delete(n); this.sent.delete(n); this.driven.delete(n); this.welcomes = this.welcomes.filter(w => w !== n); this.interest.remove(n); } drive(n: i64, input: I): void { const queue = this.inputs.get(n); if (queue === undefined || !this.driven.has(n)) { return; } let m = message(INPUT); m.tick = this.tick; m.sequence = (this.taken.get(n) ?? -1)+queue!.length+1; m.data = this.wire.input(input); let q = queue!; q.push(m); this.inputs.set(n, q); } heard(n: i64, data: bytes): void { const decoded = decode(data).maybe(); if (decoded === undefined) { return; } const m = decoded!; const queue = this.inputs.get(n); if (queue === undefined) { return; } if (m.kind === INPUT && queue!.length <QUEUED) { let q = queue!; q.push(m); this.inputs.set(n, q); } if (m.kind === ACK) { this.acked.set(n, Math.maxI64(this.acked.get(n) ?? -1, m.tick)); } } step(): Vec<Sent> { const dt = 1.0/this.hz; const r = this.rules; const ids = this.seated(); const box = r.radius ?? 0.5; const aim = r.aim; const hurt = r.hurt; const credit = r.credit; if (aim !== undefined) { this.history.record(this.tick, ids.map((id: i64): Target => ({ id, center: r.where(this.players.get(id)!), radius: box }))); } for (const n of ids) { for (const m of this.inputs.get(n) ?? []) { if (!this.players.has(n)) { break; } const input = this.wire.order(m.data).maybe() ?? r.idle; const p = r.step(this.players.get(n)!, input, dt); this.players.set(n, p); this.taken.set(n, m.sequence); const shot = aim === undefined ? undefined: aim!(p, input); if (shot === undefined || hurt === undefined) { continue; } const hit = this.history.shot(m.tick, shot!.origin, shot!.direction, shot!.farthest, n); if (hit === undefined || !this.players.has(hit!.id)) { continue; } const before = this.players.get(hit!.id)!; const after = hurt!(before, n); this.players.set(hit!.id, after); if (credit !== undefined) { this.players.set(n, credit!(this.players.get(n)!, before, after)); } } this.inputs.set(n, []); const p = this.players.get(n); if (p !== undefined) { const at = r.where(p!); this.interest.set(n, at.x, at.z); } } this.tick+ = 1; let out: Vec<Sent> = []; for (const n of this.welcomes) { let w = message(WELCOME); w.player = n; w.tick = this.tick; out.push({ player: n, message: encode(w) }); } this.welcomes = []; for (const n of ids) { const p = this.players.get(n); if (p === undefined || this.driven.has(n)) { continue; } const at = r.where(p!); let now = new Map<i64, bytes>(); for (const id of this.interest.around(at.x, at.z, this.reach)) { const o = this.players.get(id); if (o !== undefined) { now.set(id, this.wire.record(o!)); } } let kept = this.sent.get(n)!; const acked = this.acked.get(n) ?? -1; const base = kept.get(acked); let s = message(STATE); s.tick = this.tick; s.sequence = this.taken.get(n) ?? -1; s.base = base === undefined ? -1: acked; s.data = base === undefined ? stateBytes(now): delta(base!, now); kept.set(this.tick, now); for (const old of kept.keys()) { if (old <= this.tick-KEPT) { kept.delete(old); } } this.sent.set(n, kept); out.push({ player: n, message: encode(s) }); } return out; } }
```

The authority of a networked game at HZ ticks a second: it seats players, applies each one's inputs at its tick
(a shot judged at the tick its shooter saw), and sends each the records within REACH meters of it, as a delta from
the last state that player acknowledged. One thread owns it (gizapp/netplay's room).

Opaque: create and use it through this module's functions.

### `Client`

```gizlang
class Client<P, I> { player: i64 = -1; tick: i64 = 0; now: State = new Map<i64, bytes>(); before: State = new Map<i64, bytes>(); private rules: Rules<P, I>; private wire: Codec<P, I>; private hz: f64; private own: Predictor<P, I> | undefined = undefined; private states = new Map<i64, State>(); private sequence: i64 = 0; private out: Vec<bytes> = []; constructor(hz: f64, rules: Rules<P, I>) throws string { this.hz = hz; this.rules = rules; this.wire = new Codec<P, I>(rules); } welcomed(): bool { return this.own !== undefined; } mine(): P | undefined { return this.own === undefined ? undefined: this.own!.state; } heard(data: bytes): void throws string { const m = decode(data); const r = this.rules; const dt = 1.0/this.hz; if (m.kind === WELCOME) { this.player = m.player; this.tick = m.tick; this.own = new Predictor<P, I>(r.spawn(m.player), (s: P, input: I): P => r.step(s, input, dt)); return; } if (m.kind !== STATE) { return; } const base: Option<Map<i64, bytes>> = m.base <0 ? new Map<i64, bytes>(): this.states.get(m.base); if (base === undefined) { return; } const s = applied(base!, m.data); this.states.set(m.tick, s); for (const old of this.states.keys()) { if (old <= m.tick-KEPT) { this.states.delete(old); } } this.before = this.now; this.now = s; this.tick = m.tick; let ack = message(ACK); ack.tick = m.tick; this.out.push(encode(ack)); const mine = s.get(this.player); if (mine !== undefined && this.own !== undefined) { this.own!.reconcile(this.wire.player(mine!), m.sequence); } } input(input: I): void { if (this.own === undefined) { return; } this.sequence+ = 1; this.own!.predict(this.sequence, input); let i = message(INPUT); i.tick = this.tick; i.sequence = this.sequence; i.data = this.wire.input(input); this.out.push(encode(i)); } next(): bytes { if (this.out.length === 0) { return b""; } const first = this.out[0]; this.out.splice(0, 1); return first; } others(): Vec<P> throws string { let out: Vec<P> = []; for (const id of this.now.keys().toSorted((a, b) => a <b)) { if (id !== this.player) { out.push(this.wire.player(this.now.get(id)!)); } } return out; } }
```

A player's side of a networked game: it takes the server's messages (heard), sends its inputs at once and predicts
its own record with the server's STEP (input), and gives what to send (next). OWN is its record as predicted, NOW
and BEFORE the last two states (draw the others between them).

Opaque: create and use it through this module's functions.

### `Seats`

```gizlang
type Seats = { hz: f64; guests: bool; join: (id: string, name: string) => i64 throws string; heard: (player: i64, message: bytes) => void; leave: (player: i64) => void; tick: () => Vec<Sent>; }
```

A match's seats, which a served game's room carries (gizapp/netplay, on a thread of its own) or a Session runs in one
program: HZ ticks a second; GUESTS, whether a player with no Giz account may sit; JOIN seats the account ID ("" a
guest) named NAME, or says why not; HEARD takes a player's message; LEAVE frees its seat; TICK advances one tick and
gives what to send.

- `hz`: `f64`
- `guests`: `bool`
- `join`: `(arg0: string, arg1: string) => i64 throws string`
- `heard`: `(arg0: i64, arg1: bytes) => void`
- `leave`: `(arg0: i64) => void`
- `tick`: `() => Vec<M186.Sent>`

### `Session`

```gizlang
class Session<P, I> { client: Client<P, I>; online: bool = false; private hz: f64; private rules: Rules<P, I>; private make: () => Seats; private seats: Seats | undefined = undefined; private me: i64 = -1; constructor(hz: f64, rules: Rules<P, I>, make: () => Seats) throws string { this.hz = hz; this.rules = rules; this.make = make; this.client = new Client<P, I>(hz, rules); } tick(): void throws string { if (this.online) { return; } if (this.seats === undefined) { const s = this.make(); this.seats = s; this.me = s.join("", "Guest"); } const seats = this.seats!; while (true) { const m = this.client.next(); if (m.length === 0) { break; } seats.heard(this.me, m); } for (const s of seats.tick()) { if (s.player === this.me) { this.client.heard(s.message); } } } carry(input: bytes): bytes { if (!this.online) { this.online = true; this.seats = undefined; this.client = new Client<P, I>(this.hz, this.rules)!; } if (input.length> 0) { void(this.client.heard(input).maybe()); return b""; } return this.client.next(); } }
```

A player's match. Alone, the seats that MAKE gives run in this program and CLIENT plays on them through the same
messages a server would carry; once a host carries the messages (carry, the program's net export), the server it
reaches decides and the seats here are dropped.

Opaque: create and use it through this module's functions.

## Functions

### `constructor`

```gizlang
constructor(data: bytes)
```

A reader at the start of DATA.

Effects: fail, read, write, alloc.

### `message`

```gizlang
function message(kind: i64): Message
```

An empty message of KIND.

Effects: fail.

### `encode`

```gizlang
function encode(m: Message): bytes
```

The bytes of M.

Effects: fail, alloc.

### `decode`

```gizlang
function decode(b: bytes): Message throws string
```

The message of B; it fails on bytes that are no message.

Effects: fail, alloc.

### `delta`

```gizlang
function delta(base: State, now: State): bytes
```

The change from BASE to NOW: each record removed, new, or changed (its bytes XORed with the base's and the runs of
zeros counted, so a record that barely changed costs a few bytes).

Effects: fail, read, write, alloc.

### `applied`

```gizlang
function applied(base: State, d: bytes): State throws string
```

BASE changed by DELTA.

Effects: fail, read, write, alloc.

### `stateBytes`

```gizlang
function stateBytes(s: State): bytes
```

A state as one message's bytes (stateOf reads them back).

Effects: fail, read, write, alloc.

### `stateOf`

```gizlang
function stateOf(b: bytes): State throws string
```

The state of bytes that stateBytes wrote.

Effects: fail, read, write, alloc.

### `constructor`

```gizlang
constructor(cell: f64)
```

An empty grid of CELL meters.

Effects: fail, read, write, alloc.

### `constructor`

```gizlang
constructor(most: i64 = 16)
```

A history that keeps the last MOST ticks.

Effects: fail, read, write, alloc.

### `constructor`

```gizlang
constructor(state: S, step: (s: S, input: I) => S)
```

A prediction from STATE, where STEP applies an input.

### `constructor`

```gizlang
constructor(hz: f64, rules: Rules<P, I>, reach: f64 = 80.0) throws string
```

A server of RULES at HZ ticks a second; a player is sent what is within REACH meters.

### `constructor`

```gizlang
constructor(hz: f64, rules: Rules<P, I>) throws string
```

A client of RULES at HZ ticks a second, before its welcome.

### `seatsOf`

```gizlang
function seatsOf<P, I>(server: Server<P, I>, guests: bool, drive: () => void): Seats
```

The seats of SERVER, GUESTS as Seats says: each tick, DRIVE first gives the inputs of the seats this program
plays itself (Server.drive), then the server steps.

### `constructor`

```gizlang
constructor(hz: f64, rules: Rules<P, I>, make: () => Seats) throws string
```

A session of RULES at HZ ticks a second; MAKE gives the seats of a match in this program.

## Methods

### `Writer.unsigned`

```gizlang
unsigned(v: i64): Writer
```

Writes V, at least 0, as an unsigned varint.

Effects: fail, read, write, alloc.

### `Writer.signed`

```gizlang
signed(v: i64): Writer
```

Writes V as a signed (zigzag) varint.

Effects: fail, read, write, alloc.

### `Writer.real`

```gizlang
real(v: f64, step: f64): Writer
```

V to the nearest STEP (a millimeter for a position, 1/4096 of a radian for an angle).

Effects: fail, read, write, alloc.

### `Writer.bytes`

```gizlang
bytes(b: bytes): Writer
```

Writes B after its length.

Effects: fail, read, write, alloc.

### `Writer.text`

```gizlang
text(s: string): Writer
```

Writes S as its UTF-8 bytes.

Effects: fail, read, write, alloc.

### `Reader.done`

```gizlang
done(): bool
```

Whether every byte is read.

Effects: fail, read.

### `Reader.unsigned`

```gizlang
unsigned(): i64 throws string
```

The next unsigned varint.

Effects: fail, read, write.

### `Reader.signed`

```gizlang
signed(): i64 throws string
```

The next signed (zigzag) varint.

Effects: fail, read, write.

### `Reader.real`

```gizlang
real(step: f64): f64 throws string
```

The next real that Writer.real wrote to the nearest STEP.

Effects: fail, read, write.

### `Reader.bytes`

```gizlang
bytes(): bytes throws string
```

The next bytes, after their length.

Effects: fail, read, write, alloc.

### `Reader.text`

```gizlang
text(): string throws string
```

The next text.

Effects: fail, read, write, alloc.

### `Interest.set`

```gizlang
set(id: i64, x: f64, z: f64): void
```

Puts ID at X, Z.

Effects: fail, read, write, alloc.

### `Interest.remove`

```gizlang
remove(id: i64): void
```

Forgets where ID is.

Effects: fail, read, write, alloc.

### `Interest.around`

```gizlang
around(x: f64, z: f64, radius: f64): Vec<i64>
```

The IDs in the cells within RADIUS of X, Z, in order.

Effects: fail, read, alloc.

### `History.record`

```gizlang
record(tick: i64, targets: Vec<Target>): void
```

Keeps TARGETS as they are at TICK, dropping the oldest past MOST.

Effects: fail, read, write, alloc.

### `History.at`

```gizlang
at(tick: i64): Vec<Target>
```

The targets at TICK, else the oldest kept (a shooter further behind is judged at the edge).

Effects: fail, read, alloc.

### `History.shot`

```gizlang
shot(tick: i64, origin: Point3, direction: Point3, farthest: f64, shooter: i64): Target | undefined
```

The nearest target at TICK that the ray from ORIGIN along the unit DIRECTION meets within FARTHEST, not
SHOOTER.

Effects: fail, read, alloc.

### `Predictor.predict`

```gizlang
predict(sequence: i64, input: I): void
```

Applies INPUT of SEQUENCE now and keeps it.

### `Predictor.reconcile`

```gizlang
reconcile(authority: S, taken: i64): void
```

The server's state AUTHORITY after its input TAKEN: the prediction from there.

### `Predictor.waiting`

```gizlang
waiting(): i64
```

How many inputs wait for the server.

### `Server.seated`

```gizlang
seated(): Vec<i64>
```

The seated players' numbers, in order.

### `Server.player`

```gizlang
player(n: i64): P | undefined
```

The record of player N, if seated.

### `Server.join`

```gizlang
join(driven: bool = false): i64
```

Seats a new player: its number. A DRIVEN seat is one this program plays itself (a bot: drive): it is sent
nothing.

### `Server.leave`

```gizlang
leave(n: i64): void
```

Frees the seat of player N.

### `Server.drive`

```gizlang
drive(n: i64, input: I): void
```

The INPUT of the driven seat N for this tick, as its client would send it.

### `Server.heard`

```gizlang
heard(n: i64, data: bytes): void
```

The message DATA of player N. One that does not decode, or that a client may not send, is dropped.

### `Server.step`

```gizlang
step(): Vec<Sent>
```

One tick: every queued input applied, then the messages to send.

### `Client.welcomed`

```gizlang
welcomed(): bool
```

Whether the server has welcomed this player (seated it).

### `Client.mine`

```gizlang
mine(): P | undefined
```

The own record, as predicted.

### `Client.heard`

```gizlang
heard(data: bytes): void throws string
```

A message of the server.

### `Client.input`

```gizlang
input(input: I): void
```

Applies the own INPUT now and sends it.

### `Client.next`

```gizlang
next(): bytes
```

The next message to send, b"" none.

### `Client.others`

```gizlang
others(): Vec<P> throws string
```

The other players' records in the last state, with their numbers.

### `Session.tick`

```gizlang
tick(): void throws string
```

After the tick's input: alone, its messages through the seats here, and theirs back.

### `Session.carry`

```gizlang
carry(input: bytes): bytes
```

The host's call (Program.net): INPUT, a message of the server; b"", the next one to send (b"" none).
The first call takes the match online. A message that does not decode is dropped.

## Constants

### `MILLIMETER`

```gizlang
const MILLIMETER = 0.001
```

The step of a position that a state writes: a millimeter.

### `ANGLE`

```gizlang
const ANGLE = 0.000244140625
```

The step of an angle that a state writes: 1/4096 of a radian.

### `WELCOME`

```gizlang
const WELCOME: i64 = 1
```

WELCOME to a client (its player and the tick), INPUT from it (the tick it is for, its sequence and the game's
bytes), STATE to it (the tick, the last input sequence the server took, the tick of the state it is a delta from,
-1 none, and the delta), ACK from it (the tick of the last state it took). Who a client is the transport settles
before the first message (gizapp/netplay: a Giz sign-in token).

### `INPUT`

```gizlang
const INPUT: i64 = 2
```

From a client: its input for a tick.

### `STATE`

```gizlang
const STATE: i64 = 3
```

To a client: the state of a tick, whole or a delta.

### `ACK`

```gizlang
const ACK: i64 = 4
```

From a client: the tick of the last state it took.

