@rapierphysicsplugin/server 1.0.0

package/src/server.ts

@@ -0,0 +1,312 @@
+import { createServer, type Server as HttpServer } from 'node:http';
+import { WebSocketServer, WebSocket } from 'ws';
+import type RAPIER from '@dimforge/rapier3d-compat';
+import {
+  MessageType,
+  decodeClientMessage,
+  encodeMessage,
+  DEFAULT_PORT,
+  OPCODE_MESH_BINARY,
+  OPCODE_GEOMETRY_DEF,
+  OPCODE_MESH_REF,
+  OPCODE_MATERIAL_DEF,
+  OPCODE_TEXTURE_DEF,
+} from '@rapierphysicsplugin/shared';
+import type { ClientMessage } from '@rapierphysicsplugin/shared';
+import { RoomManager } from './room.js';
+import { ClientConnection } from './client-connection.js';
+import { handleClockSyncRequest } from './clock-sync.js';
+
+let clientIdCounter = 0;
+function generateClientId(): string {
+  return `client_${++clientIdCounter}`;
+}
+
+export class PhysicsServer {
+  private httpServer: HttpServer | null = null;
+  private wss: WebSocketServer | null = null;
+  private connections: Map<string, ClientConnection> = new Map();
+  private roomManager: RoomManager;
+  private rapier: typeof RAPIER;
+
+  constructor(rapier: typeof RAPIER) {
+    this.rapier = rapier;
+    this.roomManager = new RoomManager(rapier);
+  }
+
+  start(port: number = DEFAULT_PORT): Promise<void> {
+    return new Promise((resolve) => {
+      this.httpServer = createServer((_req, res) => {
+        res.writeHead(200, { 'Content-Type': 'text/plain' });
+        res.end('Physics server OK');
+      });
+
+      this.wss = new WebSocketServer({ server: this.httpServer });
+
+      this.wss.on('connection', (ws: WebSocket) => {
+        this.handleConnection(ws);
+      });
+
+      this.httpServer.listen(port, () => {
+        console.log(`Physics server listening on port ${port}`);
+        resolve();
+      });
+    });
+  }
+
+  private handleConnection(ws: WebSocket): void {
+    const clientId = generateClientId();
+    const conn = new ClientConnection(clientId, ws);
+    this.connections.set(clientId, conn);
+
+    console.log(`Client connected: ${clientId}`);
+
+    ws.on('message', (data: Buffer) => {
+      try {
+        const buf = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+
+        // Intercept mesh binary — relay without full decode
+        if (buf[0] === OPCODE_MESH_BINARY) {
+          if (conn.roomId) {
+            const room = this.roomManager.getRoom(conn.roomId);
+            if (room) {
+              room.relayMeshBinary(conn.id, buf);
+            }
+          }
+          return;
+        }
+
+        // Intercept geometry def — relay/store without full decode
+        if (buf[0] === OPCODE_GEOMETRY_DEF) {
+          if (conn.roomId) {
+            const room = this.roomManager.getRoom(conn.roomId);
+            if (room) {
+              room.relayGeometryDef(conn.id, buf);
+            }
+          }
+          return;
+        }
+
+        // Intercept mesh ref — relay/store without full decode
+        if (buf[0] === OPCODE_MESH_REF) {
+          if (conn.roomId) {
+            const room = this.roomManager.getRoom(conn.roomId);
+            if (room) {
+              room.relayMeshRef(conn.id, buf);
+            }
+          }
+          return;
+        }
+
+        // Intercept material def — relay/store without full decode
+        if (buf[0] === OPCODE_MATERIAL_DEF) {
+          if (conn.roomId) {
+            const room = this.roomManager.getRoom(conn.roomId);
+            if (room) {
+              room.relayMaterialDef(conn.id, buf);
+            }
+          }
+          return;
+        }
+
+        // Intercept texture def — relay/store without full decode
+        if (buf[0] === OPCODE_TEXTURE_DEF) {
+          if (conn.roomId) {
+            const room = this.roomManager.getRoom(conn.roomId);
+            if (room) {
+              room.relayTextureDef(conn.id, buf);
+            }
+          }
+          return;
+        }
+
+        const message = decodeClientMessage(buf);
+        this.handleMessage(conn, message);
+      } catch (err) {
+        console.error(`Error processing message from ${clientId}:`, err);
+        conn.send(encodeMessage({
+          type: MessageType.ERROR,
+          message: 'Invalid message format',
+        }));
+      }
+    });
+
+    ws.on('close', () => {
+      this.handleDisconnect(conn);
+    });
+
+    ws.on('error', (err) => {
+      console.error(`WebSocket error for ${clientId}:`, err);
+    });
+  }
+
+  private handleMessage(conn: ClientConnection, message: ClientMessage): void {
+    switch (message.type) {
+      case MessageType.CLOCK_SYNC_REQUEST:
+        handleClockSyncRequest(conn, message);
+        break;
+
+      case MessageType.CREATE_ROOM: {
+        try {
+          const room = this.roomManager.createRoom(
+            message.roomId,
+            message.initialBodies,
+            message.gravity
+          );
+          conn.send(encodeMessage({
+            type: MessageType.ROOM_CREATED,
+            roomId: room.id,
+          }));
+        } catch (err) {
+          conn.send(encodeMessage({
+            type: MessageType.ERROR,
+            message: (err as Error).message,
+          }));
+        }
+        break;
+      }
+
+      case MessageType.JOIN_ROOM: {
+        const room = this.roomManager.getRoom(message.roomId);
+        if (!room) {
+          conn.send(encodeMessage({
+            type: MessageType.ERROR,
+            message: `Room "${message.roomId}" not found`,
+          }));
+          return;
+        }
+
+        // Leave current room if in one
+        if (conn.roomId) {
+          const currentRoom = this.roomManager.getRoom(conn.roomId);
+          currentRoom?.removeClient(conn);
+        }
+
+        room.addClient(conn);
+        break;
+      }
+
+      case MessageType.LEAVE_ROOM: {
+        if (conn.roomId) {
+          const room = this.roomManager.getRoom(conn.roomId);
+          room?.removeClient(conn);
+        }
+        break;
+      }
+
+      case MessageType.CLIENT_INPUT: {
+        if (!conn.roomId) return;
+        const room = this.roomManager.getRoom(conn.roomId);
+        if (room) {
+          room.bufferInput(conn.id, message.input);
+        }
+        break;
+      }
+
+      case MessageType.ADD_BODY: {
+        if (!conn.roomId) return;
+        const room = this.roomManager.getRoom(conn.roomId);
+        if (room) {
+          try {
+            room.addBody(message.body);
+          } catch (err) {
+            conn.send(encodeMessage({
+              type: MessageType.ERROR,
+              message: (err as Error).message,
+            }));
+          }
+        }
+        break;
+      }
+
+      case MessageType.REMOVE_BODY: {
+        if (!conn.roomId) return;
+        const room = this.roomManager.getRoom(conn.roomId);
+        if (room) {
+          room.removeBody(message.bodyId);
+        }
+        break;
+      }
+
+      case MessageType.START_SIMULATION: {
+        if (!conn.roomId) return;
+        const room = this.roomManager.getRoom(conn.roomId);
+        if (room) {
+          room.startSimulation();
+        }
+        break;
+      }
+
+      case MessageType.BODY_EVENT: {
+        if (!conn.roomId) return;
+        // Rebroadcast body events to all clients in the room
+        const room = this.roomManager.getRoom(conn.roomId);
+        if (room) {
+          // The room broadcast is handled by forwarding the message
+          // For now, we just log it
+          console.log(`Body event from ${conn.id}: ${message.eventType} on ${message.bodyId}`);
+        }
+        break;
+      }
+
+      case MessageType.ADD_CONSTRAINT: {
+        if (!conn.roomId) return;
+        const room = this.roomManager.getRoom(conn.roomId);
+        if (room) {
+          try {
+            room.addConstraint(message.constraint);
+          } catch (err) {
+            conn.send(encodeMessage({
+              type: MessageType.ERROR,
+              message: (err as Error).message,
+            }));
+          }
+        }
+        break;
+      }
+
+      case MessageType.REMOVE_CONSTRAINT: {
+        if (!conn.roomId) return;
+        const room = this.roomManager.getRoom(conn.roomId);
+        if (room) {
+          room.removeConstraint(message.constraintId);
+        }
+        break;
+      }
+    }
+  }
+
+  private handleDisconnect(conn: ClientConnection): void {
+    console.log(`Client disconnected: ${conn.id}`);
+
+    if (conn.roomId) {
+      const room = this.roomManager.getRoom(conn.roomId);
+      room?.removeClient(conn);
+    }
+
+    this.connections.delete(conn.id);
+  }
+
+  stop(): void {
+    // Destroy all rooms
+    for (const roomId of this.roomManager.getAllRoomIds()) {
+      this.roomManager.destroyRoom(roomId);
+    }
+
+    // Close all connections
+    for (const [, conn] of this.connections) {
+      conn.ws.close();
+    }
+    this.connections.clear();
+
+    // Close servers
+    this.wss?.close();
+    this.wss = null;
+    this.httpServer?.close();
+    this.httpServer = null;
+  }
+
+  getRoomManager(): RoomManager {
+    return this.roomManager;
+  }
+}

package/src/simulation-loop.ts

@@ -0,0 +1,48 @@
+import { FIXED_TIMESTEP, BROADCAST_INTERVAL } from '@rapierphysicsplugin/shared';
+import type { Room } from './room.js';
+
+export class SimulationLoop {
+  private running = false;
+  private timer: ReturnType<typeof setInterval> | null = null;
+  private lastTime = 0;
+  private accumulator = 0;
+
+  constructor(private room: Room) {}
+
+  start(): void {
+    if (this.running) return;
+    this.running = true;
+    this.lastTime = performance.now();
+    this.accumulator = 0;
+
+    // Use setInterval at ~1ms for high resolution stepping
+    this.timer = setInterval(() => this.update(), 1);
+  }
+
+  stop(): void {
+    this.running = false;
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+
+  private update(): void {
+    const now = performance.now();
+    const elapsed = (now - this.lastTime) / 1000; // Convert to seconds
+    this.lastTime = now;
+
+    // Cap elapsed time to prevent spiral of death
+    const cappedElapsed = Math.min(elapsed, FIXED_TIMESTEP * 10);
+    this.accumulator += cappedElapsed;
+
+    while (this.accumulator >= FIXED_TIMESTEP) {
+      this.room.tick();
+      this.accumulator -= FIXED_TIMESTEP;
+    }
+  }
+
+  get isRunning(): boolean {
+    return this.running;
+  }
+}

package/src/state-manager.ts

@@ -0,0 +1,136 @@
+import type { BodyState, RoomSnapshot } from '@rapierphysicsplugin/shared';
+import { FIELD_POSITION, FIELD_ROTATION, FIELD_LIN_VEL, FIELD_ANG_VEL, FIELD_ALL } from '@rapierphysicsplugin/shared';
+import type { PhysicsWorld } from './physics-world.js';
+
+export class StateManager {
+  private lastBroadcastStates: Map<string, BodyState> = new Map();
+  private bodyIdToIndex: Map<string, number> = new Map();
+  private bodyIndexToId: Map<number, string> = new Map();
+  private nextBodyIndex = 0;
+
+  createSnapshot(world: PhysicsWorld, tick: number): RoomSnapshot {
+    const bodies = world.getSnapshot();
+    // Ensure all bodies have an index assigned
+    for (const body of bodies) {
+      this.ensureBodyIndex(body.id);
+    }
+    return {
+      tick,
+      timestamp: Date.now(),
+      bodies,
+    };
+  }
+
+  createDelta(world: PhysicsWorld, tick: number): RoomSnapshot & { isDelta: boolean } {
+    const allBodies = world.getSnapshot();
+    const changedBodies: BodyState[] = [];
+
+    for (const body of allBodies) {
+      this.ensureBodyIndex(body.id);
+      const prev = this.lastBroadcastStates.get(body.id);
+      if (!prev) {
+        body.fieldMask = FIELD_ALL;
+        changedBodies.push(body);
+      } else {
+        // Skip comparison for sleeping bodies (their state is unchanged)
+        if (world.isBodySleeping(body.id)) continue;
+
+        const mask = getChangedFields(prev, body);
+        if (mask !== 0) {
+          body.fieldMask = mask;
+          changedBodies.push(body);
+        }
+      }
+    }
+
+    // Update cache
+    for (const body of allBodies) {
+      this.lastBroadcastStates.set(body.id, body);
+    }
+
+    // Remove bodies no longer in simulation
+    for (const id of this.lastBroadcastStates.keys()) {
+      if (!world.hasBody(id)) {
+        this.lastBroadcastStates.delete(id);
+      }
+    }
+
+    return {
+      tick,
+      timestamp: Date.now(),
+      bodies: changedBodies,
+      isDelta: true,
+    };
+  }
+
+  ensureBodyIndex(id: string): number {
+    let index = this.bodyIdToIndex.get(id);
+    if (index === undefined) {
+      index = this.nextBodyIndex++;
+      this.bodyIdToIndex.set(id, index);
+      this.bodyIndexToId.set(index, id);
+    }
+    return index;
+  }
+
+  getBodyIndex(id: string): number | undefined {
+    return this.bodyIdToIndex.get(id);
+  }
+
+  getIdToIndexMap(): Map<string, number> {
+    return this.bodyIdToIndex;
+  }
+
+  getIndexToIdMap(): Map<number, string> {
+    return this.bodyIndexToId;
+  }
+
+  getIdToIndexRecord(): Record<string, number> {
+    const record: Record<string, number> = {};
+    for (const [id, index] of this.bodyIdToIndex) {
+      record[id] = index;
+    }
+    return record;
+  }
+
+  removeBody(id: string): void {
+    this.lastBroadcastStates.delete(id);
+    // Note: we don't remove the index mapping — indices are never reused
+    // to prevent desync with clients that haven't processed the removal yet
+  }
+
+  clear(): void {
+    this.lastBroadcastStates.clear();
+    this.bodyIdToIndex.clear();
+    this.bodyIndexToId.clear();
+    this.nextBodyIndex = 0;
+  }
+}
+
+const EPSILON = 0.0001;
+
+function vec3Changed(a: { x: number; y: number; z: number }, b: { x: number; y: number; z: number }): boolean {
+  return (
+    Math.abs(a.x - b.x) > EPSILON ||
+    Math.abs(a.y - b.y) > EPSILON ||
+    Math.abs(a.z - b.z) > EPSILON
+  );
+}
+
+function quatChanged(a: { x: number; y: number; z: number; w: number }, b: { x: number; y: number; z: number; w: number }): boolean {
+  return (
+    Math.abs(a.x - b.x) > EPSILON ||
+    Math.abs(a.y - b.y) > EPSILON ||
+    Math.abs(a.z - b.z) > EPSILON ||
+    Math.abs(a.w - b.w) > EPSILON
+  );
+}
+
+function getChangedFields(a: BodyState, b: BodyState): number {
+  let mask = 0;
+  if (vec3Changed(a.position, b.position)) mask |= FIELD_POSITION;
+  if (quatChanged(a.rotation, b.rotation)) mask |= FIELD_ROTATION;
+  if (vec3Changed(a.linVel, b.linVel)) mask |= FIELD_LIN_VEL;
+  if (vec3Changed(a.angVel, b.angVel)) mask |= FIELD_ANG_VEL;
+  return mask;
+}

package/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src/**/*"],
+  "references": [
+    { "path": "../shared" }
+  ]
+}