Multiplayer rooms that run on Cloudflare.

import { Room, reject, type Player } from "tickflare";

type Mark = "x" | "o";
interface State {
  board: (Mark | null)[];
  marks: Record<string, Mark>; // which player plays which mark
  starts: Mark;
  turn: Mark;
  winner: Mark | "draw" | null;
  wins: Record<Mark, number>;
}
export type Command = { type: "play"; cell: number };

const LINES = [[0, 1, 2], [3, 4, 5], [6, 7, 8], [0, 3, 6], [1, 4, 7], [2, 5, 8], [0, 4, 8], [2, 4, 6]];
const other = (mark: Mark): Mark => (mark === "x" ? "o" : "x");

// No tickRate: this room runs when a player or a timer wakes it, and sleeps the rest of the time.
export class Duel extends Room<State, Command> {
  protected override maxPlayers = 2;

  protected initialState(): State {
    return { board: Array(9).fill(null), marks: {}, starts: "x", turn: "x", winner: null, wins: { x: 0, o: 0 } };
  }

  // Everything a client sends is untrusted. Check it here.
  protected parseCommand(raw: unknown): Command {
    const c = raw as Partial<Command> | null;
    if (c?.type !== "play" || !Number.isInteger(c.cell) || c.cell! < 0 || c.cell! > 8) return reject("invalid_command");
    return { type: "play", cell: c.cell! };
  }

  protected override onJoin(player: Player): void {
    this.state.marks[player.id] = Object.values(this.state.marks).includes("x") ? "o" : "x";
  }

  protected override onLeave(player: Player): void {
    delete this.state.marks[player.id];
  }

  // The rules. A move that breaks them is refused, and nothing changes.
  protected onCommand(player: Player, command: Command): void {
    const state = this.state;
    const mark = state.marks[player.id];
    if (!mark) return reject("not_playing");
    if (state.winner) return reject("game_over");
    if (state.turn !== mark) return reject("not_your_turn");
    if (state.board[command.cell]) return reject("cell_taken");

    state.board[command.cell] = mark;
    if (LINES.some((line) => line.every((cell) => state.board[cell] === mark))) {
      state.winner = mark;
      state.wins[mark] += 1;
    } else if (state.board.every(Boolean)) {
      state.winner = "draw";
    } else {
      state.turn = other(mark);
    }
    // The room goes back to sleep. In three seconds the timer wakes it for the next game.
    if (state.winner) this.setTimer("rematch", 3000);
  }

  protected override onTimer(name: string): void {
    if (name !== "rematch") return;
    const state = this.state;
    state.starts = other(state.starts);
    state.turn = state.starts;
    state.board = Array(9).fill(null);
    state.winner = null;
  }
}

import { Room, reject, type Player } from "tickflare";

interface Point {
  x: number;
  y: number;
}
interface Dot extends Point {
  tx: number;
  ty: number;
  score: number;
}
interface State {
  dots: Record<string, Dot>;
  pellets: Record<string, Point>;
  nextPellet: number;
}
export type Command = { type: "move"; x: number; y: number };

const SIZE = 100;
const SIGHT = 30; // how far a player can see
const SPEED = 26; // units a second

const near = (a: Point, b: Point, radius: number) => Math.hypot(a.x - b.x, a.y - b.y) <= radius;
const round = (n: number) => Math.round(n * 10) / 10;
const somewhere = (): Point => ({ x: 8 + Math.random() * (SIZE - 16), y: 8 + Math.random() * (SIZE - 16) });

export class Arena extends Room<State, Command> {
  protected override tickRate = 10; // onTick runs ten times a second
  protected override maxPlayers = 8;
  protected override seatTimeoutMs = 60_000; // a closed tab keeps its seat for a minute

  protected initialState(): State {
    const state: State = { dots: {}, pellets: {}, nextPellet: 0 };
    for (let n = 0; n < 8; n++) state.pellets[`p${state.nextPellet++}`] = somewhere();
    return state;
  }

  // Everything a client sends is untrusted. Check it here.
  protected parseCommand(raw: unknown): Command {
    const c = raw as Partial<Command> | null;
    if (c?.type !== "move" || !Number.isFinite(c.x) || !Number.isFinite(c.y)) return reject("invalid_command");
    const clamp = (n: number) => Math.max(3, Math.min(SIZE - 3, n));
    return { type: "move", x: clamp(c.x!), y: clamp(c.y!) };
  }

  protected override onJoin(player: Player): void {
    const at = somewhere();
    this.state.dots[player.id] = { ...at, tx: at.x, ty: at.y, score: 0 };
  }

  protected override onLeave(player: Player): void {
    delete this.state.dots[player.id];
  }

  // A command only sets a target. The simulation does the moving.
  protected onCommand(player: Player, command: Command): void {
    const dot = this.state.dots[player.id];
    if (!dot) return reject("not_playing");
    dot.tx = command.x;
    dot.ty = command.y;
  }

  protected override onTick(dt: number): void {
    const { dots, pellets } = this.state;
    for (const dot of Object.values(dots)) {
      const distance = Math.hypot(dot.tx - dot.x, dot.ty - dot.y);
      const step = Math.min(distance, SPEED * dt);
      if (step > 0) {
        dot.x = round(dot.x + ((dot.tx - dot.x) / distance) * step);
        dot.y = round(dot.y + ((dot.ty - dot.y) / distance) * step);
      }
      for (const [id, pellet] of Object.entries(pellets)) {
        if (!near(dot, pellet, 4)) continue;
        delete pellets[id];
        pellets[`p${this.state.nextPellet++}`] = somewhere();
        dot.score += 1;
      }
    }
  }

  // Each player is sent only what is within sight of their own dot.
  protected override view(player: Player) {
    const me = this.state.dots[player.id];
    if (!me) return { me: null, others: {}, pellets: {} };
    const within = <T extends Point>(things: Record<string, T>) =>
      Object.fromEntries(Object.entries(things).filter(([id, thing]) => id !== player.id && near(me, thing, SIGHT)));
    return { me, others: within(this.state.dots), pellets: within(this.state.pellets) };
  }
}

import { LockstepRoom, reject } from "tickflare";

/** "Send my squad to this point." */
export interface Order {
  x: number;
  y: number;
}

// The whole room. It never runs the game: ten times a second it closes a turn
// holding the orders that arrived, records it, and sends every player the same turns.
export class Skirmish extends LockstepRoom<Order> {
  protected override tickRate = 10; // turns a second
  protected override maxPlayers = 2;

  // Every player's simulation will be fed what this returns, so refuse anything odd.
  protected parseInput(raw: unknown): Order {
    const order = raw as Partial<Order> | null;
    const onTheMap = (n: unknown): n is number => Number.isInteger(n) && (n as number) >= 0 && (n as number) <= 1000;
    if (!onTheMap(order?.x) || !onTheMap(order?.y)) return reject("invalid_order");
    return { x: order.x, y: order.y };
  }
}