@downdraft/engine 0.0.0 → 0.1.0

package/libraries/networking/src/replication.ts

@@ -0,0 +1,327 @@
+import { RPCManager } from "./rpc";
+import type { NetMessage, NetTransport } from "./transport";
+
+export type ReplicationMode = "authoritative" | "client-prediction" | "interpolated";
+
+export interface ReplicatedField {
+  name: string;
+  type: "float32" | "float64" | "uint8" | "uint16" | "uint32" | "int8" | "int16" | "int32" | "boolean";
+  precision?: number;
+  interpolate?: boolean;
+}
+
+export interface ReplicatedComponent {
+  componentId: number;
+  fields: ReplicatedField[];
+  mode: ReplicationMode;
+}
+
+export interface ReplicationConfig {
+  tickRate: number;
+  maxEntitiesPerPacket: number;
+  components: Map<number, ReplicatedComponent>;
+}
+
+export interface ReplicationSnapshot {
+  tick: number;
+  entities: Array<{
+    entityId: number;
+    components: Array<{
+      componentId: number;
+      data: Uint8Array;
+    }>;
+  }>;
+}
+
+export class ReplicationManager {
+  private transport: NetTransport;
+  private config: ReplicationConfig;
+  private snapshots: Map<number, ReplicationSnapshot> = new Map();
+  private static readonly MAX_SNAPSHOTS = 1024;
+  private lastTick = 0;
+  private tickAccumulator = 0;
+  private isServer: boolean;
+  private entityComponents: Map<number, Map<number, Record<string, unknown>>> = new Map();
+  rpc: RPCManager;
+
+  constructor(transport: NetTransport, isServer: boolean, config?: Partial<ReplicationConfig>) {
+    this.transport = transport;
+    this.isServer = isServer;
+    this.config = {
+      tickRate: config?.tickRate ?? 20,
+      maxEntitiesPerPacket: config?.maxEntitiesPerPacket ?? 64,
+      components: config?.components ?? new Map(),
+    };
+
+    this.rpc = new RPCManager(transport, isServer);
+    this.transport.onMessage((msg) => this.handleMessage(msg));
+  }
+
+  registerComponent(componentId: number, fields: ReplicatedField[], mode: ReplicationMode = "authoritative"): void {
+    this.config.components.set(componentId, { componentId, fields, mode });
+  }
+
+  trackEntity(entityId: number): void {
+    this.entityComponents.set(entityId, new Map());
+  }
+
+  untrackEntity(entityId: number): void {
+    this.entityComponents.delete(entityId);
+  }
+
+  updateEntityComponent(entityId: number, componentId: number, data: Record<string, unknown>): void {
+    let entityMap = this.entityComponents.get(entityId);
+    if (!entityMap) {
+      entityMap = new Map();
+      this.entityComponents.set(entityId, entityMap);
+    }
+    entityMap.set(componentId, data);
+  }
+
+  update(dt: number): void {
+    if (!this.isServer) return;
+
+    this.tickAccumulator += dt;
+    const tickInterval = 1 / this.config.tickRate;
+
+    if (this.tickAccumulator >= tickInterval) {
+      this.tickAccumulator -= tickInterval;
+      this.lastTick++;
+      this.sendSnapshot();
+    }
+  }
+
+  private sendSnapshot(): void {
+    const entities: ReplicationSnapshot["entities"] = [];
+    let count = 0;
+
+    for (const [entityId, components] of this.entityComponents.entries()) {
+      if (count >= this.config.maxEntitiesPerPacket) break;
+
+      const componentData: Array<{ componentId: number; data: Uint8Array }> = [];
+      for (const [componentId, data] of components.entries()) {
+        const replComp = this.config.components.get(componentId);
+        if (!replComp) continue;
+        const serialized = this.serializeComponent(data, replComp.fields);
+        componentData.push({ componentId, data: serialized });
+      }
+
+      if (componentData.length > 0) {
+        entities.push({ entityId, components: componentData });
+        count++;
+      }
+    }
+
+    if (entities.length === 0) return;
+
+    const snapshot: ReplicationSnapshot = {
+      tick: this.lastTick,
+      entities,
+    };
+
+    const data = this.serializeSnapshot(snapshot);
+    this.transport.send({
+      type: 1, // SNAPSHOT
+      data,
+      reliable: false,
+      ordered: false,
+      channel: 0,
+    });
+  }
+
+  private handleMessage(msg: NetMessage): void {
+    if (msg.type === 1) {
+      // SNAPSHOT
+      if (this.isServer) return;
+      const snapshot = this.deserializeSnapshot(msg.data);
+      // LRU eviction — delete oldest entry (first key) when at capacity.
+      if (this.snapshots.size >= ReplicationManager.MAX_SNAPSHOTS) {
+        const oldestKey = this.snapshots.keys().next().value;
+        if (oldestKey !== undefined) this.snapshots.delete(oldestKey);
+      }
+      this.snapshots.set(snapshot.tick, snapshot);
+      this.applySnapshot(snapshot);
+    }
+    // RPC messages (type 2) are handled by RPCManager directly
+  }
+
+  private applySnapshot(snapshot: ReplicationSnapshot): void {
+    snapshot.entities.forEach((entity) => {
+      let entityMap = this.entityComponents.get(entity.entityId);
+      if (!entityMap) {
+        entityMap = new Map();
+        this.entityComponents.set(entity.entityId, entityMap);
+      }
+      for (let _i = 0, _it = entity.components, _n = _it.length; _i < _n; _i++) { const comp = _it[_i];
+        const replComp = this.config.components.get(comp.componentId);
+        if (!replComp) continue;
+        const data = this.deserializeComponent(comp.data, replComp.fields);
+        entityMap.set(comp.componentId, data);
+      }
+    });
+  }
+
+  getEntityData(entityId: number, componentId: number): Record<string, unknown> | undefined {
+    return this.entityComponents.get(entityId)?.get(componentId);
+  }
+
+  private serializeComponent(data: Record<string, unknown>, fields: ReplicatedField[]): Uint8Array {
+    const buffers: Uint8Array[] = [];
+    for (let _i = 0, _it = fields, _n = _it.length; _i < _n; _i++) { const field = _it[_i];
+      const value = data[field.name];
+      if (value === undefined) continue;
+      const buf = this.serializeField(value, field.type, field.precision);
+      buffers.push(buf);
+    }
+    const total = buffers.reduce((sum, b) => sum + b.length, 0);
+    const result = new Uint8Array(total);
+    let offset = 0;
+    buffers.forEach((buf) => {
+      result.set(buf, offset);
+      offset += buf.length;
+    });
+    return result;
+  }
+
+  private deserializeComponent(data: Uint8Array, fields: ReplicatedField[]): Record<string, unknown> {
+    const result: Record<string, unknown> = {};
+    let offset = 0;
+    fields.forEach((field) => {
+      const { value, size } = this.deserializeField(data, offset, field.type);
+      result[field.name] = value;
+      offset += size;
+    });
+    return result;
+  }
+
+  private serializeField(value: unknown, type: ReplicatedField["type"], precision?: number): Uint8Array {
+    switch (type) {
+      case "float32": {
+        const buf = new ArrayBuffer(4);
+        new DataView(buf).setFloat32(0, value as number);
+        return new Uint8Array(buf);
+      }
+      case "float64": {
+        const buf = new ArrayBuffer(8);
+        new DataView(buf).setFloat64(0, value as number);
+        return new Uint8Array(buf);
+      }
+      case "uint8": return new Uint8Array([value as number]);
+      case "uint16": {
+        const buf = new ArrayBuffer(2);
+        new DataView(buf).setUint16(0, value as number);
+        return new Uint8Array(buf);
+      }
+      case "uint32": {
+        const buf = new ArrayBuffer(4);
+        new DataView(buf).setUint32(0, value as number);
+        return new Uint8Array(buf);
+      }
+      case "int8": {
+        const buf = new ArrayBuffer(1);
+        new DataView(buf).setInt8(0, value as number);
+        return new Uint8Array(buf);
+      }
+      case "int16": {
+        const buf = new ArrayBuffer(2);
+        new DataView(buf).setInt16(0, value as number);
+        return new Uint8Array(buf);
+      }
+      case "int32": {
+        const buf = new ArrayBuffer(4);
+        new DataView(buf).setInt32(0, value as number);
+        return new Uint8Array(buf);
+      }
+      case "boolean": return new Uint8Array([value ? 1 : 0]);
+      default: return new Uint8Array(0);
+    }
+  }
+
+  private deserializeField(data: Uint8Array, offset: number, type: ReplicatedField["type"]): { value: unknown; size: number } {
+    const dv = new DataView(data.buffer, data.byteOffset + offset);
+    switch (type) {
+      case "float32": return { value: dv.getFloat32(0), size: 4 };
+      case "float64": return { value: dv.getFloat64(0), size: 8 };
+      case "uint8": return { value: data[offset], size: 1 };
+      case "uint16": return { value: dv.getUint16(0), size: 2 };
+      case "uint32": return { value: dv.getUint32(0), size: 4 };
+      case "int8": return { value: dv.getInt8(0), size: 1 };
+      case "int16": return { value: dv.getInt16(0), size: 2 };
+      case "int32": return { value: dv.getInt32(0), size: 4 };
+      case "boolean": return { value: data[offset] !== 0, size: 1 };
+      default: return { value: null, size: 0 };
+    }
+  }
+
+  private serializeSnapshot(snapshot: ReplicationSnapshot): Uint8Array {
+    const parts: Uint8Array[] = [];
+    const tickBuf = new ArrayBuffer(4);
+    new DataView(tickBuf).setUint32(0, snapshot.tick);
+    parts.push(new Uint8Array(tickBuf));
+
+    const countBuf = new ArrayBuffer(2);
+    new DataView(countBuf).setUint16(0, snapshot.entities.length);
+    parts.push(new Uint8Array(countBuf));
+
+    snapshot.entities.forEach((entity) => {
+      const idBuf = new ArrayBuffer(4);
+      new DataView(idBuf).setUint32(0, entity.entityId);
+      parts.push(new Uint8Array(idBuf));
+
+      const compCountBuf = new ArrayBuffer(2);
+      new DataView(compCountBuf).setUint16(0, entity.components.length);
+      parts.push(new Uint8Array(compCountBuf));
+
+      entity.components.forEach((comp) => {
+        const compIdBuf = new ArrayBuffer(4);
+        new DataView(compIdBuf).setUint32(0, comp.componentId);
+        parts.push(new Uint8Array(compIdBuf));
+
+        const lenBuf = new ArrayBuffer(2);
+        new DataView(lenBuf).setUint16(0, comp.data.length);
+        parts.push(new Uint8Array(lenBuf));
+
+        parts.push(comp.data);
+      });
+    });
+
+    const total = parts.reduce((sum, p) => sum + p.length, 0);
+    const result = new Uint8Array(total);
+    let offset = 0;
+    parts.forEach((part) => {
+      result.set(part, offset);
+      offset += part.length;
+    });
+    return result;
+  }
+
+  private deserializeSnapshot(data: Uint8Array): ReplicationSnapshot {
+    const dv = new DataView(data.buffer, data.byteOffset);
+    let offset = 0;
+    const tick = dv.getUint32(offset); offset += 4;
+    const entityCount = dv.getUint16(offset); offset += 2;
+
+    const entities: ReplicationSnapshot["entities"] = [];
+    for (let i = 0; i < entityCount; i++) {
+      const entityId = dv.getUint32(offset); offset += 4;
+      const compCount = dv.getUint16(offset); offset += 2;
+
+      const components: Array<{ componentId: number; data: Uint8Array }> = [];
+      for (let j = 0; j < compCount; j++) {
+        const componentId = dv.getUint32(offset); offset += 4;
+        const len = dv.getUint16(offset); offset += 2;
+        const compData = data.slice(offset, offset + len);
+        offset += len;
+        components.push({ componentId, data: compData });
+      }
+      entities.push({ entityId, components });
+    }
+
+    return { tick, entities };
+  }
+
+  getTickRate(): number { return this.config.tickRate; }
+  hasComponent(componentId: number): boolean { return this.config.components.has(componentId); }
+  getRTT(): number { return this.transport.getRTT(); }
+  getPacketLoss(): number { return this.transport.getPacketLoss(); }
+}

package/libraries/networking/src/rpc.ts

@@ -0,0 +1,188 @@
+import type { NetMessage, NetTransport } from "./transport";
+
+export type RPCHandler = (args: Uint8Array) => Uint8Array | null;
+
+export interface RPCDefinition {
+  id: number;
+  name: string;
+  reliable: boolean;
+}
+
+export class RPCManager {
+  private transport: NetTransport;
+  private handlers: Map<number, RPCHandler> = new Map();
+  private definitions: Map<string, RPCDefinition> = new Map();
+  private nextId = 1;
+  private isServer: boolean;
+  private authToken?: string;
+  private authenticated = false;
+  private callTimestamps: Map<string, number[]> = new Map();
+  private static readonly RATE_LIMIT_MAX_CALLS = 100;
+  private static readonly RATE_LIMIT_WINDOW_MS = 1000;
+
+  constructor(transport: NetTransport, isServer: boolean, authToken?: string) {
+    this.transport = transport;
+    this.isServer = isServer;
+    this.authToken = authToken;
+    if (!authToken) this.authenticated = true;
+    this.transport.onMessage((msg) => {
+      if (msg.type === 2) {
+        this.handleMessage(msg);
+      }
+    });
+  }
+
+  setAuthToken(token: string): void {
+    this.authToken = token;
+    this.authenticated = false;
+  }
+
+  register(name: string, handler: RPCHandler, reliable: boolean = true): number {
+    const id = this.nextId++;
+    const def: RPCDefinition = { id, name, reliable };
+    this.definitions.set(name, def);
+    this.handlers.set(id, handler);
+    return id;
+  }
+
+  unregister(name: string): void {
+    const def = this.definitions.get(name);
+    if (def) {
+      this.handlers.delete(def.id);
+      this.definitions.delete(name);
+    }
+  }
+
+  call(name: string, args: Uint8Array): void {
+    const def = this.definitions.get(name);
+    if (def) {
+      const buf = new Uint8Array(4 + args.length);
+      const dv = new DataView(buf.buffer);
+      dv.setUint32(0, def.id);
+      buf.set(args, 4);
+      this.transport.send({
+        type: 2,
+        data: buf,
+        reliable: def.reliable,
+        ordered: true,
+        channel: 1,
+      });
+    } else {
+      const nameBytes = new TextEncoder().encode(name);
+      const buf = new Uint8Array(4 + 2 + nameBytes.length + args.length);
+      const dv = new DataView(buf.buffer);
+      dv.setUint32(0, 0);
+      dv.setUint16(4, nameBytes.length);
+      buf.set(nameBytes, 6);
+      buf.set(args, 6 + nameBytes.length);
+      this.transport.send({
+        type: 2,
+        data: buf,
+        reliable: true,
+        ordered: true,
+        channel: 1,
+      });
+    }
+  }
+
+  callById(rpcId: number, args: Uint8Array, reliable: boolean = true): void {
+    const buf = new Uint8Array(4 + args.length);
+    const dv = new DataView(buf.buffer);
+    dv.setUint32(0, rpcId);
+    buf.set(args, 4);
+    this.transport.send({
+      type: 2,
+      data: buf,
+      reliable,
+      ordered: true,
+      channel: 1,
+    });
+  }
+
+  private handleMessage(msg: NetMessage): void {
+    if (msg.data.length < 4) return;
+
+    // Optional authentication: the first message from a peer must match the token.
+    if (this.authToken && !this.authenticated) {
+      const tokenText = new TextDecoder().decode(msg.data);
+      if (tokenText === this.authToken) {
+        this.authenticated = true;
+        return;
+      }
+      // reject the connection on auth failure
+      this.transport.disconnect();
+      return;
+    }
+
+    const dv = new DataView(msg.data.buffer, msg.data.byteOffset);
+    const rpcId = dv.getUint32(0);
+    let handler: RPCHandler | undefined;
+    let args: Uint8Array;
+    let handlerName: string;
+    if (rpcId === 0) {
+      if (msg.data.length < 6) return;
+      const nameLen = dv.getUint16(4);
+      if (msg.data.length < 6 + nameLen) return;
+      const name = new TextDecoder().decode(msg.data.slice(6, 6 + nameLen));
+      const def = this.definitions.get(name);
+      handler = def ? this.handlers.get(def.id) : undefined;
+      args = msg.data.slice(6 + nameLen);
+      handlerName = name;
+    } else {
+      handler = this.handlers.get(rpcId);
+      args = msg.data.slice(4);
+      handlerName = String(rpcId);
+    }
+    if (handler) {
+      if (!this.checkRateLimit(handlerName)) return;
+      const result = handler(args);
+      if (result && this.isServer) {
+        const respBuf = new Uint8Array(4 + result.length);
+        const respDv = new DataView(respBuf.buffer);
+        respDv.setUint32(0, rpcId);
+        respBuf.set(result, 4);
+        this.transport.send({
+          type: 2,
+          data: respBuf,
+          reliable: true,
+          ordered: true,
+          channel: 1,
+        });
+      }
+    }
+  }
+
+  getDefinition(name: string): RPCDefinition | undefined {
+    return this.definitions.get(name);
+  }
+
+  getHandler(rpcId: number): RPCHandler | undefined {
+    return this.handlers.get(rpcId);
+  }
+
+  private checkRateLimit(handlerName: string): boolean {
+    const now = performance.now();
+    const windowMs = RPCManager.RATE_LIMIT_WINDOW_MS;
+    const timestamps = this.callTimestamps.get(handlerName) ?? [];
+    const cutoff = now - windowMs;
+    // prune entries older than 1 second
+    let firstValid = 0;
+    while (firstValid < timestamps.length && timestamps[firstValid] < cutoff) {
+      firstValid++;
+    }
+    const recent = firstValid > 0 ? timestamps.slice(firstValid) : timestamps;
+    if (recent.length >= RPCManager.RATE_LIMIT_MAX_CALLS) {
+      this.callTimestamps.set(handlerName, recent);
+      return false;
+    }
+    recent.push(now);
+    this.callTimestamps.set(handlerName, recent);
+    return true;
+  }
+
+  dispose(): void {
+    this.handlers.clear();
+    this.definitions.clear();
+    this.callTimestamps.clear();
+  }
+}

package/libraries/networking/src/session.ts

@@ -0,0 +1,173 @@
+import type { PlatformAdapter, PlatformLobbyData, PlatformPlayerInfo } from "./platform-adapter";
+import type { NetTransport } from "./transport";
+
+export type SessionState = "offline" | "hosting" | "connected" | "connecting" | "error";
+
+export interface SessionConfig {
+  maxPlayers: number;
+  isHost: boolean;
+  platform: PlatformAdapter;
+  transport?: NetTransport;
+  metadata?: Record<string, string>;
+}
+
+export interface SessionInfo {
+  state: SessionState;
+  lobbyId: string | null;
+  localPlayer: PlatformPlayerInfo | null;
+  players: PlatformPlayerInfo[];
+  tick: number;
+}
+
+export class SessionManager {
+  private platform: PlatformAdapter;
+  private transport: NetTransport | null;
+  private state: SessionState = "offline";
+  private lobby: PlatformLobbyData | null = null;
+  private localPlayer: PlatformPlayerInfo | null = null;
+  private players: PlatformPlayerInfo[] = [];
+  private tick: number = 0;
+  private maxPlayers: number;
+  private isHost: boolean;
+  private stateChangeCbs: Array<(state: SessionState) => void> = [];
+  private playerJoinCbs: Array<(player: PlatformPlayerInfo) => void> = [];
+  private playerLeaveCbs: Array<(player: PlatformPlayerInfo) => void> = [];
+
+  constructor(config: SessionConfig) {
+    this.platform = config.platform;
+    this.transport = config.transport ?? null;
+    this.maxPlayers = config.maxPlayers;
+    this.isHost = config.isHost;
+  }
+
+  async start(): Promise<void> {
+    await this.platform.init();
+    this.localPlayer = this.platform.getLocalPlayer();
+
+    this.platform.onLobbyUpdate((lobby) => {
+      this.lobby = lobby;
+      this.updatePlayers(lobby.members);
+    });
+
+    this.platform.onPeerConnect((peerId) => {
+      const player: PlatformPlayerInfo = {
+        platformId: this.platform.platformId,
+        platformPlayerId: peerId,
+        displayName: peerId,
+      };
+      this.playerJoinCbs.forEach((cb) => cb(player));
+    });
+
+    this.platform.onPeerDisconnect((peerId) => {
+      const player = this.players.find((p) => p.platformPlayerId === peerId);
+      if (player) {
+        this.playerLeaveCbs.forEach((cb) => cb(player));
+      }
+    });
+
+    if (this.isHost) {
+      this.setState("connecting");
+      this.lobby = await this.platform.createLobby({
+        maxPlayers: this.maxPlayers,
+        isHost: true,
+        metadata: this.metadata,
+      });
+      this.setState("hosting");
+    } else {
+      this.setState("connecting");
+    }
+  }
+
+  async join(lobbyId: string): Promise<void> {
+    this.setState("connecting");
+    this.lobby = await this.platform.joinLobby(lobbyId);
+    this.updatePlayers(this.lobby.members);
+    this.setState("connected");
+  }
+
+  async stop(): Promise<void> {
+    await this.platform.leaveLobby();
+    await this.platform.shutdown();
+    this.lobby = null;
+    this.players = [];
+    this.setState("offline");
+  }
+
+  tick_(dt: number): void {
+    this.tick++;
+  }
+
+  getState(): SessionState {
+    return this.state;
+  }
+
+  getLobby(): PlatformLobbyData | null {
+    return this.lobby;
+  }
+
+  getLocalPlayer(): PlatformPlayerInfo | null {
+    return this.localPlayer;
+  }
+
+  getPlayers(): PlatformPlayerInfo[] {
+    return this.players;
+  }
+
+  getMaxPlayers(): number {
+    return this.maxPlayers;
+  }
+
+  isHosting(): boolean {
+    return this.isHost;
+  }
+
+  getInfo(): SessionInfo {
+    return {
+      state: this.state,
+      lobbyId: this.lobby?.lobbyId ?? null,
+      localPlayer: this.localPlayer,
+      players: this.players,
+      tick: this.tick,
+    };
+  }
+
+  onStateChange(cb: (state: SessionState) => void): void {
+    this.stateChangeCbs.push(cb);
+  }
+
+  onPlayerJoin(cb: (player: PlatformPlayerInfo) => void): void {
+    this.playerJoinCbs.push(cb);
+  }
+
+  onPlayerLeave(cb: (player: PlatformPlayerInfo) => void): void {
+    this.playerLeaveCbs.push(cb);
+  }
+
+  private setState(state: SessionState): void {
+    this.state = state;
+    this.stateChangeCbs.forEach((cb) => cb(state));
+  }
+
+  private updatePlayers(members: PlatformPlayerInfo[]): void {
+    const oldIds = new Set(this.players.map((p) => p.platformPlayerId));
+    const newIds = new Set(members.map((p) => p.platformPlayerId));
+
+    members.forEach((p) => {
+      if (!oldIds.has(p.platformPlayerId)) {
+        this.playerJoinCbs.forEach((cb) => cb(p));
+      }
+    });
+    this.players.forEach((p) => {
+      if (!newIds.has(p.platformPlayerId)) {
+        this.playerLeaveCbs.forEach((cb) => cb(p));
+      }
+    });
+    this.players = [...members];
+  }
+
+  private metadata: Record<string, string> = {};
+
+  setMetadata(key: string, value: string): void {
+    this.metadata[key] = value;
+  }
+}