emoemu 0.1.0

package/src/netplay/FrameBuffer/tests.ts

@@ -0,0 +1,286 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { FrameBuffer, createFrameBuffer } from '.';
+import { crc32 } from '../crc32';
+import { DEFAULT_FRAME_BUFFER_SIZE, MAX_INPUT_DEVICES } from '..';
+
+describe('FrameBuffer', () => {
+  let buffer: FrameBuffer;
+
+  beforeEach(() => {
+    buffer = createFrameBuffer(10); // Small buffer for testing
+  });
+
+  describe('initialization', () => {
+    it('should create buffer with specified capacity', () => {
+      expect(buffer.capacity).toBe(10);
+    });
+
+    it('should start empty', () => {
+      expect(buffer.size).toBe(0);
+      expect(buffer.newestFrame).toBe(-1);
+    });
+
+    it('should use default capacity if not specified', () => {
+      const defaultBuffer = createFrameBuffer();
+      expect(defaultBuffer.capacity).toBe(DEFAULT_FRAME_BUFFER_SIZE);
+    });
+  });
+
+  describe('advance', () => {
+    it('should advance to first frame', () => {
+      const frame = buffer.advance();
+      expect(frame.frameNumber).toBe(0);
+      expect(buffer.newestFrame).toBe(0);
+      expect(buffer.size).toBe(1);
+    });
+
+    it('should advance multiple frames', () => {
+      for (let i = 0; i < 5; i++) {
+        buffer.advance();
+      }
+      expect(buffer.newestFrame).toBe(4);
+      expect(buffer.oldestFrame).toBe(0);
+      expect(buffer.size).toBe(5);
+    });
+
+    it('should wrap around when exceeding capacity', () => {
+      for (let i = 0; i < 15; i++) {
+        buffer.advance();
+      }
+      expect(buffer.newestFrame).toBe(14);
+      expect(buffer.oldestFrame).toBe(5);
+      expect(buffer.size).toBe(10);
+    });
+
+    it('should reset frame state on reuse', () => {
+      const frame1 = buffer.advance();
+      frame1.serializedState = Buffer.from([1, 2, 3]);
+      frame1.crc = 12345;
+
+      // Advance past capacity to reuse slot
+      for (let i = 0; i < 10; i++) {
+        buffer.advance();
+      }
+
+      // Frame 10 should be in slot 0, which was frame 0
+      const frame10 = buffer.get(10);
+      expect(frame10).not.toBeNull();
+      expect(frame10!.serializedState).toBeNull();
+      expect(frame10!.crc).toBeNull();
+    });
+  });
+
+  describe('get', () => {
+    it('should return null for frame not in buffer', () => {
+      expect(buffer.get(0)).toBeNull();
+      expect(buffer.get(100)).toBeNull();
+    });
+
+    it('should return frame by number', () => {
+      buffer.advance();
+      buffer.advance();
+      const frame = buffer.get(1);
+      expect(frame).not.toBeNull();
+      expect(frame!.frameNumber).toBe(1);
+    });
+
+    it('should return null for expired frame', () => {
+      for (let i = 0; i < 15; i++) {
+        buffer.advance();
+      }
+      expect(buffer.get(0)).toBeNull();
+      expect(buffer.get(4)).toBeNull();
+      expect(buffer.get(5)).not.toBeNull();
+    });
+  });
+
+  describe('getCurrent', () => {
+    it('should return null when empty', () => {
+      expect(buffer.getCurrent()).toBeNull();
+    });
+
+    it('should return newest frame', () => {
+      buffer.advance();
+      buffer.advance();
+      buffer.advance();
+      const current = buffer.getCurrent();
+      expect(current).not.toBeNull();
+      expect(current!.frameNumber).toBe(2);
+    });
+  });
+
+  describe('hasFrame', () => {
+    it('should return false for empty buffer', () => {
+      expect(buffer.hasFrame(0)).toBe(false);
+    });
+
+    it('should return true for frames in range', () => {
+      for (let i = 0; i < 5; i++) {
+        buffer.advance();
+      }
+      expect(buffer.hasFrame(0)).toBe(true);
+      expect(buffer.hasFrame(4)).toBe(true);
+    });
+
+    it('should return false for frames outside range', () => {
+      for (let i = 0; i < 5; i++) {
+        buffer.advance();
+      }
+      expect(buffer.hasFrame(5)).toBe(false);
+      expect(buffer.hasFrame(-1)).toBe(false);
+    });
+  });
+
+  describe('state management', () => {
+    it('should set and get state', () => {
+      buffer.advance();
+      const state = Buffer.from([1, 2, 3, 4, 5]);
+      expect(buffer.setState(0, state)).toBe(true);
+      expect(buffer.getState(0)).toEqual(state);
+    });
+
+    it('should compute CRC when setting state', () => {
+      buffer.advance();
+      const state = Buffer.from('test state');
+      buffer.setState(0, state);
+      const crc = buffer.getCrc(0);
+      expect(crc).not.toBeNull();
+      expect(crc).toBe(crc32(state));
+    });
+
+    it('should return false when setting state for invalid frame', () => {
+      expect(buffer.setState(0, Buffer.alloc(0))).toBe(false);
+    });
+  });
+
+  describe('local input', () => {
+    it('should set local input for current frame', () => {
+      buffer.advance();
+      const input = [0xff, 0x1234, 0x5678];
+      expect(buffer.setLocalInput(input)).toBe(true);
+
+      const frame = buffer.getCurrent();
+      expect(frame!.localInput[0]).toBe(0xff);
+      expect(frame!.localInput[1]).toBe(0x1234);
+      expect(frame!.localInput[2]).toBe(0x5678);
+    });
+
+    it('should set input for specific device', () => {
+      buffer.advance();
+      expect(buffer.setLocalInputForDevice(1, 0xabcd, 0x1111, 0x2222)).toBe(true);
+
+      const frame = buffer.getCurrent();
+      // Device 1 starts at index 3 (device 0 uses indices 0-2)
+      expect(frame!.localInput[3]).toBe(0xabcd);
+      expect(frame!.localInput[4]).toBe(0x1111);
+      expect(frame!.localInput[5]).toBe(0x2222);
+    });
+
+    it('should reject device index out of range', () => {
+      buffer.advance();
+      expect(buffer.setLocalInputForDevice(MAX_INPUT_DEVICES, 0xff)).toBe(false);
+    });
+  });
+
+  describe('remote input', () => {
+    it('should set and get remote input', () => {
+      buffer.advance();
+      const input = [0xaa, 0xbb, 0xcc];
+      buffer.setRemoteInput(0, 1, input, true);
+
+      expect(buffer.getRemoteInput(0, 1)).toEqual(input);
+      expect(buffer.isRemoteInputReal(0, 1)).toBe(true);
+    });
+
+    it('should track simulated vs real input', () => {
+      buffer.advance();
+      buffer.setRemoteInput(0, 1, [1, 2, 3], false);
+      expect(buffer.isRemoteInputReal(0, 1)).toBe(false);
+
+      buffer.setRemoteInput(0, 1, [4, 5, 6], true);
+      expect(buffer.isRemoteInputReal(0, 1)).toBe(true);
+    });
+
+    it('should return null for unknown client', () => {
+      buffer.advance();
+      expect(buffer.getRemoteInput(0, 99)).toBeNull();
+    });
+  });
+
+  describe('sync frame finding', () => {
+    it('should find sync frame with all real input', () => {
+      for (let i = 0; i < 5; i++) {
+        buffer.advance();
+        buffer.setRemoteInput(i, 1, [i], true);
+        buffer.setRemoteInput(i, 2, [i], true);
+      }
+
+      const syncFrame = buffer.findSyncFrame([1, 2]);
+      expect(syncFrame).toBe(4);
+    });
+
+    it('should find last frame before simulated input', () => {
+      for (let i = 0; i < 5; i++) {
+        buffer.advance();
+        buffer.setRemoteInput(i, 1, [i], true);
+        buffer.setRemoteInput(i, 2, [i], i < 3); // Only real for frames 0-2
+      }
+
+      const syncFrame = buffer.findSyncFrame([1, 2]);
+      expect(syncFrame).toBe(2);
+    });
+
+    it('should return null if no synced frames', () => {
+      for (let i = 0; i < 3; i++) {
+        buffer.advance();
+        buffer.setRemoteInput(i, 1, [i], false);
+      }
+
+      const syncFrame = buffer.findSyncFrame([1]);
+      expect(syncFrame).toBeNull();
+    });
+  });
+
+  describe('unread frame finding', () => {
+    it('should find first frame with simulated input', () => {
+      for (let i = 0; i < 5; i++) {
+        buffer.advance();
+        buffer.setRemoteInput(i, 1, [i], i < 3);
+      }
+
+      const unreadFrame = buffer.findUnreadFrame([1]);
+      expect(unreadFrame).toBe(3);
+    });
+
+    it('should return null if all frames have real input', () => {
+      for (let i = 0; i < 5; i++) {
+        buffer.advance();
+        buffer.setRemoteInput(i, 1, [i], true);
+      }
+
+      const unreadFrame = buffer.findUnreadFrame([1]);
+      expect(unreadFrame).toBeNull();
+    });
+  });
+
+  describe('initializeAt', () => {
+    it('should initialize buffer at specific frame', () => {
+      const frame = buffer.initializeAt(1000);
+      expect(frame.frameNumber).toBe(1000);
+      expect(buffer.newestFrame).toBe(1000);
+      expect(buffer.oldestFrame).toBe(1000);
+    });
+  });
+
+  describe('clear', () => {
+    it('should reset buffer to empty state', () => {
+      for (let i = 0; i < 5; i++) {
+        buffer.advance();
+      }
+
+      buffer.clear();
+      expect(buffer.size).toBe(0);
+      expect(buffer.newestFrame).toBe(-1);
+    });
+  });
+});

package/src/netplay/InputBuffer/consts.ts

@@ -0,0 +1,7 @@
+/** Number of input values per device (joypad, analogLeft, analogRight) */
+export const INPUTS_PER_DEVICE = 3;
+
+/** Index offsets for input values */
+export const INPUT_JOYPAD = 0;
+export const INPUT_ANALOG_LEFT = 1;
+export const INPUT_ANALOG_RIGHT = 2;

package/src/netplay/InputBuffer/index.ts

@@ -0,0 +1,347 @@
+/**
+ * Input Buffer for Netplay
+ *
+ * Manages input state per client, including:
+ * - Input delay queue for local input
+ * - Input prediction for remote clients
+ * - Frame-accurate input tracking
+ */
+
+import { times } from 'remeda';
+import { MAX_INPUT_DEVICES, MAX_INPUT_DELAY_FRAMES } from '..';
+
+export * from './consts';
+import { INPUTS_PER_DEVICE, INPUT_JOYPAD, INPUT_ANALOG_LEFT, INPUT_ANALOG_RIGHT } from './consts';
+
+/**
+ * Create a zero-filled number array of the given size.
+ */
+const createZeroArray = (size: number): number[] => times(size, () => 0);
+
+/**
+ * Per-client input state tracking.
+ */
+interface ClientInputState {
+  /** Client ID */
+  clientId: number;
+
+  /** Last known input values per device */
+  lastInput: number[];
+
+  /** Last frame we received real input for */
+  lastRealInputFrame: number;
+
+  /** Is this client local? */
+  isLocal: boolean;
+}
+
+/**
+ * Delayed input entry for local input delay queue.
+ */
+interface DelayedInput {
+  /** Frame number this input is for */
+  frameNumber: number;
+
+  /** Input values */
+  input: number[];
+}
+
+/**
+ * InputBuffer manages input state for all clients in a netplay session.
+ */
+export class InputBuffer {
+  private readonly clients: Map<number, ClientInputState> = new Map();
+  private readonly delayQueue: DelayedInput[] = [];
+  private _inputDelayFrames: number = 0;
+  private _localClientId: number = 0;
+
+  /** Current input delay in frames */
+  get inputDelayFrames(): number {
+    return this._inputDelayFrames;
+  }
+
+  /** Local client ID */
+  get localClientId(): number {
+    return this._localClientId;
+  }
+
+  /**
+   * Initialize the input buffer with local client ID and delay.
+   */
+  initialize(localClientId: number, inputDelayFrames: number = 0): void {
+    this._localClientId = localClientId;
+    this._inputDelayFrames = Math.min(inputDelayFrames, MAX_INPUT_DELAY_FRAMES);
+    this.clients.clear();
+    this.delayQueue.length = 0;
+
+    // Register local client
+    this.registerClient(localClientId, true);
+  }
+
+  /**
+   * Update the local client ID.
+   * Called when MODE command assigns our client number.
+   */
+  updateLocalClientId(newClientId: number): void {
+    const oldId = this._localClientId;
+    if (oldId === newClientId) {
+      return;
+    }
+
+    // Move client state from old ID to new ID
+    const oldState = this.clients.get(oldId);
+    if (oldState) {
+      this.clients.delete(oldId);
+      oldState.clientId = newClientId;
+      this.clients.set(newClientId, oldState);
+    }
+
+    this._localClientId = newClientId;
+  }
+
+  /**
+   * Register a client for input tracking.
+   */
+  registerClient(clientId: number, isLocal: boolean = false): void {
+    if (this.clients.has(clientId)) {
+      return;
+    }
+
+    this.clients.set(clientId, {
+      clientId,
+      lastInput: createZeroArray(MAX_INPUT_DEVICES * INPUTS_PER_DEVICE),
+      lastRealInputFrame: -1,
+      isLocal,
+    });
+  }
+
+  /**
+   * Unregister a client.
+   */
+  unregisterClient(clientId: number): void {
+    this.clients.delete(clientId);
+  }
+
+  /**
+   * Get all registered client IDs.
+   */
+  getClientIds(): number[] {
+    return Array.from(this.clients.keys());
+  }
+
+  /**
+   * Get remote client IDs (excluding local).
+   */
+  getRemoteClientIds(): number[] {
+    return Array.from(this.clients.entries())
+      .filter(([_, state]) => !state.isLocal)
+      .map(([id]) => id);
+  }
+
+  /**
+   * Queue local input with delay.
+   * Returns the frame number this input will be applied to.
+   */
+  queueLocalInput(currentFrame: number, input: number[]): number {
+    const targetFrame = currentFrame + this._inputDelayFrames;
+
+    this.delayQueue.push({
+      frameNumber: targetFrame,
+      input: [...input],
+    });
+
+    // Update last known input for local client
+    const localState = this.clients.get(this._localClientId);
+    if (localState) {
+      const len = Math.min(input.length, localState.lastInput.length);
+      for (let i = 0; i < len; i++) {
+        localState.lastInput[i] = input[i];
+      }
+    }
+
+    return targetFrame;
+  }
+
+  /**
+   * Get local input for a specific frame from the delay queue.
+   * Returns null if not yet available.
+   */
+  getDelayedLocalInput(frameNumber: number): number[] | null {
+    const entry = this.delayQueue.find((e) => e.frameNumber === frameNumber);
+    return entry?.input ?? null;
+  }
+
+  /**
+   * Remove processed entries from the delay queue.
+   */
+  pruneDelayQueue(upToFrame: number): void {
+    while (this.delayQueue.length > 0 && this.delayQueue[0].frameNumber <= upToFrame) {
+      this.delayQueue.shift();
+    }
+  }
+
+  /**
+   * Record received input from a remote client.
+   */
+  recordRemoteInput(clientId: number, frameNumber: number, input: number[]): void {
+    let state = this.clients.get(clientId);
+    if (!state) {
+      // Auto-register unknown client
+      this.registerClient(clientId, false);
+      state = this.clients.get(clientId)!;
+    }
+
+    // Update last known input
+    const len = Math.min(input.length, state.lastInput.length);
+    for (let i = 0; i < len; i++) {
+      state.lastInput[i] = input[i];
+    }
+
+    // Update last real input frame
+    if (frameNumber > state.lastRealInputFrame) {
+      state.lastRealInputFrame = frameNumber;
+    }
+  }
+
+  /**
+   * Get input for a client at a specific frame.
+   * If real input isn't available, returns predicted input.
+   */
+  getInputForClient(
+    clientId: number,
+    _frameNumber: number,
+    realInputAvailable: boolean
+  ): { input: number[]; isReal: boolean } {
+    const state = this.clients.get(clientId);
+    if (!state) {
+      // Unknown client - return zeros
+      return {
+        input: createZeroArray(MAX_INPUT_DEVICES * INPUTS_PER_DEVICE),
+        isReal: false,
+      };
+    }
+
+    if (realInputAvailable) {
+      return {
+        input: [...state.lastInput],
+        isReal: true,
+      };
+    }
+
+    // Predict: repeat last known input
+    return {
+      input: this.predictInput(state),
+      isReal: false,
+    };
+  }
+
+  /**
+   * Predict input for a client based on last known state.
+   * Simple strategy: repeat last known input.
+   */
+  private predictInput(state: ClientInputState): number[] {
+    // Simple prediction: repeat last known input
+    return [...state.lastInput];
+  }
+
+  /**
+   * Get the last frame we received real input for a client.
+   */
+  getLastRealInputFrame(clientId: number): number {
+    return this.clients.get(clientId)?.lastRealInputFrame ?? -1;
+  }
+
+  /**
+   * Set input for a specific device.
+   * Convenience method for setting joypad + analog values.
+   */
+  setDeviceInput(
+    clientId: number,
+    deviceIndex: number,
+    joypad: number,
+    analogLeft: number = 0,
+    analogRight: number = 0
+  ): void {
+    const state = this.clients.get(clientId);
+    if (!state || deviceIndex >= MAX_INPUT_DEVICES) {
+      return;
+    }
+
+    const base = deviceIndex * INPUTS_PER_DEVICE;
+    state.lastInput[base + INPUT_JOYPAD] = joypad;
+    state.lastInput[base + INPUT_ANALOG_LEFT] = analogLeft;
+    state.lastInput[base + INPUT_ANALOG_RIGHT] = analogRight;
+  }
+
+  /**
+   * Get input for a specific device.
+   */
+  getDeviceInput(
+    clientId: number,
+    deviceIndex: number
+  ): { joypad: number; analogLeft: number; analogRight: number } | null {
+    const state = this.clients.get(clientId);
+    if (!state || deviceIndex >= MAX_INPUT_DEVICES) {
+      return null;
+    }
+
+    const base = deviceIndex * INPUTS_PER_DEVICE;
+    return {
+      joypad: state.lastInput[base + INPUT_JOYPAD],
+      analogLeft: state.lastInput[base + INPUT_ANALOG_LEFT],
+      analogRight: state.lastInput[base + INPUT_ANALOG_RIGHT],
+    };
+  }
+
+  /**
+   * Merge input from multiple clients into a single input array.
+   * Each client controls specific device slots.
+   */
+  mergeInputs(
+    clientDeviceMap: Map<number, number[]>,
+    frameNumber: number,
+    realInputMap: Map<number, boolean>
+  ): { merged: number[]; allReal: boolean } {
+    const merged = createZeroArray(MAX_INPUT_DEVICES * INPUTS_PER_DEVICE);
+    let allReal = true;
+
+    for (const [clientId, deviceIndices] of clientDeviceMap) {
+      const isReal = realInputMap.get(clientId) ?? false;
+      const { input } = this.getInputForClient(clientId, frameNumber, isReal);
+
+      if (!isReal) {
+        allReal = false;
+      }
+
+      for (const deviceIndex of deviceIndices) {
+        if (deviceIndex >= MAX_INPUT_DEVICES) {
+          continue;
+        }
+
+        const srcBase = 0; // Assuming client's first device maps to their assigned slot
+        const dstBase = deviceIndex * INPUTS_PER_DEVICE;
+
+        merged[dstBase + INPUT_JOYPAD] = input[srcBase + INPUT_JOYPAD];
+        merged[dstBase + INPUT_ANALOG_LEFT] = input[srcBase + INPUT_ANALOG_LEFT];
+        merged[dstBase + INPUT_ANALOG_RIGHT] = input[srcBase + INPUT_ANALOG_RIGHT];
+      }
+    }
+
+    return { merged, allReal };
+  }
+
+  /**
+   * Clear all client state and queues.
+   */
+  clear(): void {
+    this.clients.clear();
+    this.delayQueue.length = 0;
+  }
+}
+
+/**
+ * Create a new input buffer.
+ */
+export const createInputBuffer = (): InputBuffer => {
+  return new InputBuffer();
+};