@jgengine/node 0.6.0 → 0.8.0

package/dist/wsServer.js

@@ -1,224 +1,21 @@
 import { WebSocketServer } from "ws";
-import { decidePoseSync } from "@jgengine/core/multiplayer/presenceModel";
-import { decodeWsClientMessage, encodeWsMessage, subscriptionKey, } from "@jgengine/ws/protocol";
-const DEFAULT_POSE_RULES = {
-    maxSpeed: 12,
-    maxVerticalOffset: 3,
-    minElapsedSec: 0.05,
-    maxElapsedSec: 0.5,
-    keepAliveRefreshMs: 10_000,
-};
+import { createHostRouter } from "@jgengine/ws/hostRouter";
 export function createGameWsServer(options) {
-    const host = options.host;
-    const now = options.now ?? Date.now;
-    const poseRules = options.poseRules ?? DEFAULT_POSE_RULES;
-    const authenticate = options.authenticate ?? (({ userId }) => userId);
+    const router = createHostRouter(options);
     const wss = options.server !== undefined
         ? new WebSocketServer({ server: options.server, path: options.path })
         : new WebSocketServer({ port: options.port ?? 0, path: options.path });
-    const connections = new Set();
-    const presence = new Map();
-    const send = (connection, message) => {
-        if (connection.socket.readyState !== connection.socket.OPEN)
-            return;
-        connection.socket.send(encodeWsMessage(message));
-    };
-    const reply = (connection, id, result) => {
-        send(connection, { v: 1, t: "reply", id, ok: true, result });
-    };
-    const replyError = (connection, id, reason) => {
-        send(connection, { v: 1, t: "reply", id, ok: false, reason });
-    };
-    const presenceRows = (serverId) => {
-        const rows = presence.get(serverId);
-        if (rows === undefined)
-            return [];
-        return [...rows.entries()].map(([userId, pose]) => ({
-            userId,
-            position: pose.position,
-            rotationY: pose.rotationY,
-            rotationPitch: pose.rotationPitch ?? 0,
-            lastSeenAt: pose.lastSeenAtMs ?? 0,
-        }));
-    };
-    const broadcastPresence = (serverId) => {
-        const key = subscriptionKey("presence", serverId);
-        const data = presenceRows(serverId);
-        for (const connection of connections) {
-            if (!connection.subscriptions.has(key))
-                continue;
-            send(connection, { v: 1, t: "update", channel: "presence", serverId, data });
-        }
-    };
-    const pushSubscription = async (connection, channel, serverId, action) => {
-        if (connection.userId === null)
-            return;
-        if (channel === "server") {
-            const data = await host.getServerView({ userId: connection.userId, serverId });
-            send(connection, { v: 1, t: "update", channel, serverId, data });
-        }
-        else if (channel === "player") {
-            const data = await host.getPlayerView({ userId: connection.userId, serverId });
-            send(connection, { v: 1, t: "update", channel, serverId, data });
-        }
-        else if (channel === "feed") {
-            const data = await host.getFeed({ userId: connection.userId, serverId, action: action ?? "" });
-            send(connection, { v: 1, t: "update", channel, serverId, action: action ?? "", data });
-        }
-        else {
-            send(connection, { v: 1, t: "update", channel, serverId, data: presenceRows(serverId) });
-        }
-    };
-    const onHostEvent = (event) => {
-        for (const connection of connections) {
-            if (connection.userId === null)
-                continue;
-            if (event.type === "server") {
-                if (connection.subscriptions.has(subscriptionKey("server", event.serverId))) {
-                    void pushSubscription(connection, "server", event.serverId);
-                }
-            }
-            else if (event.type === "player") {
-                if (connection.userId === event.userId &&
-                    connection.subscriptions.has(subscriptionKey("player", event.serverId))) {
-                    void pushSubscription(connection, "player", event.serverId);
-                }
-            }
-            else {
-                if (connection.subscriptions.has(subscriptionKey("feed", event.serverId, event.action))) {
-                    void pushSubscription(connection, "feed", event.serverId, event.action);
-                }
-            }
-        }
-    };
-    const unsubscribeHost = host.subscribe(onHostEvent);
-    const handlePose = (connection, serverId, pose) => {
-        if (connection.userId === null)
-            return;
-        const rows = presence.get(serverId) ?? new Map();
-        presence.set(serverId, rows);
-        const timestamp = now();
-        const current = rows.get(connection.userId);
-        if (current === undefined) {
-            rows.set(connection.userId, {
-                position: { x: pose.x, y: pose.y, z: pose.z },
-                rotationY: pose.rotationY,
-                rotationPitch: pose.rotationPitch,
-                lastSeenAtMs: timestamp,
-            });
-            broadcastPresence(serverId);
-            return;
-        }
-        const decision = decidePoseSync(current, { position: { x: pose.x, y: pose.y, z: pose.z }, rotationY: pose.rotationY, rotationPitch: pose.rotationPitch }, poseRules, timestamp);
-        if (decision.changed || decision.refreshKeepAlive) {
-            rows.set(connection.userId, {
-                position: decision.position,
-                rotationY: decision.rotationY,
-                rotationPitch: decision.rotationPitch,
-                lastSeenAtMs: timestamp,
-            });
-        }
-        if (decision.changed)
-            broadcastPresence(serverId);
-    };
-    const dropPresence = (connection) => {
-        if (connection.userId === null)
-            return;
-        for (const [serverId, rows] of presence) {
-            if (rows.delete(connection.userId)) {
-                if (rows.size === 0)
-                    presence.delete(serverId);
-                broadcastPresence(serverId);
-            }
-        }
-    };
-    const handleMessage = async (connection, message) => {
-        if (message.t === "hello") {
-            const userId = await authenticate({ userId: message.userId, token: message.token });
-            if (userId === null) {
-                replyError(connection, message.id, "Not authenticated");
-                connection.socket.close();
-                return;
-            }
-            connection.userId = userId;
-            reply(connection, message.id, { userId });
-            return;
-        }
-        if (message.t === "pose") {
-            handlePose(connection, message.serverId, message.pose);
-            return;
-        }
-        if (connection.userId === null) {
-            replyError(connection, message.id, "Not authenticated");
-            return;
-        }
-        const userId = connection.userId;
-        try {
-            switch (message.t) {
-                case "join": {
-                    const result = await host.joinServer({
-                        userId,
-                        gameId: message.gameId,
-                        serverId: message.serverId,
-                    });
-                    reply(connection, message.id, result);
-                    return;
-                }
-                case "leave": {
-                    await host.leaveServer({ userId, serverId: message.serverId });
-                    reply(connection, message.id, null);
-                    return;
-                }
-                case "runCommand": {
-                    const result = await host.runCommand({
-                        userId,
-                        serverId: message.serverId,
-                        command: message.command,
-                        input: message.input,
-                    });
-                    reply(connection, message.id, result);
-                    return;
-                }
-                case "pushFeed": {
-                    await host.pushFeedEntry({
-                        userId,
-                        serverId: message.serverId,
-                        action: message.action,
-                        entry: message.entry,
-                    });
-                    reply(connection, message.id, null);
-                    return;
-                }
-                case "subscribe": {
-                    connection.subscriptions.add(subscriptionKey(message.channel, message.serverId, message.action));
-                    reply(connection, message.id, null);
-                    await pushSubscription(connection, message.channel, message.serverId, message.action);
-                    return;
-                }
-                case "unsubscribe": {
-                    connection.subscriptions.delete(subscriptionKey(message.channel, message.serverId, message.action));
-                    reply(connection, message.id, null);
-                    return;
-                }
-            }
-        }
-        catch (error) {
-            replyError(connection, message.id, error instanceof Error ? error.message : "Internal error");
-        }
-    };
     wss.on("connection", (socket) => {
-        const connection = { socket, userId: null, subscriptions: new Set() };
-        connections.add(connection);
-        socket.on("message", (raw) => {
-            const message = decodeWsClientMessage(raw.toString());
-            if (message === null)
-                return;
-            void handleMessage(connection, message);
-        });
-        socket.on("close", () => {
-            connections.delete(connection);
-            dropPresence(connection);
+        const connection = router.connect({
+            send: (data) => {
+                if (socket.readyState !== socket.OPEN)
+                    return;
+                socket.send(data);
+            },
+            close: () => socket.close(),
         });
+        socket.on("message", (raw) => connection.handleRaw(raw.toString()));
+        socket.on("close", () => connection.close());
     });
     return {
         wss,
@@ -229,10 +26,11 @@ export function createGameWsServer(options) {
             }
             return address.port;
         },
+        rewind: router.rewind,
         close: () => new Promise((resolve) => {
-            unsubscribeHost();
-            for (const connection of connections) {
-                connection.socket.terminate();
+            router.close();
+            for (const client of wss.clients) {
+                client.terminate();
             }
             let settled = false;
             const finish = () => {