@colyseus/core 0.18.0 → 0.18.1

package/build/input/types.d.ts

@@ -0,0 +1,476 @@
+/**
+ * Types for the room input subsystem: the option shapes accepted by
+ * `Room.defineInput()`, the per-client {@link InputAccessor} / room-wide
+ * {@link InputAPI} surfaces, and the internal normalized options. Runtime
+ * lives in `InputBuffer.ts`.
+ */
+/**
+ * Names of fields on `I` whose values are `number` — used by
+ * `Room.defineInput()` to constrain `seqField` to actually-numeric fields
+ * on the input schema. Filters out booleans, strings, methods, etc.
+ */
+export type NumericFieldsOf<I> = {
+    [K in keyof I]: I[K] extends number ? (K extends string ? K : never) : never;
+}[keyof I];
+/**
+ * Context handed to the `idle` callback form — see {@link IdleInput}. A reused
+ * per-client scratch: read it inside the callback, don't store it. It carries
+ * MECHANISM only — derived judgments (e.g. liveness) stay in userland; look the
+ * client up via `this.clients.get(ctx.sessionId)` when your policy needs it.
+ */
+export interface IdleContext<I> {
+    /** Last decoded input (`undefined` before the client's first). */
+    latest: I | undefined;
+    sessionId: string;
+}
+/**
+ * What to synthesize when the buffer is empty (declared room-wide at
+ * `defineInput({ idle })`, or per-call via {@link ConsumeOptions.idle}):
+ * - `true` — pure schema defaults.
+ * - `Partial<I>` — defaults overlaid with these fields. A full schema instance
+ *   (e.g. {@link InputAccessor.latest}) also works — fields are copied BY NAME,
+ *   so its prototype accessors are read correctly.
+ * - callback — invoked LAZILY (only on an actually-empty tick) with an
+ *   {@link IdleContext}, returning either of the above. The right form when the
+ *   overrides take work to compute (entity lookups, held-button carry-over).
+ *
+ * ⚠ Do NOT build overrides by spreading a schema instance (`{ ...latest, x }`):
+ * schema fields live on the prototype, so the spread copies NOTHING of them.
+ * Return `latest` itself, or name the fields (`{ x, plant: !!latest?.plant }`).
+ */
+export type IdleInput<I> = true | Partial<I> | ((ctx: IdleContext<I>) => true | Partial<I>);
+/**
+ * Options for {@link InputAccessor.drain} / {@link InputAccessor.next}.
+ * `idle` overrides the room-level `defineInput({ idle })` policy for this call
+ * (see {@link IdleInput}); pass `false` to suppress it (force skip behavior).
+ */
+export interface ConsumeOptions<I> {
+    idle?: IdleInput<I> | false;
+}
+/**
+ * Input sanitization, declared at `defineInput({ sanitize })` — never trust the
+ * wire. Applied to each decoded frame IN PLACE, before anything reads it
+ * (`latest`, the buffer, the `idle` callback's ctx):
+ * - **Map form** — per-field `[min, max]` range clamps with NaN-safe semantics:
+ *   `NaN` (both comparisons false) lands on `min`, closing the classic
+ *   `Math.min(NaN, …)` poisoning hole.
+ * - **Callback form** — arbitrary in-place fix-up (wrap an angle, enforce a
+ *   cross-field rule) for anything beyond ranges.
+ *
+ * Sanitizers MODIFY, they never reject — a malformed value becomes a legal one
+ * instead of dropping the frame. Must not touch the `seqField` (it runs before
+ * dedupe). Semantic validation ("slot must name an owned weapon") stays in
+ * your sim — this handles value domains, not game rules.
+ */
+export type SanitizeInput<I> = Partial<Record<NumericFieldsOf<I>, readonly [number, number]>> | ((input: I) => void);
+/** Options for `Room.defineInput()`. The user-facing twin of the internal
+ *  normalized {@link NormalizedInputOptions}. */
+export interface DefineInputOptions<I = any> {
+    seqField?: NumericFieldsOf<I>;
+    bufferMaxSize?: number;
+    /**
+     * Input sanitization — never trust the wire. Applied IN PLACE to every
+     * decoded frame before anything reads it (`latest`, the buffer, the `idle`
+     * ctx). Map form = per-field `[min, max]` clamps with NaN-safe semantics
+     * (NaN → min — closes the `Math.min(NaN, …)` poisoning hole); callback form
+     * = arbitrary in-place fix-up. Sanitizers MODIFY, never reject. See
+     * {@link SanitizeInput}.
+     *
+     * ```ts
+     * sanitize: { moveF: [-1, 1], pitch: [-PITCH_LIMIT, PITCH_LIMIT], dt: [0, MAX_DT] },
+     * // or:  sanitize: (f) => { f.angle = wrapAngle(f.angle); },
+     * ```
+     */
+    sanitize?: SanitizeInput<I>;
+    /**
+     * Room-level absence policy: when a tick has no buffered input, bare
+     * `drain()` / `next()` synthesize ONE "idle" frame from it — the schema's
+     * defaults overlaid with the policy's overrides — so the sim loop needs no
+     * empty-branch. Prefer the callback form, invoked lazily (only on
+     * actually-empty ticks) with an {@link IdleContext} (`latest` + `sessionId`):
+     *
+     * ```ts
+     * idle: ({ latest, sessionId }) => {
+     *   const p = this.state.players.get(sessionId);   // closes over the room
+     *   return p ? { yaw: p.yaw, plant: !!latest?.plant } : true;
+     * }
+     * ```
+     *
+     * Not declaring it keeps the skip behavior (`drain()` → `[]`). Per-call
+     * `{ idle }` overrides this default; `{ idle: false }` suppresses it.
+     * Synthesized frames never advance the reconcile ack or `renderTime`.
+     */
+    idle?: IdleInput<I>;
+    /**
+     * Fixed step rate in **Hz** cascaded to the client via the join handshake;
+     * it predicts at dt = 1/tickRate for deterministic rollback. Defaults to
+     * the `setTimestep` rate — pass this only when the prediction
+     * step differs from it. NOTE: a *rate*, not an interval — `1000/30` is the
+     * step in ms, a classic mistake; use {@link stepMs} for that. Superseded by
+     * {@link stepMs} / {@link stepSeconds} when those are given.
+     */
+    tickRate?: number;
+    /**
+     * Fixed step as a duration in **milliseconds** — the unit-safe alternative
+     * to {@link tickRate} (`stepMs: 1000/30` is unambiguous where
+     * `tickRate: 1000/30` is a bug). Normalized to the canonical Hz value
+     * (`1000/stepMs`). Takes precedence over `tickRate`.
+     */
+    stepMs?: number;
+    /**
+     * Fixed step as a duration in **seconds** (e.g. `1/30`). Normalized to the
+     * canonical Hz value (`1/stepSeconds`). Highest precedence.
+     */
+    stepSeconds?: number;
+    /**
+     * Physics sub-steps per input tick (integer ≥ 1, default 1) — decouples the
+     * PHYSICS rate from the input/network rate. One input still drives exactly
+     * one fixed step (the replay invariant), but the simulation integrates
+     * `subSteps` engine steps of `stepSeconds/subSteps` inside it, identically
+     * on client and server — physics at `tickRate * subSteps` Hz while sending
+     * `tickRate` inputs/sec. Cascaded to clients via the join handshake;
+     * both sides read the derived numbers off their step context
+     * (`ctx.subSteps` / `ctx.subDt`) so N and dt can't drift apart.
+     * Usually declared via {@link Room.setFixedTimestep}'s `subSteps` option
+     * instead — pass it here only when the room runs its own loop.
+     */
+    subSteps?: number;
+}
+/** `true` when the defineInput opts declared an `idle` policy — narrows the
+ *  returned {@link InputAPI} so bare `next()` types non-optional `I`.
+ *  @internal — exported for {@link RoomInput.define}. */
+export type IdleDeclared<O, I> = O extends {
+    idle: IdleInput<I>;
+} ? true : false;
+/**
+ * Internal: input configuration captured by `Room.defineInput()` — the
+ * normalized form of {@link DefineInputOptions} (step declarations resolved to
+ * Hz, sanitizer compiled). The schema constructor is stored here so the
+ * runtime doesn't need to know it through the public `room.inputs` (the
+ * `.get(sessionId)` accessor).
+ *
+ * @internal
+ */
+export interface NormalizedInputOptions {
+    /**
+     * Schema constructor used to allocate per-client input instances on join.
+     * Captured by `defineInput()` from its `type` argument.
+     *
+     * Typed loosely (`new () => any`) to sidestep type-identity issues across
+     * duplicate `@colyseus/schema` installs; the runtime calls
+     * `instance.clone()` and friends, which match by shape.
+     */
+    ctor: new () => any;
+    /**
+     * Name of a monotonically-increasing numeric field on the input schema used
+     * to order and dedupe incoming frames. Unset by default (opt-in) — dedupe and
+     * `.at()` lookup are off unless you name a field here. When set, the framework:
+     * - Drops redundant frames (`input[seqField]` ≤ the last-seen value are
+     *   discarded before they enter the buffer) — the unreliable-mode
+     *   ring-redundancy pattern.
+     * - Powers `room.inputs.get(sessionId).at(value)` lookups.
+     *
+     * Despite the name, "seq" here is broader than an integer counter — any
+     * monotonic numeric field works:
+     * - **Sequence counter** (`"seq"`, `"tick"`, `"frame"`) — typical for
+     *   lockstep / rollback netcode.
+     * - **Timestamp** (`"timestamp"`, milliseconds or seconds) — useful for
+     *   variable-rate clients, lag compensation, hit registration (a float-seconds
+     *   timestamp stamped on each saved move is the common shape).
+     *
+     * Whichever you use, the field must increase monotonically across frames
+     * for dedupe to work.
+     */
+    seqField?: string;
+    /**
+     * > 0 enables per-client buffering of cloned snapshots — required for
+     * `room.inputs.get(sessionId).drain() / .peek() / .at()` to return populated
+     * data. Oldest drops on overflow. Set to `0` to disable (`.latest` still
+     * works).
+     */
+    bufferMaxSize: number;
+    /**
+     * Fixed step rate (Hz) advertised to clients via the join handshake; they
+     * predict at dt = 1/tickRate. Set explicitly via `defineInput`, or derived
+     * from `setTimestep`. Unset = not advertised.
+     */
+    tickRate?: number;
+    /**
+     * Physics sub-steps per input tick (integer ≥ 1) advertised to clients via
+     * the join handshake — the simulation integrates `subSteps` engine steps of
+     * `(1/tickRate)/subSteps` per input on BOTH sides, so physics runs at
+     * `tickRate * subSteps` Hz on a `tickRate` input/network rate. Set via
+     * `setFixedTimestep(..., { subSteps })` (or `defineInput`). Unset/1 = not
+     * advertised (input rate == physics rate).
+     */
+    subSteps?: number;
+    /**
+     * Room-level absence policy: bare `drain()` / `next()` synthesize one idle
+     * frame from it when a tick has no input. See {@link IdleInput}.
+     */
+    idle?: IdleInput<any>;
+    /**
+     * COMPILED sanitizer (see {@link SanitizeInput} / `compileSanitizer`) —
+     * applied in place to each decoded frame before it becomes visible to
+     * `latest` / the buffer / the idle ctx.
+     */
+    sanitize?: (instance: any) => void;
+}
+/**
+ * Per-client input accessor returned by `room.inputs.get(sessionId)`. Combines the
+ * latest decoded instance with the (optional) snapshot ring buffer.
+ *
+ * - {@link latest} — the bound Schema instance, mutated in place by the
+ *   decoder. Cheapest read; use when only the most recent state matters.
+ * - {@link consume} / `for (const inp of accessor)` / {@link drain} /
+ *   {@link next} / {@link take} / {@link peek} / {@link at} — populated when
+ *   `defineInput()` was called with `bufferMaxSize > 0` (default 32). Use for
+ *   rollback netcode / lockstep where every frame matters.
+ *
+ * **Per-entity vs shared world** — pick the consume primitive by who integrates:
+ * - **Per-entity** (each body integrates itself): iterate the accessor —
+ *   `for (const inp of this.inputs.get(sid))` (sugar for {@link consume}) — and
+ *   sub-integrate one per input. N inputs = N steps for that player, ack lands
+ *   on the newest applied. The clean default. Iterating consumes ONE AT A TIME,
+ *   so {@link renderTime} tracks each input (lag comp stays exact per step) and
+ *   `break` leaves the rest buffered. {@link drain} returns the same set as an
+ *   array (retainable), but reports only the newest input's {@link renderTime}.
+ * - **Shared world** (one solver step advances every body together): you can't
+ *   replay N inputs as N world steps without over-stepping everyone else, so
+ *   {@link next} exactly one input per entity per tick (or {@link take} a bounded
+ *   few and sub-step the solver per input). The ack then === inputs actually
+ *   simulated; `drain()`-then-apply-latest would silently jump the ack past
+ *   inputs the server never simulated, snapping the client's reconciler.
+ *
+ * Returned for unknown sessionIds and rooms without `defineInput()` is a
+ * frozen no-op accessor (latest=undefined, drain/next/take/peek=[]/undefined,
+ * at=undefined, size=0, clear=no-op).
+ *
+ * `Idle` is `true` when the room declared `defineInput({ idle })` — it narrows
+ * {@link next} to non-optional `I` (bare calls always yield a frame).
+ */
+export interface InputAccessor<I = any, Idle extends boolean = false> {
+    /** Latest decoded input. `undefined` when unknown sessionId or no input declared. */
+    readonly latest: I | undefined;
+    /**
+     * Find the buffered snapshot whose `[seqField]` equals `value`. The field
+     * name is the Room's `defineInput()` `seqField`. Linear scan — cheap for
+     * typical buffer sizes; not intended for very large rings. Returns
+     * `undefined` when no match is buffered (or `seqField` isn't configured).
+     *
+     * Useful for tick-aligned retrieval (lockstep, rollback).
+     */
+    at(value: number): I | undefined;
+    /**
+     * The blessed **per-entity** loop: consume each pending input oldest → newest,
+     * ONE AT A TIME. Unlike {@link drain} (which reports only the newest input's
+     * stamps up front), iterating updates {@link renderTime}/{@link reckonTime} and
+     * advances {@link consumedCount} per yielded input — so per-step lag comp
+     * rewinds to the exact instant of the input being applied:
+     *
+     * ```ts
+     * for (const inp of this.inputs.get(sid)) {   // sugar: accessor is iterable
+     *   applyInput(p, inp, dt);
+     *   this.collide(sid, p);                // renderTime === THIS input's stamp
+     *   if (!p.alive) break;                 // break leaves the rest buffered
+     * }
+     * ```
+     *
+     * When the buffer is empty and an `idle` policy is in effect (room-level, or
+     * per-call `opts.idle`), yields EXACTLY ONE idle frame (not consumed: no ack
+     * bump, no {@link renderTime} change, {@link wasIdle} === true) then stops. No
+     * policy + empty → zero iterations. Unknown sessionId / `bufferMaxSize: 0` →
+     * empty. `for (const inp of accessor)` is `consume()` with no opts.
+     *
+     * The returned iterator is POOLED (reused per call, allocation-free). For
+     * `for..of` / spread / `Array.from` this is invisible. If you drive it by hand,
+     * iterate it once to completion (or call `.return()` / `break`) before the next
+     * `consume()`, and read each `.next()` result before the next — don't retain or
+     * compare result objects. (Nesting two `consume()` loops over the SAME channel
+     * is handled safely but is meaningless — both share one cursor.)
+     */
+    consume(opts?: ConsumeOptions<I>): IterableIterator<I>;
+    /** Iterate pending (and/or one idle) inputs — sugar for {@link consume}(). */
+    [Symbol.iterator](): IterableIterator<I>;
+    /**
+     * Take everything buffered (oldest → newest) and clear. Snapshots are safe to retain.
+     *
+     * With a room-level `defineInput({ idle })` policy the result is TOTAL: an
+     * empty tick yields one synthesized "idle" frame instead of `[]`, so the sim
+     * loop needs no empty-branch (gravity still integrates, action guards
+     * naturally no-op on default values). The synthesized frame is the schema's
+     * DEFAULTS overlaid with the policy's overrides (see {@link IdleInput}):
+     *
+     * ```ts
+     * // declared once at defineInput({ idle: (ctx) => ({ ... }) }); then simply:
+     * for (const f of this.inputs.get(sid).drain()) {
+     *   stepPlayer(p, f, world);          // ≥1 frame, always
+     *   if (f.fire) tryFire(...);         // idle frame: fire=false → no-op
+     * }
+     * ```
+     *
+     * Pass `{ idle }` to override the room policy for this call, or
+     * `{ idle: false }` to suppress it.
+     *
+     * The idle frame is NOT a consumed input: it advances neither the reconcile
+     * ack (`consumedCount`) nor {@link renderTime}. It is ONE reused instance per
+     * client, refilled on each synthesis — read it within the tick, don't store
+     * it. No synthesis for unknown sessionIds or `bufferMaxSize: 0`.
+     */
+    drain(opts?: ConsumeOptions<I>): I[];
+    /**
+     * Consume the single oldest buffered input and advance the reconcile ack by
+     * exactly one — the complement to {@link peek}. Returns `undefined`
+     * when the buffer is empty.
+     *
+     * Use this in a **shared-world** loop where one solver step advances every
+     * entity together: you can't apply N-inputs-per-player as N world steps without
+     * over-stepping the others, so consume one input per entity per fixed step
+     * instead. {@link drain} (consume all, ack jumps to newest) is correct only
+     * when each entity integrates ITSELF — see the {@link InputAccessor} docs.
+     *
+     * `consumedCount`/{@link renderTime} stay exact: the ack reflects only the
+     * inputs you actually simulated, and `renderTime` is the stamp of THIS input.
+     *
+     * With a room-level `defineInput({ idle })` policy (or a per-call `{ idle }`
+     * override) an empty tick returns a synthesized frame instead of `undefined`
+     * — same contract as {@link drain}'s. A "held key keeps moving through a
+     * packet gap" loop:
+     *
+     * @example
+     * ```ts
+     * // declared once:
+     * inputs = this.defineInput(InputSchema, {
+     *   idle: ({ latest }) => latest ?? true,   // empty tick → last input verbatim
+     * });
+     * // per tick:
+     * this.setFixedTimestep(() => {
+     *   for (const [sid, body] of bodies) {
+     *     applyInputToBody(body, this.inputs.get(sid).next());   // typed I — never undefined
+     *   }
+     *   world.step();                                       // one step for everyone
+     * }, 30);
+     * ```
+     */
+    next(): Idle extends true ? I : I | undefined;
+    next(opts: {
+        idle: IdleInput<I>;
+    }): I;
+    next(opts?: ConsumeOptions<I>): I | undefined;
+    /**
+     * Consume up to `n` oldest buffered inputs (oldest → newest) and advance the
+     * reconcile ack by the count actually taken. Returns fewer than `n` (or `[]`)
+     * when the buffer holds fewer. Use for shared-world **sub-stepping** — apply
+     * each taken input as its own solver sub-step within one tick, bounding the
+     * sub-steps per tick. {@link next} is the `take(1)` shorthand.
+     */
+    take(n: number): I[];
+    /** Read everything buffered without consuming. */
+    peek(): I[];
+    /** Number of snapshots currently buffered. */
+    readonly size: number;
+    /**
+     * Cumulative count of this client's inputs CONSUMED so far — the reconcile ack
+     * echoed back to the client (its `lastProcessed`). Advances by one per
+     * {@link next}, by the count taken per {@link take}/{@link drain}, by one per
+     * yield while iterating {@link consume}, and on overflow-drop; a synthesized
+     * idle frame NEVER advances it. Monotonic, so it doubles as a server-side input
+     * seq — gate per-input actions off it (e.g. a fire cooldown counted in inputs)
+     * instead of hand-rolling a counter. `0` before the first consume / for the
+     * no-op accessor.
+     */
+    readonly consumedCount: number;
+    /**
+     * `true` when the most recently produced frame was a synthesized idle (vs a
+     * real consumed input) — the "skip work on idle" guard. Set per consume
+     * call/yield: `true` after a {@link next}/{@link consume}/{@link drain} that
+     * fell back to the `idle` policy on an empty buffer, `false` after a real
+     * input. Always `false` for {@link take} (never synthesizes) and the no-op
+     * accessor. Reads meaningfully right after the consume that produced the frame.
+     */
+    readonly wasIdle: boolean;
+    /** Drop all buffered snapshots (also resets the dedupe tracker). */
+    clear(): void;
+    /**
+     * Server-clock render timestamp (ms since room start) of the most recently
+     * consumed input — the time the client was rendering the world at when it
+     * issued that input. Tracks the consume primitive: {@link drain}/{@link take}
+     * report the NEWEST input they consumed; {@link next} and each
+     * {@link consume}/`for..of` yield report THAT one input, so per-input loops
+     * rewind to the exact instant of the input simulated.
+     * `0` until the first render-time-stamped input is consumed. Populated only
+     * when the room rewinds a `mode:"snapshot"` group (which auto-enables the
+     * renderTime stamp) and `bufferMaxSize > 0`. Usually you don't read this
+     * directly — pass the
+     * sessionId to `rewind.lastSeenBy(sessionId)` (which resolves this value, clamps
+     * it, and falls back to live) for lag-compensated "what you see is what you
+     * hit" hit registration; use this getter only for a custom rewind time.
+     */
+    readonly renderTime: number;
+    /**
+     * Reckon-display stamp (server-clock ms) of the most recently consumed input
+     * — the client's serverNow ESTIMATE when it sampled that input, i.e. the
+     * exact instant its forward-reckoned (`mode:"reckon"`) entities were
+     * displayed at. Stamping the display instant DIRECTLY makes the rewind read
+     * immune to the client's RTT-estimation error: the client displayed
+     * `f(serverNow_est)` and the server reads `f(serverNow_est)` — the same
+     * index into the same recorded timeline, so estimation error cancels (the
+     * `maxRewindMs` clamp still bounds spoofing). Same consume semantics as
+     * {@link renderTime}; consumed automatically by `rewind.lastSeenBy()` —
+     * rarely read directly.
+     *
+     * Always a usable instant: when no reckon-stamped input has been consumed
+     * yet (lag-comp off, client clock unsynced, nothing consumed), resolves to
+     * the room clock's current `elapsedTime` — the fallback rooms previously
+     * hand-wrote as `reckonTime > 0 ? reckonTime : now`. `rewind.lastSeenBy()`
+     * internally reads the raw stamp, so its midpoint reconstruction still
+     * engages for unstamped clients. The no-op accessor (unknown session / no
+     * `defineInput()`) returns `0`.
+     */
+    readonly reckonTime: number;
+}
+/**
+ * Returned by `Room.defineInput()`. Assign it to `this.inputs`, then call
+ * `room.inputs.get(sessionId)` per tick to read each client's input stream —
+ * the same per-session lookup verb as `room.clients.get(sessionId)`.
+ *
+ * The fixed-step metadata lives HERE (one per room), not on the per-client
+ * {@link InputAccessor} — these values are identical for every client, so they'd
+ * be pure duplication per connection. `.get()` keeps the accessor and this
+ * metadata cleanly separated.
+ */
+export type InputAPI<I = any, Idle extends boolean = false> = {
+    /**
+     * The input accessor for `sessionId` — the per-client stream you iterate /
+     * `.next()` / `.drain()`. Returns a frozen no-op accessor for unknown sessions.
+     * Mirrors `room.clients.get(sessionId)`.
+     */
+    get(sessionId: string): InputAccessor<I, Idle>;
+    /**
+     * Server-advertised fixed step rate in **Hz** — from `defineInput`'s
+     * `tickRate`/`stepMs`/`stepSeconds`, or derived from `setTimestep` —
+     * the same value cascaded to predicting clients. `undefined` when no fixed
+     * step is advertised.
+     */
+    readonly tickRate?: number;
+    /**
+     * The fixed step as **seconds** (`1/tickRate`): the dt to integrate one input
+     * with, bit-identical to the client's prediction dt. Pass it to your physics
+     * step (`applyInput(p, cmd, level, room.inputs.stepSeconds)`) so server and
+     * client share one timestep instead of each keeping a constant that can drift.
+     * `undefined` when no rate is advertised.
+     */
+    readonly stepSeconds?: number;
+    /** The fixed step as **milliseconds** (`1000/tickRate`). `undefined` when no rate. */
+    readonly stepMs?: number;
+    /** Physics sub-steps per input tick (≥ 1; `1` unless declared via
+     *  `setFixedTimestep(..., { subSteps })` / `defineInput`). */
+    readonly subSteps: number;
+    /** The physics sub-step as **seconds** (`stepSeconds / subSteps`) — the engine
+     *  dt when sub-stepping; equals {@link stepSeconds} when `subSteps` is 1.
+     *  `undefined` when no rate is advertised. */
+    readonly subStepSeconds?: number;
+    /** The physics sub-step as **milliseconds** (`stepMs / subSteps`). `undefined`
+     *  when no rate is advertised. */
+    readonly subStepMs?: number;
+};

package/build/input/types.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

package/build/rooms/QueueRoom.cjs

@@ -98,7 +98,7 @@ var QueueRoom = class extends import_Room.Room {
       throw new import_ServerError.ServerError(import_shared_types.ErrorCode.APPLICATION_ERROR, "QueueRoom: 'matchRoomName' option is required.");
     }
     (0, import_Debug.debugMatchMaking)("QueueRoom#onCreate() maxPlayers: %d, maxWaitingCycles: %d, maxTeamSize: %d, allowIncompleteGroups: %d, roomNameToCreate: %s", this.maxPlayers, this.maxWaitingCycles, this.maxTeamSize, this.allowIncompleteGroups, this.matchRoomName);
-    this.setSimulationInterval(() => this.reassignMatchGroups(), this.cycleTickInterval);
+    this.setTimestep(() => this.reassignMatchGroups(), this.cycleTickInterval);
   }
   onJoin(client, options, auth) {
     this.addToQueue(client, {

package/build/rooms/QueueRoom.cjs.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/rooms/QueueRoom.ts"],
-  "sourcesContent": ["import { Room } from '../Room.ts';\nimport type { Client } from '../Transport.ts';\nimport type { IRoomCache } from '../matchmaker/driver.ts';\nimport * as matchMaker from '../MatchMaker.ts';\nimport { debugMatchMaking } from '../Debug.ts';\nimport { ServerError } from '../errors/ServerError.ts';\nimport { CloseCode, ErrorCode } from '@colyseus/shared-types';\n\nexport interface QueueOptions {\n  /**\n   * number of players on each match\n   */\n  maxPlayers?: number;\n\n  /**\n   * name of the room to create\n   */\n  matchRoomName: string;\n\n  /**\n   * after these cycles, create a match with a bot\n   */\n  maxWaitingCycles?: number;\n\n  /**\n   * after this time, try to fit this client with a not-so-compatible group\n   */\n  maxWaitingCyclesForPriority?: number;\n\n  /**\n   * If set, teams must have the same size to be matched together\n   */\n  maxTeamSize?: number;\n\n  /**\n   * If `allowIncompleteGroups` is true, players inside an unmatched group (that\n   * did not reached `maxPlayers`, and `maxWaitingCycles` has been\n   * reached) will be matched together. Your room should fill the remaining\n   * spots with \"bots\" on this case.\n   */\n  allowIncompleteGroups?: boolean;\n\n  /**\n   * Comparison function for matching clients to groups\n   * Returns true if the client is compatible with the group\n   */\n  compare?: (client: QueueClientData, matchGroup: QueueMatchGroup) => boolean;\n\n  /**\n   *\n   * When onGroupReady is set, the \"roomNameToCreate\" option is ignored.\n   */\n  onGroupReady?: (this: QueueRoom, group: QueueMatchGroup) => Promise<IRoomCache>;\n}\n\nexport interface QueueMatchGroup {\n  averageRank: number;\n  clients: Array<Client<{ userData: QueueClientData }>>,\n  ready?: boolean;\n  confirmed?: number;\n}\n\nexport interface QueueMatchTeam {\n  averageRank: number;\n  clients: Array<Client<{ userData: QueueClientData }>>,\n  teamId: string | symbol;\n}\n\nexport interface QueueClientData {\n  /**\n   * Rank of the client\n   */\n  rank: number;\n\n  /**\n   * Timestamp of when the client entered the queue\n   */\n  currentCycle?: number;\n\n  /**\n   * Optional: if matching with a team, the team ID\n   */\n  teamId?: string;\n\n  /**\n   * Additional options passed by the client when joining the room\n   */\n  options?: any;\n\n  /**\n   * Match group the client is currently in\n   */\n  group?: QueueMatchGroup;\n\n  /**\n   * Whether the client has confirmed the connection to the room\n   */\n  confirmed?: boolean;\n\n  /**\n   * Whether the client should be prioritized in the queue\n   * (e.g. for players that are waiting for a long time)\n   */\n  highPriority?: boolean;\n\n  /**\n   * The last number of clients in the queue sent to the client\n   */\n  lastQueueClientCount?: number;\n}\n\n//\n// Optional: strongly-typed client messages\n// (This is optional, but recommended for better type safety and code generation for native SDKs)\n//\ntype QueueClient = Client<{\n  userData: QueueClientData;\n  messages: {\n    clients: number;\n    seat: matchMaker.ISeatReservation;\n  }\n}>;\n\nconst DEFAULT_TEAM = Symbol(\"$default_team\");\nconst DEFAULT_COMPARE = (client: QueueClientData, matchGroup: QueueMatchGroup) => {\n  const diff = Math.abs(client.rank - matchGroup.averageRank);\n  const diffRatio = (diff / matchGroup.averageRank);\n  // If diff ratio is too high, create a new match group\n  return (diff < 10 || diffRatio <= 2);\n}\n\nexport class QueueRoom extends Room {\n  maxPlayers = 4;\n  maxTeamSize: number;\n  allowIncompleteGroups: boolean = false;\n\n  maxWaitingCycles = 15;\n  maxWaitingCyclesForPriority?: number = 10;\n\n  /**\n   * Evaluate groups for each client at interval\n   */\n  cycleTickInterval = 1000;\n\n  /**\n   * Groups of players per iteration\n   */\n  groups: QueueMatchGroup[] = [];\n  highPriorityGroups: QueueMatchGroup[] = [];\n\n  matchRoomName: string;\n\n  protected compare = DEFAULT_COMPARE;\n  protected onGroupReady = (group: QueueMatchGroup) => matchMaker.createRoom(this.matchRoomName, {});\n\n  messages = {\n    confirm: (client: Client, _: unknown) => {\n      const queueData = client.userData;\n\n      if (queueData && queueData.group && typeof (queueData.group.confirmed) === \"number\") {\n        queueData.confirmed = true;\n        queueData.group.confirmed++;\n        client.leave(CloseCode.NORMAL_CLOSURE);\n      }\n    },\n  }\n\n  onCreate(options: QueueOptions) {\n    if (typeof(options.maxWaitingCycles) === \"number\") {\n      this.maxWaitingCycles = options.maxWaitingCycles;\n    }\n\n    if (typeof(options.maxPlayers) === \"number\") {\n      this.maxPlayers = options.maxPlayers;\n    }\n\n    if (typeof(options.maxTeamSize) === \"number\") {\n      this.maxTeamSize = options.maxTeamSize;\n    }\n\n    if (typeof(options.allowIncompleteGroups) !== \"undefined\") {\n      this.allowIncompleteGroups = options.allowIncompleteGroups;\n    }\n\n    if (typeof(options.compare) === \"function\") {\n      this.compare = options.compare;\n    }\n\n    if (typeof(options.onGroupReady) === \"function\") {\n      this.onGroupReady = options.onGroupReady;\n    }\n\n    if (options.matchRoomName) {\n      this.matchRoomName = options.matchRoomName;\n\n    } else {\n      throw new ServerError(ErrorCode.APPLICATION_ERROR, \"QueueRoom: 'matchRoomName' option is required.\");\n    }\n\n    debugMatchMaking(\"QueueRoom#onCreate() maxPlayers: %d, maxWaitingCycles: %d, maxTeamSize: %d, allowIncompleteGroups: %d, roomNameToCreate: %s\", this.maxPlayers, this.maxWaitingCycles, this.maxTeamSize, this.allowIncompleteGroups, this.matchRoomName);\n\n    /**\n     * Redistribute clients into groups at every interval\n     */\n    this.setSimulationInterval(() => this.reassignMatchGroups(), this.cycleTickInterval);\n  }\n\n  onJoin(client: QueueClient, options: any, auth?: unknown) {\n    this.addToQueue(client, {\n      rank: options.rank,\n      teamId: options.teamId,\n      options,\n    });\n  }\n\n  addToQueue(client: QueueClient, queueData: QueueClientData) {\n    if (queueData.currentCycle === undefined) {\n      queueData.currentCycle = 0;\n    }\n    client.userData = queueData;\n\n    // FIXME: reassign groups upon joining [?] (without incrementing cycle count)\n    client.send(\"clients\", 1);\n  }\n\n  createMatchGroup() {\n    const group: QueueMatchGroup = { clients: [], averageRank: 0 };\n    this.groups.push(group);\n    return group;\n  }\n\n  reassignMatchGroups() {\n    // Re-set all groups\n    this.groups.length = 0;\n    this.highPriorityGroups.length = 0;\n\n    const sortedClients = (this.clients)\n      .filter((client) => {\n        // Filter out:\n        // - clients that are not in the queue\n        // - clients that are already in a \"ready\" group\n        return (\n          client.userData &&\n          client.userData.group?.ready !== true\n        );\n      })\n      .sort((a, b) => {\n        //\n        // Sort by rank ascending\n        //\n        return a.userData.rank - b.userData.rank;\n      });\n\n    //\n    // The room either distribute by teams or by clients\n    //\n    if (typeof(this.maxTeamSize) === \"number\") {\n      this.redistributeTeams(sortedClients);\n\n    } else {\n      this.redistributeClients(sortedClients);\n    }\n\n    this.evaluateHighPriorityGroups();\n    this.processGroupsReady();\n  }\n\n  redistributeTeams(sortedClients: Client<{ userData: QueueClientData }>[]) {\n    const teamsByID: { [teamId: string | symbol]: QueueMatchTeam } = {};\n\n    sortedClients.forEach((client) => {\n      const teamId = client.userData.teamId || DEFAULT_TEAM;\n\n      // Create a new team if it doesn't exist\n      if (!teamsByID[teamId]) {\n        teamsByID[teamId] = { teamId: teamId, clients: [], averageRank: 0, };\n      }\n\n      teamsByID[teamId].averageRank += client.userData.rank;\n      teamsByID[teamId].clients.push(client);\n    });\n\n    // Calculate average rank for each team\n    let teams = Object.values(teamsByID).map((team) => {\n      team.averageRank /= team.clients.length;\n      return team;\n    }).sort((a, b) => {\n      // Sort by average rank ascending\n      return a.averageRank - b.averageRank;\n    });\n\n    // Iterate over teams multiple times until all clients are assigned to a group\n    do {\n      let currentGroup: QueueMatchGroup = this.createMatchGroup();\n      teams = teams.filter((team) => {\n        // Remove clients from the team and add them to the current group\n        const totalRank = team.averageRank * team.clients.length;\n\n        // currentGroup.averageRank = (currentGroup.averageRank === undefined)\n        //   ? team.averageRank\n        //   : (currentGroup.averageRank + team.averageRank) / ;\n        currentGroup = this.redistributeClients(team.clients.splice(0, this.maxTeamSize), currentGroup, totalRank);\n\n        if (team.clients.length >= this.maxTeamSize) {\n          // team still has enough clients to form a group\n          return true;\n        }\n\n        // increment cycle count for all clients in the team\n        team.clients.forEach((client) => client.userData.currentCycle++);\n\n        return false;\n      });\n    } while (teams.length >= 2);\n  }\n\n  redistributeClients(\n    sortedClients: Client<{ userData: QueueClientData }>[],\n    currentGroup: QueueMatchGroup = this.createMatchGroup(),\n    totalRank: number = 0,\n  ) {\n    for (let i = 0, l = sortedClients.length; i < l; i++) {\n      const client = sortedClients[i];\n      const userData = client.userData;\n      const currentCycle = userData.currentCycle++;\n\n      if (currentGroup.averageRank > 0) {\n        if (\n          !this.compare(userData, currentGroup) &&\n          !userData.highPriority\n        ) {\n          currentGroup = this.createMatchGroup();\n          totalRank = 0;\n        }\n      }\n\n      userData.group = currentGroup;\n      currentGroup.clients.push(client);\n\n      totalRank += userData.rank;\n      currentGroup.averageRank = totalRank / currentGroup.clients.length;\n\n      // Enough players in the group, mark it as ready!\n      if (currentGroup.clients.length === this.maxPlayers) {\n        currentGroup.ready = true;\n        currentGroup = this.createMatchGroup();\n        totalRank = 0;\n        continue;\n      }\n\n      if (currentCycle >= this.maxWaitingCycles && this.allowIncompleteGroups) {\n        /**\n         * Match long-waiting clients with bots\n         */\n        if (this.highPriorityGroups.indexOf(currentGroup) === -1) {\n          this.highPriorityGroups.push(currentGroup);\n        }\n\n      } else if (\n        this.maxWaitingCyclesForPriority !== undefined &&\n        currentCycle >= this.maxWaitingCyclesForPriority\n      ) {\n        /**\n         * Force this client to join a group, even if rank is incompatible\n         */\n        userData.highPriority = true;\n      }\n    }\n\n    return currentGroup;\n  }\n\n  evaluateHighPriorityGroups() {\n    /**\n     * Evaluate groups with high priority clients\n     */\n    this.highPriorityGroups.forEach((group) => {\n      group.ready = group.clients.every((c) => {\n        // Give new clients another chance to join a group that is not \"high priority\"\n        return c.userData?.currentCycle > 1;\n        // return c.userData?.currentCycle >= this.maxWaitingCycles;\n      });\n    });\n  }\n\n  processGroupsReady() {\n    this.groups.forEach(async (group) => {\n      if (group.ready) {\n        group.confirmed = 0;\n\n        try {\n          /**\n           * Create room instance in the server.\n           */\n          const room = await this.onGroupReady.call(this, group);\n\n          /**\n           * Reserve a seat for each client in the group.\n           * (If one fails, force all clients to leave, re-queueing is up to the client-side logic)\n           */\n          await matchMaker.reserveMultipleSeatsFor(\n            room,\n            group.clients.map((client) => ({\n              sessionId: client.sessionId,\n              options: client.userData.options,\n              auth: client.auth,\n            })),\n          );\n\n          /**\n           * Send room data for new WebSocket connection!\n           */\n          group.clients.forEach((client, i) => {\n            client.send(\"seat\", matchMaker.buildSeatReservation(room, client.sessionId));\n          });\n\n        } catch (e: any) {\n          //\n          // If creating a room, or reserving a seat failed - fail all clients\n          // Whether the clients retry or not is up to the client-side logic\n          //\n          group.clients.forEach(client => client.leave(1011, e.message));\n        }\n\n      } else {\n        /**\n         * Notify clients within the group on how many players are in the queue\n         */\n        group.clients.forEach((client) => {\n          //\n          // avoid sending the same number of clients to the client if it hasn't changed\n          //\n          const queueClientCount = group.clients.length;\n          if (client.userData.lastQueueClientCount !== queueClientCount) {\n            client.userData.lastQueueClientCount = queueClientCount;\n            client.send(\"clients\", queueClientCount);\n          }\n        });\n      }\n    });\n  }\n\n}"],
-  "mappings": "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",
+  "sourcesContent": ["import { Room } from '../Room.ts';\nimport type { Client } from '../Transport.ts';\nimport type { IRoomCache } from '../matchmaker/driver.ts';\nimport * as matchMaker from '../MatchMaker.ts';\nimport { debugMatchMaking } from '../Debug.ts';\nimport { ServerError } from '../errors/ServerError.ts';\nimport { CloseCode, ErrorCode } from '@colyseus/shared-types';\n\nexport interface QueueOptions {\n  /**\n   * number of players on each match\n   */\n  maxPlayers?: number;\n\n  /**\n   * name of the room to create\n   */\n  matchRoomName: string;\n\n  /**\n   * after these cycles, create a match with a bot\n   */\n  maxWaitingCycles?: number;\n\n  /**\n   * after this time, try to fit this client with a not-so-compatible group\n   */\n  maxWaitingCyclesForPriority?: number;\n\n  /**\n   * If set, teams must have the same size to be matched together\n   */\n  maxTeamSize?: number;\n\n  /**\n   * If `allowIncompleteGroups` is true, players inside an unmatched group (that\n   * did not reached `maxPlayers`, and `maxWaitingCycles` has been\n   * reached) will be matched together. Your room should fill the remaining\n   * spots with \"bots\" on this case.\n   */\n  allowIncompleteGroups?: boolean;\n\n  /**\n   * Comparison function for matching clients to groups\n   * Returns true if the client is compatible with the group\n   */\n  compare?: (client: QueueClientData, matchGroup: QueueMatchGroup) => boolean;\n\n  /**\n   *\n   * When onGroupReady is set, the \"roomNameToCreate\" option is ignored.\n   */\n  onGroupReady?: (this: QueueRoom, group: QueueMatchGroup) => Promise<IRoomCache>;\n}\n\nexport interface QueueMatchGroup {\n  averageRank: number;\n  clients: Array<Client<{ userData: QueueClientData }>>,\n  ready?: boolean;\n  confirmed?: number;\n}\n\nexport interface QueueMatchTeam {\n  averageRank: number;\n  clients: Array<Client<{ userData: QueueClientData }>>,\n  teamId: string | symbol;\n}\n\nexport interface QueueClientData {\n  /**\n   * Rank of the client\n   */\n  rank: number;\n\n  /**\n   * Timestamp of when the client entered the queue\n   */\n  currentCycle?: number;\n\n  /**\n   * Optional: if matching with a team, the team ID\n   */\n  teamId?: string;\n\n  /**\n   * Additional options passed by the client when joining the room\n   */\n  options?: any;\n\n  /**\n   * Match group the client is currently in\n   */\n  group?: QueueMatchGroup;\n\n  /**\n   * Whether the client has confirmed the connection to the room\n   */\n  confirmed?: boolean;\n\n  /**\n   * Whether the client should be prioritized in the queue\n   * (e.g. for players that are waiting for a long time)\n   */\n  highPriority?: boolean;\n\n  /**\n   * The last number of clients in the queue sent to the client\n   */\n  lastQueueClientCount?: number;\n}\n\n//\n// Optional: strongly-typed client messages\n// (This is optional, but recommended for better type safety and code generation for native SDKs)\n//\ntype QueueClient = Client<{\n  userData: QueueClientData;\n  messages: {\n    clients: number;\n    seat: matchMaker.ISeatReservation;\n  }\n}>;\n\nconst DEFAULT_TEAM = Symbol(\"$default_team\");\nconst DEFAULT_COMPARE = (client: QueueClientData, matchGroup: QueueMatchGroup) => {\n  const diff = Math.abs(client.rank - matchGroup.averageRank);\n  const diffRatio = (diff / matchGroup.averageRank);\n  // If diff ratio is too high, create a new match group\n  return (diff < 10 || diffRatio <= 2);\n}\n\nexport class QueueRoom extends Room {\n  maxPlayers = 4;\n  maxTeamSize: number;\n  allowIncompleteGroups: boolean = false;\n\n  maxWaitingCycles = 15;\n  maxWaitingCyclesForPriority?: number = 10;\n\n  /**\n   * Evaluate groups for each client at interval\n   */\n  cycleTickInterval = 1000;\n\n  /**\n   * Groups of players per iteration\n   */\n  groups: QueueMatchGroup[] = [];\n  highPriorityGroups: QueueMatchGroup[] = [];\n\n  matchRoomName: string;\n\n  protected compare = DEFAULT_COMPARE;\n  protected onGroupReady = (group: QueueMatchGroup) => matchMaker.createRoom(this.matchRoomName, {});\n\n  messages = {\n    confirm: (client: Client, _: unknown) => {\n      const queueData = client.userData;\n\n      if (queueData && queueData.group && typeof (queueData.group.confirmed) === \"number\") {\n        queueData.confirmed = true;\n        queueData.group.confirmed++;\n        client.leave(CloseCode.NORMAL_CLOSURE);\n      }\n    },\n  }\n\n  onCreate(options: QueueOptions) {\n    if (typeof(options.maxWaitingCycles) === \"number\") {\n      this.maxWaitingCycles = options.maxWaitingCycles;\n    }\n\n    if (typeof(options.maxPlayers) === \"number\") {\n      this.maxPlayers = options.maxPlayers;\n    }\n\n    if (typeof(options.maxTeamSize) === \"number\") {\n      this.maxTeamSize = options.maxTeamSize;\n    }\n\n    if (typeof(options.allowIncompleteGroups) !== \"undefined\") {\n      this.allowIncompleteGroups = options.allowIncompleteGroups;\n    }\n\n    if (typeof(options.compare) === \"function\") {\n      this.compare = options.compare;\n    }\n\n    if (typeof(options.onGroupReady) === \"function\") {\n      this.onGroupReady = options.onGroupReady;\n    }\n\n    if (options.matchRoomName) {\n      this.matchRoomName = options.matchRoomName;\n\n    } else {\n      throw new ServerError(ErrorCode.APPLICATION_ERROR, \"QueueRoom: 'matchRoomName' option is required.\");\n    }\n\n    debugMatchMaking(\"QueueRoom#onCreate() maxPlayers: %d, maxWaitingCycles: %d, maxTeamSize: %d, allowIncompleteGroups: %d, roomNameToCreate: %s\", this.maxPlayers, this.maxWaitingCycles, this.maxTeamSize, this.allowIncompleteGroups, this.matchRoomName);\n\n    /**\n     * Redistribute clients into groups at every interval\n     */\n    this.setTimestep(() => this.reassignMatchGroups(), this.cycleTickInterval);\n  }\n\n  onJoin(client: QueueClient, options: any, auth?: unknown) {\n    this.addToQueue(client, {\n      rank: options.rank,\n      teamId: options.teamId,\n      options,\n    });\n  }\n\n  addToQueue(client: QueueClient, queueData: QueueClientData) {\n    if (queueData.currentCycle === undefined) {\n      queueData.currentCycle = 0;\n    }\n    client.userData = queueData;\n\n    // FIXME: reassign groups upon joining [?] (without incrementing cycle count)\n    client.send(\"clients\", 1);\n  }\n\n  createMatchGroup() {\n    const group: QueueMatchGroup = { clients: [], averageRank: 0 };\n    this.groups.push(group);\n    return group;\n  }\n\n  reassignMatchGroups() {\n    // Re-set all groups\n    this.groups.length = 0;\n    this.highPriorityGroups.length = 0;\n\n    const sortedClients = (this.clients)\n      .filter((client) => {\n        // Filter out:\n        // - clients that are not in the queue\n        // - clients that are already in a \"ready\" group\n        return (\n          client.userData &&\n          client.userData.group?.ready !== true\n        );\n      })\n      .sort((a, b) => {\n        //\n        // Sort by rank ascending\n        //\n        return a.userData.rank - b.userData.rank;\n      });\n\n    //\n    // The room either distribute by teams or by clients\n    //\n    if (typeof(this.maxTeamSize) === \"number\") {\n      this.redistributeTeams(sortedClients);\n\n    } else {\n      this.redistributeClients(sortedClients);\n    }\n\n    this.evaluateHighPriorityGroups();\n    this.processGroupsReady();\n  }\n\n  redistributeTeams(sortedClients: Client<{ userData: QueueClientData }>[]) {\n    const teamsByID: { [teamId: string | symbol]: QueueMatchTeam } = {};\n\n    sortedClients.forEach((client) => {\n      const teamId = client.userData.teamId || DEFAULT_TEAM;\n\n      // Create a new team if it doesn't exist\n      if (!teamsByID[teamId]) {\n        teamsByID[teamId] = { teamId: teamId, clients: [], averageRank: 0, };\n      }\n\n      teamsByID[teamId].averageRank += client.userData.rank;\n      teamsByID[teamId].clients.push(client);\n    });\n\n    // Calculate average rank for each team\n    let teams = Object.values(teamsByID).map((team) => {\n      team.averageRank /= team.clients.length;\n      return team;\n    }).sort((a, b) => {\n      // Sort by average rank ascending\n      return a.averageRank - b.averageRank;\n    });\n\n    // Iterate over teams multiple times until all clients are assigned to a group\n    do {\n      let currentGroup: QueueMatchGroup = this.createMatchGroup();\n      teams = teams.filter((team) => {\n        // Remove clients from the team and add them to the current group\n        const totalRank = team.averageRank * team.clients.length;\n\n        // currentGroup.averageRank = (currentGroup.averageRank === undefined)\n        //   ? team.averageRank\n        //   : (currentGroup.averageRank + team.averageRank) / ;\n        currentGroup = this.redistributeClients(team.clients.splice(0, this.maxTeamSize), currentGroup, totalRank);\n\n        if (team.clients.length >= this.maxTeamSize) {\n          // team still has enough clients to form a group\n          return true;\n        }\n\n        // increment cycle count for all clients in the team\n        team.clients.forEach((client) => client.userData.currentCycle++);\n\n        return false;\n      });\n    } while (teams.length >= 2);\n  }\n\n  redistributeClients(\n    sortedClients: Client<{ userData: QueueClientData }>[],\n    currentGroup: QueueMatchGroup = this.createMatchGroup(),\n    totalRank: number = 0,\n  ) {\n    for (let i = 0, l = sortedClients.length; i < l; i++) {\n      const client = sortedClients[i];\n      const userData = client.userData;\n      const currentCycle = userData.currentCycle++;\n\n      if (currentGroup.averageRank > 0) {\n        if (\n          !this.compare(userData, currentGroup) &&\n          !userData.highPriority\n        ) {\n          currentGroup = this.createMatchGroup();\n          totalRank = 0;\n        }\n      }\n\n      userData.group = currentGroup;\n      currentGroup.clients.push(client);\n\n      totalRank += userData.rank;\n      currentGroup.averageRank = totalRank / currentGroup.clients.length;\n\n      // Enough players in the group, mark it as ready!\n      if (currentGroup.clients.length === this.maxPlayers) {\n        currentGroup.ready = true;\n        currentGroup = this.createMatchGroup();\n        totalRank = 0;\n        continue;\n      }\n\n      if (currentCycle >= this.maxWaitingCycles && this.allowIncompleteGroups) {\n        /**\n         * Match long-waiting clients with bots\n         */\n        if (this.highPriorityGroups.indexOf(currentGroup) === -1) {\n          this.highPriorityGroups.push(currentGroup);\n        }\n\n      } else if (\n        this.maxWaitingCyclesForPriority !== undefined &&\n        currentCycle >= this.maxWaitingCyclesForPriority\n      ) {\n        /**\n         * Force this client to join a group, even if rank is incompatible\n         */\n        userData.highPriority = true;\n      }\n    }\n\n    return currentGroup;\n  }\n\n  evaluateHighPriorityGroups() {\n    /**\n     * Evaluate groups with high priority clients\n     */\n    this.highPriorityGroups.forEach((group) => {\n      group.ready = group.clients.every((c) => {\n        // Give new clients another chance to join a group that is not \"high priority\"\n        return c.userData?.currentCycle > 1;\n        // return c.userData?.currentCycle >= this.maxWaitingCycles;\n      });\n    });\n  }\n\n  processGroupsReady() {\n    this.groups.forEach(async (group) => {\n      if (group.ready) {\n        group.confirmed = 0;\n\n        try {\n          /**\n           * Create room instance in the server.\n           */\n          const room = await this.onGroupReady.call(this, group);\n\n          /**\n           * Reserve a seat for each client in the group.\n           * (If one fails, force all clients to leave, re-queueing is up to the client-side logic)\n           */\n          await matchMaker.reserveMultipleSeatsFor(\n            room,\n            group.clients.map((client) => ({\n              sessionId: client.sessionId,\n              options: client.userData.options,\n              auth: client.auth,\n            })),\n          );\n\n          /**\n           * Send room data for new WebSocket connection!\n           */\n          group.clients.forEach((client, i) => {\n            client.send(\"seat\", matchMaker.buildSeatReservation(room, client.sessionId));\n          });\n\n        } catch (e: any) {\n          //\n          // If creating a room, or reserving a seat failed - fail all clients\n          // Whether the clients retry or not is up to the client-side logic\n          //\n          group.clients.forEach(client => client.leave(1011, e.message));\n        }\n\n      } else {\n        /**\n         * Notify clients within the group on how many players are in the queue\n         */\n        group.clients.forEach((client) => {\n          //\n          // avoid sending the same number of clients to the client if it hasn't changed\n          //\n          const queueClientCount = group.clients.length;\n          if (client.userData.lastQueueClientCount !== queueClientCount) {\n            client.userData.lastQueueClientCount = queueClientCount;\n            client.send(\"clients\", queueClientCount);\n          }\n        });\n      }\n    });\n  }\n\n}"],
+  "mappings": "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",
   "names": []
 }

package/build/rooms/QueueRoom.mjs

@@ -64,7 +64,7 @@ var QueueRoom = class extends Room {
       throw new ServerError(ErrorCode.APPLICATION_ERROR, "QueueRoom: 'matchRoomName' option is required.");
     }
     debugMatchMaking("QueueRoom#onCreate() maxPlayers: %d, maxWaitingCycles: %d, maxTeamSize: %d, allowIncompleteGroups: %d, roomNameToCreate: %s", this.maxPlayers, this.maxWaitingCycles, this.maxTeamSize, this.allowIncompleteGroups, this.matchRoomName);
-    this.setSimulationInterval(() => this.reassignMatchGroups(), this.cycleTickInterval);
+    this.setTimestep(() => this.reassignMatchGroups(), this.cycleTickInterval);
   }
   onJoin(client, options, auth) {
     this.addToQueue(client, {