@downdraft/engine 0.0.0 → 0.1.0

package/libraries/navmesh/src/pathfinder.ts

@@ -0,0 +1,252 @@
+import type { NavMesh } from "./navmesh";
+import type { Vec3 } from "./types";
+
+interface AStarNode {
+  polyId: number;
+  g: number;
+  f: number;
+  parent: AStarNode | null;
+}
+
+class MinHeap<T> {
+  private data: T[] = [];
+  private compare: (a: T, b: T) => number;
+
+  constructor(compare: (a: T, b: T) => number) {
+    this.compare = compare;
+  }
+
+  get size(): number {
+    return this.data.length;
+  }
+
+  push(item: T): void {
+    this.data.push(item);
+    this.siftUp(this.data.length - 1);
+  }
+
+  pop(): T | undefined {
+    if (this.data.length === 0) return undefined;
+    const top = this.data[0];
+    const last = this.data.pop()!;
+    if (this.data.length > 0) {
+      this.data[0] = last;
+      this.siftDown(0);
+    }
+    return top;
+  }
+
+  private siftUp(idx: number): void {
+    while (idx > 0) {
+      const parent = (idx - 1) >> 1;
+      if (this.compare(this.data[idx], this.data[parent]) >= 0) break;
+      [this.data[idx], this.data[parent]] = [this.data[parent], this.data[idx]];
+      idx = parent;
+    }
+  }
+
+  private siftDown(idx: number): void {
+    const n = this.data.length;
+    while (true) {
+      let smallest = idx;
+      const left = idx * 2 + 1;
+      const right = idx * 2 + 2;
+      if (left < n && this.compare(this.data[left], this.data[smallest]) < 0) smallest = left;
+      if (right < n && this.compare(this.data[right], this.data[smallest]) < 0) smallest = right;
+      if (smallest === idx) break;
+      [this.data[idx], this.data[smallest]] = [this.data[smallest], this.data[idx]];
+      idx = smallest;
+    }
+  }
+}
+
+export class Pathfinder {
+  private navMesh: NavMesh;
+
+  constructor(navMesh: NavMesh) {
+    this.navMesh = navMesh;
+  }
+
+  findPath(start: Vec3, end: Vec3): Vec3[] {
+    const startPoly = this.navMesh.findClosestPoly(start);
+    const endPoly = this.navMesh.findClosestPoly(end);
+
+    if (startPoly < 0 || endPoly < 0) return [];
+    if (startPoly === endPoly) return [start, end];
+
+    const polyPath = this.aStar(startPoly, endPoly);
+    if (polyPath.length === 0) return [];
+
+    return this.funnelAlgorithm(start, end, polyPath);
+  }
+
+  private aStar(startPoly: number, endPoly: number): number[] {
+    const open = new MinHeap<AStarNode>((a, b) => a.f - b.f);
+    const closed = new Set<number>();
+    const allNodes = new Map<number, AStarNode>();
+    const MAX_ITERATIONS = 10000;
+
+    const startNode: AStarNode = {
+      polyId: startPoly,
+      g: 0,
+      f: 0,
+      parent: null,
+    };
+    const endCenter = this.navMesh.getPolyCenter(endPoly);
+    startNode.f = this.heuristic(this.navMesh.getPolyCenter(startPoly), endCenter);
+    open.push(startNode);
+    allNodes.set(startPoly, startNode);
+
+    let iterations = 0;
+    while (open.size > 0) {
+      if (iterations++ >= MAX_ITERATIONS) {
+        return [];
+      }
+      const current = open.pop()!;
+
+      if (closed.has(current.polyId)) continue;
+      const best = allNodes.get(current.polyId);
+      if (best && current.f > best.f) continue;
+
+      if (current.polyId === endPoly) {
+        return this.reconstructPath(current);
+      }
+
+      closed.add(current.polyId);
+
+      const neighbors = this.navMesh.getPolyNeighbors(current.polyId);
+      for (let _i = 0, _it = neighbors, _n = _it.length; _i < _n; _i++) { const neighborId = _it[_i];
+        if (closed.has(neighborId)) continue;
+
+        const neighborCenter = this.navMesh.getPolyCenter(neighborId);
+        const g = current.g + this.heuristic(
+          this.navMesh.getPolyCenter(current.polyId),
+          neighborCenter,
+        );
+
+        const existing = allNodes.get(neighborId);
+        if (existing && g >= existing.g) continue;
+
+        const h = this.heuristic(neighborCenter, endCenter);
+        const node: AStarNode = {
+          polyId: neighborId,
+          g,
+          f: g + h,
+          parent: current,
+        };
+        allNodes.set(neighborId, node);
+        open.push(node);
+      }
+    }
+
+    return [];
+  }
+
+  private reconstructPath(node: AStarNode): number[] {
+    const path: number[] = [];
+    let current: AStarNode | null = node;
+    while (current) {
+      path.unshift(current.polyId);
+      current = current.parent;
+    }
+    return path;
+  }
+
+  private heuristic(a: Vec3, b: Vec3): number {
+    const dx = a[0] - b[0];
+    const dy = a[1] - b[1];
+    const dz = a[2] - b[2];
+    return Math.sqrt(dx * dx + dy * dy + dz * dz);
+  }
+
+  private funnelAlgorithm(start: Vec3, end: Vec3, polyPath: number[]): Vec3[] {
+    if (polyPath.length < 2) return [start, end];
+
+    const portals: { left: Vec3; right: Vec3 }[] = [];
+    for (let i = 0; i < polyPath.length - 1; i++) {
+      const portal = this.navMesh.getPortalEdge(polyPath[i], polyPath[i + 1]);
+      if (portal) {
+        portals.push({ left: portal.left, right: portal.right });
+      } else {
+        const center = this.navMesh.getPolyCenter(polyPath[i]);
+        portals.push({ left: center, right: center });
+      }
+    }
+
+    const path: Vec3[] = [start];
+    let apex = start;
+    let apexIndex = 0;
+    let leftLeg = portals[0].left;
+    let leftIndex = 0;
+    let rightLeg = portals[0].right;
+    let rightIndex = 0;
+
+    for (let i = 1; i <= portals.length; i++) {
+      if (i === portals.length) {
+        if (!this.vecEqual(apex, end)) {
+          path.push(end);
+        }
+        break;
+      }
+
+      const portal = portals[i];
+      const newLeft = portal.left;
+      const newRight = portal.right;
+
+      if (this.tripleProduct(rightLeg, apex, newRight) >= 0) {
+        if (this.tripleProduct(leftLeg, apex, newRight) > 0 || apexIndex === rightIndex) {
+          rightLeg = newRight;
+          rightIndex = i;
+        } else {
+          apex = leftLeg;
+          apexIndex = leftIndex;
+          if (!this.vecEqual(apex, path[path.length - 1])) {
+            path.push(apex);
+          }
+          leftLeg = apex;
+          leftIndex = apexIndex;
+          rightLeg = apex;
+          rightIndex = apexIndex;
+          i = apexIndex;
+          continue;
+        }
+      }
+
+      if (this.tripleProduct(leftLeg, apex, newLeft) <= 0) {
+        if (this.tripleProduct(rightLeg, apex, newLeft) < 0 || apexIndex === leftIndex) {
+          leftLeg = newLeft;
+          leftIndex = i;
+        } else {
+          apex = rightLeg;
+          apexIndex = rightIndex;
+          if (!this.vecEqual(apex, path[path.length - 1])) {
+            path.push(apex);
+          }
+          leftLeg = apex;
+          leftIndex = apexIndex;
+          rightLeg = apex;
+          rightIndex = apexIndex;
+          i = apexIndex;
+          continue;
+        }
+      }
+    }
+
+    return path;
+  }
+
+  private tripleProduct(a: Vec3, b: Vec3, c: Vec3): number {
+    const abx = b[0] - a[0];
+    const abz = b[2] - a[2];
+    const acx = c[0] - a[0];
+    const acz = c[2] - a[2];
+    return abx * acz - abz * acx;
+  }
+
+  private vecEqual(a: Vec3, b: Vec3): boolean {
+    const eps = 0.0001;
+    return Math.abs(a[0] - b[0]) < eps &&
+           Math.abs(a[1] - b[1]) < eps &&
+           Math.abs(a[2] - b[2]) < eps;
+  }
+}

package/libraries/navmesh/src/types.ts

@@ -0,0 +1,63 @@
+export type Vec3 = [number, number, number];
+
+export interface NavPoly {
+  id: number;
+  vertexIndices: number[];
+  neighborPolys: number[];
+  portalEdges: PortalEdge[];
+  centroid: Vec3;
+  area: number;
+  region: number;
+}
+
+export interface PortalEdge {
+  fromPoly: number;
+  toPoly: number;
+  left: Vec3;
+  right: Vec3;
+}
+
+export interface NavMeshData {
+  polygons: NavPoly[];
+  vertices: Float32Array;
+  vertexCount: number;
+}
+
+export interface NavMeshGeneratorConfig {
+  cellSize: number;
+  cellHeight: number;
+  agentRadius: number;
+  agentHeight: number;
+  maxSlope: number;
+  maxStep: number;
+  regionMinSize: number;
+}
+
+export interface HeightFieldSampler {
+  sampleHeight(x: number, z: number): number;
+  isWalkable(x: number, z: number): boolean;
+}
+
+export interface NavAgentData {
+  [key: string]: unknown;
+  radius: number;
+  height: number;
+  maxSpeed: number;
+  acceleration: number;
+  path: Vec3[];
+  pathIndex: number;
+  velocity: Vec3;
+  target: Vec3 | null;
+  state: "idle" | "seeking" | "arrived";
+  avoidanceRadius: number;
+  separationWeight: number;
+  alignmentWeight: number;
+  cohesionWeight: number;
+  polyId: number;
+  repathTimer: number;
+}
+
+export interface CrowdSystemConfig {
+  spatialCellSize: number;
+  terrainSampleFn: ((x: number, z: number) => number) | null;
+}

package/libraries/networking/README.md

@@ -0,0 +1,25 @@
+# `@downdraft/engine/libraries/networking`
+
+Client/server networking transports — WebRTC, WebSocket, and loopback/mock transports with a shared transport contract.
+
+## Install
+
+```sh
+bun add @downdraft/engine/libraries/networking
+```
+
+## Key exports
+
+- `AuthorityManager`
+- `ConnectionManager`
+- `DeltaDecoder`
+- `DeltaEncoder`
+- `EpicEOSAdapter`
+- `InterestManager`
+- `InterpolationManager`
+- `LobbyManager`
+- `MockPlatformAdapter`
+- `MockTransport`
+- …and 17 more
+
+See the [Downdraft engine repository](https://github.com/knackstedt/downdraft) for architecture docs and examples.

package/libraries/networking/src/authority.ts

@@ -0,0 +1,121 @@
+export type AuthorityLevel = "server" | "client" | "shared";
+
+export interface EntityAuthority {
+  entityId: number;
+  ownerPeerId: string | null;
+  authorityLevel: AuthorityLevel;
+  locked: boolean;
+}
+
+export class AuthorityManager {
+  private authorities: Map<number, EntityAuthority> = new Map();
+  private localPeerId: string;
+  private isServer: boolean;
+  private authorityChangeCbs: Array<(entityId: number, authority: EntityAuthority) => void> = [];
+
+  constructor(localPeerId: string, isServer: boolean) {
+    this.localPeerId = localPeerId;
+    this.isServer = isServer;
+  }
+
+  registerEntity(entityId: number, authorityLevel: AuthorityLevel = "server"): void {
+    this.authorities.set(entityId, {
+      entityId,
+      ownerPeerId: authorityLevel === "client" ? this.localPeerId : null,
+      authorityLevel,
+      locked: false,
+    });
+  }
+
+  unregisterEntity(entityId: number): void {
+    this.authorities.delete(entityId);
+  }
+
+  requestAuthority(entityId: number, peerId: string): boolean {
+    if (!this.isServer) return false;
+    const auth = this.authorities.get(entityId);
+    if (!auth) return false;
+    if (auth.locked) return false;
+    auth.ownerPeerId = peerId;
+    auth.authorityLevel = "client";
+    this.notifyChange(entityId, auth);
+    return true;
+  }
+
+  grantAuthority(entityId: number, peerId: string): void {
+    const auth = this.authorities.get(entityId);
+    if (!auth) return;
+    auth.ownerPeerId = peerId;
+    auth.authorityLevel = "client";
+    this.notifyChange(entityId, auth);
+  }
+
+  revokeAuthority(entityId: number): void {
+    const auth = this.authorities.get(entityId);
+    if (!auth) return;
+    auth.ownerPeerId = null;
+    auth.authorityLevel = "server";
+    this.notifyChange(entityId, auth);
+  }
+
+  lockAuthority(entityId: number): void {
+    const auth = this.authorities.get(entityId);
+    if (!auth) return;
+    auth.locked = true;
+  }
+
+  unlockAuthority(entityId: number): void {
+    const auth = this.authorities.get(entityId);
+    if (!auth) return;
+    auth.locked = false;
+  }
+
+  hasAuthority(entityId: number): boolean {
+    const auth = this.authorities.get(entityId);
+    if (!auth) return false;
+    if (this.isServer && auth.authorityLevel === "server") return true;
+    if (auth.authorityLevel === "client" && auth.ownerPeerId === this.localPeerId) return true;
+    if (auth.authorityLevel === "shared") return true;
+    return false;
+  }
+
+  getAuthority(entityId: number): EntityAuthority | undefined {
+    return this.authorities.get(entityId);
+  }
+
+  getOwnedEntities(): number[] {
+    const result: number[] = [];
+    for (const [entityId, auth] of this.authorities.entries()) {
+      if (auth.ownerPeerId === this.localPeerId) {
+        result.push(entityId);
+      }
+    }
+    return result;
+  }
+
+  getServerEntities(): number[] {
+    const result: number[] = [];
+    for (const [entityId, auth] of this.authorities.entries()) {
+      if (auth.authorityLevel === "server") {
+        result.push(entityId);
+      }
+    }
+    return result;
+  }
+
+  canModify(entityId: number): boolean {
+    return this.hasAuthority(entityId);
+  }
+
+  onAuthorityChange(cb: (entityId: number, authority: EntityAuthority) => void): void {
+    this.authorityChangeCbs.push(cb);
+  }
+
+  private notifyChange(entityId: number, auth: EntityAuthority): void {
+    this.authorityChangeCbs.forEach((cb) => cb(entityId, auth));
+  }
+
+  setLocalPeerId(peerId: string): void {
+    this.localPeerId = peerId;
+  }
+}

package/libraries/networking/src/connection.ts

@@ -0,0 +1,139 @@
+import type { PlatformAdapter } from "./platform-adapter";
+import type { NetTransport } from "./transport";
+
+export type ConnectionState = "disconnected" | "connecting" | "connected" | "reconnecting" | "error";
+
+export interface PeerInfo {
+  peerId: string;
+  connected: boolean;
+  rtt: number;
+  lastSeen: number;
+}
+
+export class ConnectionManager {
+  private platform: PlatformAdapter;
+  private transport: NetTransport | null;
+  private state: ConnectionState = "disconnected";
+  private peers: Map<string, PeerInfo> = new Map();
+  private stateChangeCbs: Array<(state: ConnectionState) => void> = [];
+  private peerConnectCbs: Array<(peerId: string) => void> = [];
+  private peerDisconnectCbs: Array<(peerId: string) => void> = [];
+  private reconnectDelay: number = 1000;
+  private maxReconnectDelay: number = 30000;
+  private reconnectAttempts: number = 0;
+  private maxReconnectAttempts: number = 5;
+
+  constructor(platform: PlatformAdapter, transport?: NetTransport) {
+    this.platform = platform;
+    this.transport = transport ?? null;
+
+    this.platform.onPeerConnect((peerId) => {
+      this.peers.set(peerId, {
+        peerId,
+        connected: true,
+        rtt: this.platform.getRTT(peerId),
+        lastSeen: Date.now(),
+      });
+      this.peerConnectCbs.forEach((cb) => cb(peerId));
+      if (this.state === "connecting" || this.state === "reconnecting") {
+        this.setState("connected");
+      }
+    });
+
+    this.platform.onPeerDisconnect((peerId) => {
+      const peer = this.peers.get(peerId);
+      if (peer) {
+        peer.connected = false;
+      }
+      this.peerDisconnectCbs.forEach((cb) => cb(peerId));
+      if (this.peers.size === 0 || ![...this.peers.values()].some((p) => p.connected)) {
+        this.setState("reconnecting");
+      }
+    });
+  }
+
+  send(peerId: string, data: Uint8Array, reliable: boolean = true): void {
+    this.platform.sendToPeer(peerId, data, reliable);
+  }
+
+  broadcast(data: Uint8Array, reliable: boolean = true): void {
+    for (const [peerId] of this.peers.entries()) {
+      this.platform.sendToPeer(peerId, data, reliable);
+    }
+  }
+
+  getConnectedPeers(): string[] {
+    return [...this.peers.values()].filter((p) => p.connected).map((p) => p.peerId);
+  }
+
+  getPeerInfo(peerId: string): PeerInfo | undefined {
+    return this.peers.get(peerId);
+  }
+
+  getPeerCount(): number {
+    return this.peers.size;
+  }
+
+  getConnectedPeerCount(): number {
+    return [...this.peers.values()].filter((p) => p.connected).length;
+  }
+
+  getState(): ConnectionState {
+    return this.state;
+  }
+
+  getAverageRTT(): number {
+    const connected = [...this.peers.values()].filter((p) => p.connected);
+    if (connected.length === 0) return 0;
+    return connected.reduce((sum, p) => sum + p.rtt, 0) / connected.length;
+  }
+
+  updatePeerRTTs(): void {
+    for (const [peerId, peer] of this.peers.entries()) {
+      peer.rtt = this.platform.getRTT(peerId);
+      peer.lastSeen = Date.now();
+    }
+  }
+
+  shouldReconnect(): boolean {
+    return this.state === "reconnecting" && this.reconnectAttempts < this.maxReconnectAttempts;
+  }
+
+  getReconnectDelay(): number {
+    const delay = Math.min(this.reconnectDelay * Math.pow(2, this.reconnectAttempts), this.maxReconnectDelay);
+    return delay;
+  }
+
+  incrementReconnectAttempt(): void {
+    this.reconnectAttempts++;
+  }
+
+  resetReconnect(): void {
+    this.reconnectAttempts = 0;
+  }
+
+  setState(state: ConnectionState): void {
+    this.state = state;
+    this.stateChangeCbs.forEach((cb) => cb(state));
+  }
+
+  onStateChange(cb: (state: ConnectionState) => void): void {
+    this.stateChangeCbs.push(cb);
+  }
+
+  onPeerConnect(cb: (peerId: string) => void): void {
+    this.peerConnectCbs.push(cb);
+  }
+
+  onPeerDisconnect(cb: (peerId: string) => void): void {
+    this.peerDisconnectCbs.push(cb);
+  }
+
+  disconnectAll(): void {
+    for (const peer of this.peers.values()) {
+      peer.connected = false;
+    }
+    this.peers.clear();
+    this.setState("disconnected");
+  }
+}