Add multiplayer to your game.

Join a room

When the game is hosted by antics this call takes no arguments: the SDK finds the server on the same origin and reads the room code out of the page's query string. Presence is immediate — the instant it resolves you are in room.players for everyone else, so there is no lobby protocol to build.

import { joinRoom } from "/sdk/v1.js";

const room = await joinRoom({});
room.code      // "KX7P2M"
room.link      // the URL that puts someone else in THIS room
room.me        // you
room.players   // everyone, including you

Publish each player's own slice

Put room.me.setState wherever you already move the local player, and read everyone back from room.players where you already draw. Writes apply locally at once and the SDK coalesces them to about 20 Hz — call it every frame, don't throttle it yourself.

room.me.setState({ x: me.x, y: me.y, angle: me.angle });

for (const p of room.players) {
  const s = p.state;   // your own write is already applied locally
  drawPlayer(s.x, s.y, s.angle, p.name);
}

Each player writes only their own slice. That's not a style preference: route everyone's movement through one authority and your own controls start waiting on a network round trip, which feels like mud.

Give the shared world to the host

One client is the host, and only that client may write room.setState — the phase, the wave, the NPCs, the scoreboard. Put the simulation inside room.onHostTick: it fires ~30 Hz only while you're host and moves to whoever is host next, so you never hand-roll the start/stop wiring. Everyone renders from onState, which delivers the full merged state, not a delta.

room.onHostTick((dtMs) => {          // runs only while you're the host
  world.step(dtMs);
  room.setState({ phase: world.phase, wave: world.wave });
});

room.onState((state) => renderWorld(state));   // every client, host included

Send events for the things that happen once

State answers "what is true right now". Events answer "what just happened" — a shot, a pickup, a hit. They're reliable and ordered, never coalesced, and a third argument replies to one player instead of the room.

room.send("shoot", { x, y, angle });
room.on("shoot", (payload, from) => spawnBullet(payload, room.player(from)));

room.send("hit", { dmg: 5 }, from);   // reply to just that player

Act on your own client first, then send. Waiting for another client to detect your hit and echo it back stacks two network hops onto your own trigger — the single most common reason a working integration still feels laggy.