@pylonsync/realtime 0.22.12 → 0.22.14

package/dist/connection.d.ts

@@ -124,7 +124,12 @@ export interface ShardClient<TSnapshot = unknown, TInput = unknown> {
      * acknowledge, or 0 when the connection is not open (the input is not
      * sent, and `onError` hears why).
      */
-    send: (input: TInput) => number;
+    /**
+     * `viewTick`: the tick (fractional) the client was drawing when the
+     * player acted, for a shard with lag compensation. `connectShardGame`
+     * sets it from the last `frame`.
+     */
+    send: (input: TInput, viewTick?: number) => number;
     close: () => void;
     readonly connected: boolean;
     /** The transport of the open (or last) connection, or null before one opened. */

package/dist/game.d.ts

@@ -65,8 +65,11 @@ export interface ShardGame<TInput = unknown> {
      * frame.
      */
     frame(now?: number): number;
-    /** Send an input; every predictor made by `predict` records it. Returns
-     *  its sequence number, or 0 when it was not sent. */
+    /**
+     * Send an input; every predictor made by `predict` records it. The input
+     * carries the tick the last `frame` drew, for a shard with lag
+     * compensation. Returns its sequence number, or 0 when it was not sent.
+     */
     send(input: TInput): number;
     /**
      * A predictor that records every input `send` sends, forgets inputs the

package/dist/interpolation.d.ts

@@ -72,12 +72,20 @@ export declare class EntityInterpolator {
     /** The newest tick the last `update` drew; a render tick never goes
      *  below it. */
     private floor;
+    private drawn;
     /** Lives that ended, oldest first, so `record` can drop them when
      *  `update` does not run (a hidden tab keeps receiving frames). */
     private ended;
     constructor(options?: InterpolationOptions);
     /** The newest tick recorded, or -1. */
     get latestTick(): number;
+    /**
+     * The tick the last `update` drew: its render tick, raised to what an
+     * earlier update drew and capped at the newest tick received, or -1 before
+     * the first update. This is the tick the player saw: the view tick for lag
+     * compensation.
+     */
+    get drawnTick(): number;
     /** Forget everything. The next `update` removes every entity. */
     clear(): void;
     /**

package/dist/wire.d.ts

@@ -87,7 +87,7 @@ export declare function decodeShardRejection(codec: number, payload: Uint8Array,
  * other codec (and a connection that has not seen a frame yet) gets JSON
  * text, which the server always accepts.
  */
-export declare function encodeShardInput(codec: number | null, input: unknown, clientSeq: number): string | Uint8Array;
+export declare function encodeShardInput(codec: number | null, input: unknown, clientSeq: number, viewTick?: number): string | Uint8Array;
 /** Acks one message may carry (the server refuses more). */
 export declare const MAX_ACKS_PER_MESSAGE = 512;
 /**

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.22.12",
+  "version": "0.22.14",
   "description": "Pylon realtime shard client pieces with no framework: the wire protocol, codecs, and the entity replication decoder and table.",
   "type": "module",
   "main": "./src/index.ts",

package/src/connection.ts

@@ -147,7 +147,12 @@ export interface ShardClient<TSnapshot = unknown, TInput = unknown> {
    * acknowledge, or 0 when the connection is not open (the input is not
    * sent, and `onError` hears why).
    */
-  send: (input: TInput) => number;
+  /**
+   * `viewTick`: the tick (fractional) the client was drawing when the
+   * player acted, for a shard with lag compensation. `connectShardGame`
+   * sets it from the last `frame`.
+   */
+  send: (input: TInput, viewTick?: number) => number;
   close: () => void;
   readonly connected: boolean;
   /** The transport of the open (or last) connection, or null before one opened. */
@@ -1041,13 +1046,13 @@ export function connectShard<TSnapshot = unknown, TInput = unknown>(
     onClose(fn) {
       closeHandlers.push(fn);
     },
-    send(input: TInput): number {
+    send(input: TInput, viewTick?: number): number {
       if (!link || !connected || !link.open) {
         dispatchError(new Error("Cannot send: shard connection is not open"));
         return 0;
       }
       clientSeq += 1;
-      link.send(encodeShardInput(codec, input, clientSeq));
+      link.send(encodeShardInput(codec, input, clientSeq, viewTick));
       sentAt.set(clientSeq, now());
       if (sentAt.size > MAX_TIMED) sentAt.delete(sentAt.keys().next().value as number);
       return clientSeq;

package/src/game.test.ts

@@ -100,7 +100,8 @@ test("a render loop draws entities between frames, and prediction follows acks",
   const s2 = game.send({ dx: 1 });
   const s3 = game.send({ dx: 1 });
   expect([s1, s2, s3]).toEqual([1, 2, 3]);
-  expect(JSON.parse(ws.sent[0])).toEqual({ input: { dx: 1 }, client_seq: 1 });
+  // Each input carries the tick the last frame drew, for lag compensation.
+  expect(JSON.parse(ws.sent[0])).toEqual({ input: { dx: 1 }, client_seq: 1, view_tick: renderTick });
   deliver(11, 2, { update: [{ id: 1, from: [0, 0, 0], pos: [1.5, 0, 0] }] });
   expect(predicted).toBeCloseTo(2.5);
   expect(game.ack).toBe(2);
@@ -135,3 +136,13 @@ test("a render loop draws entities between frames, and prediction follows acks",
   expect(game.left).toEqual([2]);
   game.close();
 });
+
+test("an input sent before the first frame carries no view tick", () => {
+  const game = connectShardGame<{ dx: number }>("zone-nv", { subscriberId: "p1", baseUrl: "h", now: () => 0 });
+  const ws = sockets[sockets.length - 1];
+  ws.open();
+  ws.deliver(replicationFrame(1, 0, { full: true, spawn: [{ id: 1, pos: [0, 0, 0] }] }));
+  expect(game.send({ dx: 1 })).toBe(1);
+  expect(JSON.parse(ws.sent[0])).toEqual({ input: { dx: 1 }, client_seq: 1 });
+  game.close();
+});

package/src/game.ts

@@ -77,8 +77,11 @@ export interface ShardGame<TInput = unknown> {
    * frame.
    */
   frame(now?: number): number;
-  /** Send an input; every predictor made by `predict` records it. Returns
-   *  its sequence number, or 0 when it was not sent. */
+  /**
+   * Send an input; every predictor made by `predict` records it. The input
+   * carries the tick the last `frame` drew, for a shard with lag
+   * compensation. Returns its sequence number, or 0 when it was not sent.
+   */
   send(input: TInput): number;
   /**
    * A predictor that records every input `send` sends, forgets inputs the
@@ -160,7 +163,8 @@ export function connectShardGame<TInput = unknown>(
       return renderTick;
     },
     send(input) {
-      const seq = connection.send(input);
+      const drawn = interpolator.drawnTick;
+      const seq = connection.send(input, drawn >= 0 ? drawn : undefined);
       for (const p of predictors) p.push(seq, input);
       return seq;
     },

package/src/interpolation.test.ts

@@ -21,6 +21,24 @@ function harness(options?: InterpolationOptions) {
 }
 
 describe("EntityInterpolator", () => {
+  test("drawnTick is the tick an update placed entities at, never going back", () => {
+    const h = harness();
+    expect(h.interp.drawnTick).toBe(-1);
+    h.frame(1, { full: true, spawn: [{ id: 1, pos: [0, 0, 0] }] });
+    h.frame(9, { update: [{ id: 1, from: [0, 0, 0], pos: [8, 0, 0] }] });
+    h.at(5.5);
+    expect(h.interp.drawnTick).toBe(5.5);
+    // An earlier render tick is raised to what was drawn.
+    h.at(3);
+    expect(h.interp.drawnTick).toBe(5.5);
+    // Frames stopped: past the newest tick received (9), the picture is
+    // tick 9's.
+    h.at(14);
+    expect(h.interp.drawnTick).toBe(9);
+    h.interp.clear();
+    expect(h.interp.drawnTick).toBe(-1);
+  });
+
   test("draws an entity between the samples around the render tick", () => {
     const h = harness();
     h.frame(1, { full: true, spawn: [{ id: 1, pos: [0, 0, 0] }] });

package/src/interpolation.ts

@@ -90,6 +90,7 @@ export class EntityInterpolator {
   /** The newest tick the last `update` drew; a render tick never goes
    *  below it. */
   private floor = -Infinity;
+  private drawn = -1;
   /** Lives that ended, oldest first, so `record` can drop them when
    *  `update` does not run (a hidden tab keeps receiving frames). */
   private ended: Array<{ id: number; life: Life }> = [];
@@ -105,12 +106,23 @@ export class EntityInterpolator {
     return this.lastTick;
   }
 
+  /**
+   * The tick the last `update` drew: its render tick, raised to what an
+   * earlier update drew and capped at the newest tick received, or -1 before
+   * the first update. This is the tick the player saw: the view tick for lag
+   * compensation.
+   */
+  get drawnTick(): number {
+    return this.drawn;
+  }
+
   /** Forget everything. The next `update` removes every entity. */
   clear(): void {
     this.lives.clear();
     this.ended = [];
     this.lastTick = -1;
     this.floor = -Infinity;
+    this.drawn = -1;
   }
 
   /**
@@ -167,6 +179,9 @@ export class EntityInterpolator {
     renderTick = Math.max(renderTick, this.floor);
     // What this update draws is at most the newest tick recorded.
     this.floor = Math.min(renderTick, this.lastTick);
+    // Past the newest tick received, entities hold at their last samples:
+    // the picture is that tick's.
+    this.drawn = this.floor;
     for (const [id, lives] of this.lives) {
       // Lives that ended by the render tick are over.
       while (lives.length > 0 && lives[0].despawnTick !== null && lives[0].despawnTick <= renderTick) {