modd-network 1.0.1 → 1.0.3

package/dist/modd-engine.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/modd-engine.test.js

@@ -0,0 +1,190 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const modd_engine_1 = require("./modd-engine");
+// Mock physics adapter
+function createMockAdapter(initialState) {
+    let state = { ...initialState };
+    return {
+        getState: () => ({ ...state }),
+        setState: (newState) => { state = { ...newState }; }
+    };
+}
+(0, vitest_1.describe)('createStateSync (Game)', () => {
+    let game;
+    (0, vitest_1.beforeEach)(() => {
+        game = (0, modd_engine_1.createStateSync)({ lerpSpeed: 0.3 });
+    });
+    (0, vitest_1.describe)('player management', () => {
+        (0, vitest_1.it)('should add and retrieve players', () => {
+            game.addPlayer('player1', { x: 0, y: 0, z: 0 });
+            const player = game.getPlayer('player1');
+            (0, vitest_1.expect)(player).toBeDefined();
+            (0, vitest_1.expect)(player?.id).toBe('player1');
+        });
+        (0, vitest_1.it)('should remove players', () => {
+            game.addPlayer('player1', { x: 0, y: 0, z: 0 });
+            game.removePlayer('player1');
+            (0, vitest_1.expect)(game.getPlayer('player1')).toBeUndefined();
+        });
+        (0, vitest_1.it)('should get all players', () => {
+            game.addPlayer('player1', { x: 0, y: 0, z: 0 });
+            game.addPlayer('player2', { x: 10, y: 0, z: 10 });
+            const players = game.getPlayers();
+            (0, vitest_1.expect)(players.length).toBe(2);
+        });
+        (0, vitest_1.it)('should set local player', () => {
+            game.setLocalPlayer('player1');
+            (0, vitest_1.expect)(game.localPlayerId).toBe('player1');
+        });
+        (0, vitest_1.it)('should update local player state', () => {
+            game.setLocalPlayer('player1');
+            game.addPlayer('player1', { x: 0, y: 0, z: 0 });
+            game.updateLocalPlayerState({ x: 10, y: 5, z: 10 });
+            const player = game.getPlayer('player1');
+            (0, vitest_1.expect)(player?.state.x).toBe(10);
+            (0, vitest_1.expect)(player?.state.y).toBe(5);
+        });
+    });
+    (0, vitest_1.describe)('entity management', () => {
+        (0, vitest_1.it)('should register and retrieve entities', () => {
+            const adapter = createMockAdapter({ x: 0, y: 0, z: 0 });
+            game.registerEntity('box1', adapter);
+            const entity = game.getEntity('box1');
+            (0, vitest_1.expect)(entity).toBeDefined();
+            (0, vitest_1.expect)(entity?.id).toBe('box1');
+        });
+        (0, vitest_1.it)('should unregister entities', () => {
+            const adapter = createMockAdapter({ x: 0, y: 0, z: 0 });
+            game.registerEntity('box1', adapter);
+            game.unregisterEntity('box1');
+            (0, vitest_1.expect)(game.getEntity('box1')).toBeUndefined();
+        });
+        (0, vitest_1.it)('should get all entities', () => {
+            game.registerEntity('box1', createMockAdapter({ x: 0, y: 0, z: 0 }));
+            game.registerEntity('box2', createMockAdapter({ x: 10, y: 0, z: 10 }));
+            (0, vitest_1.expect)(game.getEntities().length).toBe(2);
+        });
+    });
+    (0, vitest_1.describe)('authority', () => {
+        (0, vitest_1.beforeEach)(() => {
+            const adapter = createMockAdapter({ x: 10, y: 0, z: 10 });
+            game.registerEntity('box1', adapter);
+        });
+        (0, vitest_1.it)('should return false when no local player', () => {
+            (0, vitest_1.expect)(game.isAuthority('box1')).toBe(false);
+        });
+        (0, vitest_1.it)('should assign authority to closest player after tick', () => {
+            game.setLocalPlayer('player1');
+            game.addPlayer('player1', { x: 10, y: 0, z: 10 }); // close
+            game.addPlayer('player2', { x: 100, y: 0, z: 100 }); // far
+            game.tick();
+            (0, vitest_1.expect)(game.isAuthority('box1')).toBe(true);
+        });
+        (0, vitest_1.it)('should not have authority if another player is closer', () => {
+            game.setLocalPlayer('player1');
+            game.addPlayer('player1', { x: 100, y: 0, z: 100 }); // far
+            game.addPlayer('player2', { x: 10, y: 0, z: 10 }); // close
+            game.tick();
+            (0, vitest_1.expect)(game.isAuthority('box1')).toBe(false);
+        });
+    });
+    (0, vitest_1.describe)('state receiving', () => {
+        (0, vitest_1.it)('should receive player state via processInput', () => {
+            game.setLocalPlayer('player1');
+            game.addPlayer('player1', { x: 0, y: 0, z: 0 });
+            game.processInput({ type: 'playerState', id: 'player2', x: 50, y: 0, z: 50 });
+            const player2 = game.getPlayer('player2');
+            (0, vitest_1.expect)(player2).toBeDefined();
+            (0, vitest_1.expect)(player2?.targetState.x).toBe(50);
+        });
+        (0, vitest_1.it)('should not apply own state back', () => {
+            game.setLocalPlayer('player1');
+            game.addPlayer('player1', { x: 0, y: 0, z: 0 });
+            game.processInput({ type: 'playerState', id: 'player1', x: 100, y: 0, z: 100 });
+            const player1 = game.getPlayer('player1');
+            (0, vitest_1.expect)(player1?.state.x).toBe(0);
+        });
+        (0, vitest_1.it)('should receive entity state when not authority', () => {
+            const adapter = createMockAdapter({ x: 0, y: 0, z: 0 });
+            game.registerEntity('box1', adapter);
+            game.processInput({ type: 'entityState', id: 'box1', x: 50, y: 10, z: 50 });
+            const entity = game.getEntity('box1');
+            (0, vitest_1.expect)(entity?.targetState.x).toBe(50);
+        });
+    });
+    (0, vitest_1.describe)('tick', () => {
+        (0, vitest_1.it)('should increment frame', () => {
+            const initialFrame = game.frame;
+            game.tick();
+            (0, vitest_1.expect)(game.frame).toBe(initialFrame + 1);
+        });
+        (0, vitest_1.it)('should interpolate other players toward target', () => {
+            game.setLocalPlayer('player1');
+            game.addPlayer('player1', { x: 0, y: 0, z: 0 });
+            game.addPlayer('player2', { x: 0, y: 0, z: 0 });
+            // Set target for player2
+            const player2 = game.getPlayer('player2');
+            player2.targetState = { x: 100, y: 0, z: 0 };
+            game.tick();
+            // Should have moved toward target
+            (0, vitest_1.expect)(player2.state.x).toBeGreaterThan(0);
+            (0, vitest_1.expect)(player2.state.x).toBeLessThan(100);
+        });
+    });
+    (0, vitest_1.describe)('configuration', () => {
+        (0, vitest_1.it)('should use default config values', () => {
+            const defaultGame = (0, modd_engine_1.createStateSync)();
+            (0, vitest_1.expect)(defaultGame.config.lerpSpeed).toBe(0.3);
+            (0, vitest_1.expect)(defaultGame.config.positionThreshold).toBe(0.01);
+            (0, vitest_1.expect)(defaultGame.config.restFramesRequired).toBe(30);
+        });
+        (0, vitest_1.it)('should accept custom config', () => {
+            const customGame = (0, modd_engine_1.createStateSync)({
+                lerpSpeed: 0.5,
+                positionThreshold: 0.1,
+                restFramesRequired: 60
+            });
+            (0, vitest_1.expect)(customGame.config.lerpSpeed).toBe(0.5);
+            (0, vitest_1.expect)(customGame.config.positionThreshold).toBe(0.1);
+            (0, vitest_1.expect)(customGame.config.restFramesRequired).toBe(60);
+        });
+    });
+});
+(0, vitest_1.describe)('rapierAdapter', () => {
+    (0, vitest_1.it)('should throw on invalid body', () => {
+        (0, vitest_1.expect)(() => (0, modd_engine_1.rapierAdapter)(null)).toThrow();
+        (0, vitest_1.expect)(() => (0, modd_engine_1.rapierAdapter)(undefined)).toThrow();
+        (0, vitest_1.expect)(() => (0, modd_engine_1.rapierAdapter)({})).toThrow();
+    });
+    (0, vitest_1.it)('should work with valid body', () => {
+        const mockBody = {
+            translation: () => ({ x: 1, y: 2, z: 3 }),
+            linvel: () => ({ x: 0.1, y: 0.2, z: 0.3 }),
+            rotation: () => ({ x: 0, y: 0, z: 0, w: 1 }),
+            angvel: () => ({ x: 0, y: 0, z: 0 }),
+            setTranslation: () => { },
+            setLinvel: () => { },
+            setRotation: () => { },
+            setAngvel: () => { }
+        };
+        const adapter = (0, modd_engine_1.rapierAdapter)(mockBody);
+        const state = adapter.getState();
+        (0, vitest_1.expect)(state.x).toBe(1);
+        (0, vitest_1.expect)(state.y).toBe(2);
+        (0, vitest_1.expect)(state.z).toBe(3);
+    });
+});
+(0, vitest_1.describe)('generic2DAdapter', () => {
+    (0, vitest_1.it)('should get and set state', () => {
+        let body = { x: 10, y: 20, vx: 1, vy: 2 };
+        const adapter = (0, modd_engine_1.generic2DAdapter)(() => body, (state) => { body = { ...body, ...state }; });
+        const state = adapter.getState();
+        (0, vitest_1.expect)(state.x).toBe(10);
+        (0, vitest_1.expect)(state.y).toBe(20);
+        (0, vitest_1.expect)(state.z).toBe(0);
+        adapter.setState({ x: 50, y: 60, z: 0, vx: 5, vy: 6 });
+        (0, vitest_1.expect)(body.x).toBe(50);
+        (0, vitest_1.expect)(body.y).toBe(60);
+    });
+});

package/dist/modd-network.d.ts

@@ -1,40 +1,73 @@
 /**
- * MODD Network SDK
- * Pure network layer for real-time multiplayer applications
- * Works with any app type: games, chat, collaboration, etc.
+ * Hash a client ID to a 4-byte identifier (matches server-side hash)
+ * Uses FNV-1a hash for speed and consistency
  */
-export interface ConnectOptions {
-    appId?: string;
-    snapshot?: any;
-    user?: any;
-    centralServiceUrl?: string;
-    creatorNodeId?: string;
-    getStateHash?: () => string;
-    onConnect?: (snapshot: any, inputs: Input[]) => void;
-    onDisconnect?: () => void;
-    onError?: (error: string) => void;
-    onMessage?: (data: any, seq: number) => void;
-    onTick?: (frame: number, inputs: Input[], isCatchUp?: boolean) => void;
-    onSnapshot?: (snapshot: any, hash: string) => void;
-}
-export interface Input {
-    sequenceNumber: number;
+export declare function hashClientId(clientId: string): number;
+export declare const hashPlayerId: typeof hashClientId;
+/**
+ * Register a client ID so we can decode their hash in TICK messages
+ * Call this when a client joins (from the join event's clientId)
+ */
+export declare function registerClientId(clientId: string): void;
+export declare const registerPlayerId: typeof registerClientId;
+/**
+ * Unregister a client ID (call on leave)
+ */
+export declare function unregisterClientId(clientId: string): void;
+export declare const unregisterPlayerId: typeof unregisterClientId;
+export interface GameEvent {
+    id: string;
+    clientId: string;
+    type: string;
     data: any;
-    clientId?: string;
-    timestamp?: number;
+    timestamp: number;
+    seq: number;
 }
+export type Input = GameEvent;
 export interface Connection {
     send(data: any): void;
     sendSnapshot(snapshot: any, hash: string): void;
     leaveRoom(): void;
     close(): void;
     readonly connected: boolean;
+    readonly clientId: string | null;
     readonly node: string | null;
     readonly bandwidthIn: number;
     readonly bandwidthOut: number;
     readonly totalBytesIn: number;
     readonly totalBytesOut: number;
     readonly frame: number;
+    getLatency(): string;
+    getClients(): void;
+}
+export interface ConnectOptions {
+    snapshot?: any;
+    user?: any;
+    centralServiceUrl?: string;
+    nodeUrl?: string;
+    joinToken?: string;
+    getStateHash?: () => string;
+    onConnect?: (snapshot: any, events: GameEvent[], frame: number, node: string | null) => void;
+    onDisconnect?: () => void;
+    onError?: (error: string) => void;
+    onMessage?: (data: any, seq: number) => void;
+    onTick?: (frame: number, events: GameEvent[], isCatchUp?: boolean) => void;
+    onSnapshot?: (snapshot: any, hash: string) => void;
+    onClientsUpdate?: (clients: any[]) => void;
+}
+export interface DecodedMessage {
+    type: string;
+    roomId?: string;
+    clientId?: string;
+    frame?: number;
+    inputs?: any[];
+    snapshot?: any;
+    snapshotHash?: string;
+    events?: GameEvent[];
+    message?: string;
+    clients?: any[];
 }
-export declare function connect(roomId: string, options?: ConnectOptions): Promise<Connection>;
+export declare function encodeSyncHash(roomId: string, hash: string, seq: number, frame: number): Uint8Array;
+export declare function decodeBinaryMessage(buffer: ArrayBuffer): DecodedMessage | null;
+export declare function connect(appId: string, roomId: string, options?: ConnectOptions): Promise<Connection>;
 export declare const modd: typeof connect;