@mml-io/3d-web-user-networking 0.22.0 → 0.23.0

package/build/DeltaNetComponentMapping.d.ts

@@ -0,0 +1,58 @@
+import { UserNetworkingClientUpdate } from "./types";
+import { UserData } from "./UserData";
+import { UserNetworkingLogger } from "./UserNetworkingLogger";
+import { CharacterDescription } from "./UserNetworkingMessages";
+export declare const COMPONENT_POSITION_X = 1;
+export declare const COMPONENT_POSITION_Y = 2;
+export declare const COMPONENT_POSITION_Z = 3;
+export declare const COMPONENT_ROTATION_Y = 4;
+export declare const COMPONENT_ROTATION_W = 5;
+export declare const COMPONENT_STATE = 6;
+export declare const STATE_INTERNAL_CONNECTION_ID = 0;
+export declare const STATE_CHARACTER_DESCRIPTION = 1;
+export declare const STATE_USERNAME = 2;
+export declare const STATE_COLORS = 3;
+export declare const rotationMultiplier = 360;
+export declare const positionMultiplier = 100;
+export declare class DeltaNetComponentMapping {
+    /**
+     * Convert UserNetworkingClientUpdate to deltanet components
+     */
+    static toComponents(update: UserNetworkingClientUpdate): Map<number, bigint>;
+    /**
+     * Convert deltanet components back to UserNetworkingClientUpdate
+     */
+    static fromComponents(components: Map<number, bigint>): UserNetworkingClientUpdate;
+    /**
+     * Encode character description and username to binary states
+     */
+    static toStates(userIdentity: UserData): Map<number, Uint8Array>;
+    /**
+     * Encode username to binary state
+     */
+    static toUsernameState(username: string): Map<number, Uint8Array>;
+    /**
+     * Encode character description to binary state
+     */
+    static toCharacterDescriptionState(characterDescription: CharacterDescription): Map<number, Uint8Array>;
+    /**
+     * Encode colors to binary state
+     */
+    static toColorsState(colors: Array<[number, number, number]>): Map<number, Uint8Array>;
+    /**
+     * Encode single state value
+     */
+    static toSingleState(stateId: number, value: any): Map<number, Uint8Array>;
+    static encodeColors(colors: Array<[number, number, number]>): Uint8Array;
+    static decodeColors(colors: Uint8Array, logger: UserNetworkingLogger): Array<[number, number, number]>;
+    static fromUserStates(states: Map<number, Uint8Array>, logger: UserNetworkingLogger): UserData;
+    static userIdFromBytes(bytes: Uint8Array): number | null;
+    static usernameFromBytes(bytes: Uint8Array): string | null;
+    static characterDescriptionFromBytes(bytes: Uint8Array): CharacterDescription | null;
+    /**
+     * Decode binary states back to username and character description
+     */
+    static fromStates(states: Map<number, Uint8Array>, logger: UserNetworkingLogger): {
+        userId: number | null;
+    } & UserData;
+}

package/build/UserData.d.ts

@@ -1,5 +1,6 @@
 import { CharacterDescription } from "./UserNetworkingMessages";
 export type UserData = {
-    readonly username: string;
-    readonly characterDescription: CharacterDescription;
+    username: string | null;
+    characterDescription: CharacterDescription | null;
+    colors: Array<[number, number, number]> | null;
 };

package/build/UserNetworkingClient.d.ts

@@ -1,27 +1,53 @@
-import { ReconnectingWebSocket, WebsocketFactory, WebsocketStatus } from "./ReconnectingWebSocket";
-import { UserNetworkingClientUpdate } from "./UserNetworkingCodec";
-import { CharacterDescription, FromUserNetworkingClientMessage, UserNetworkingServerErrorType } from "./UserNetworkingMessages";
+import { UserNetworkingClientUpdate, WebsocketFactory, WebsocketStatus } from "./types";
+import { UserData } from "./UserData";
+import { UserNetworkingLogger } from "./UserNetworkingLogger";
+import { CharacterDescription } from "./UserNetworkingMessages";
 export type UserNetworkingClientConfig = {
     url: string;
     sessionToken: string;
     websocketFactory: WebsocketFactory;
     statusUpdateCallback: (status: WebsocketStatus) => void;
     assignedIdentity: (clientId: number) => void;
-    clientUpdate: (id: number, update: null | UserNetworkingClientUpdate) => void;
-    clientProfileUpdated: (id: number, username: string, characterDescription: CharacterDescription) => void;
     onServerError: (error: {
         message: string;
-        errorType: UserNetworkingServerErrorType;
-    }) => void;
-    onServerBroadcast?: (broadcast: {
-        broadcastType: string;
-        payload: any;
+        errorType: string;
     }) => void;
+    onCustomMessage?: (customType: number, contents: string) => void;
+    onUpdate(update: NetworkUpdate): void;
+};
+export type AddedUser = {
+    userState: UserData;
+    components: UserNetworkingClientUpdate;
+};
+export type UpdatedUser = {
+    userState?: Partial<UserData>;
+    components: UserNetworkingClientUpdate;
+};
+export type NetworkUpdate = {
+    removedUserIds: Set<number>;
+    addedUserIds: Map<number, AddedUser>;
+    updatedUsers: Map<number, UpdatedUser>;
 };
-export declare class UserNetworkingClient extends ReconnectingWebSocket {
+export declare class UserNetworkingClient {
     private config;
-    constructor(config: UserNetworkingClientConfig);
+    private logger;
+    private deltaNetClient;
+    private deltaNetState;
+    private userId;
+    private userIndex;
+    private userState;
+    private stableIdToUserId;
+    private userProfiles;
+    private isAuthenticated;
+    private pendingUpdate;
+    constructor(config: UserNetworkingClientConfig, initialUserState?: UserData, initialUpdate?: UserNetworkingClientUpdate, logger?: UserNetworkingLogger);
+    private reset;
+    private sendInitialAuthentication;
+    private processNetworkUpdate;
     sendUpdate(update: UserNetworkingClientUpdate): void;
-    sendMessage(message: FromUserNetworkingClientMessage): void;
-    protected handleIncomingWebsocketMessage(message: MessageEvent): void;
+    sendCustomMessage(customType: number, contents: string): void;
+    updateUsername(username: string): void;
+    updateCharacterDescription(characterDescription: CharacterDescription): void;
+    updateColors(colors: Array<[number, number, number]>): void;
+    stop(): void;
 }

package/build/UserNetworkingLogger.d.ts

@@ -0,0 +1,15 @@
+export type UserNetworkingServerLogFunction = (...args: Array<any>) => void;
+export type UserNetworkingLogger = {
+    trace: UserNetworkingServerLogFunction;
+    debug: UserNetworkingServerLogFunction;
+    info: UserNetworkingServerLogFunction;
+    warn: UserNetworkingServerLogFunction;
+    error: UserNetworkingServerLogFunction;
+};
+export declare class UserNetworkingConsoleLogger implements UserNetworkingLogger {
+    trace(...args: Array<any>): void;
+    debug(...args: Array<any>): void;
+    info(...args: Array<any>): void;
+    warn(...args: Array<any>): void;
+    error(...args: Array<any>): void;
+}

package/build/UserNetworkingMessages.d.ts

@@ -1,16 +1,4 @@
-export declare const USER_NETWORKING_DISCONNECTED_MESSAGE_TYPE = "disconnected";
-export declare const USER_NETWORKING_IDENTITY_MESSAGE_TYPE = "identity";
-export declare const USER_NETWORKING_USER_AUTHENTICATE_MESSAGE_TYPE = "user_auth";
-export declare const USER_NETWORKING_USER_PROFILE_MESSAGE_TYPE = "user_profile";
-export declare const USER_NETWORKING_USER_UPDATE_MESSAGE_TYPE = "user_update";
-export declare const USER_NETWORKING_SERVER_BROADCAST_MESSAGE_TYPE = "broadcast";
-export declare const USER_NETWORKING_SERVER_ERROR_MESSAGE_TYPE = "error";
-export declare const USER_NETWORKING_PING_MESSAGE_TYPE = "ping";
-export declare const USER_NETWORKING_PONG_MESSAGE_TYPE = "pong";
-export type UserNetworkingIdentityMessage = {
-    type: typeof USER_NETWORKING_IDENTITY_MESSAGE_TYPE;
-    id: number;
-};
+import { DeltaNetServerError } from "@mml-io/delta-net-server";
 export type CharacterDescription = {
     meshFileUrl: string;
     mmlCharacterString?: null;
@@ -24,49 +12,22 @@ export type CharacterDescription = {
     mmlCharacterString?: null;
     mmlCharacterUrl: string;
 };
-export type UserNetworkingProfileMessage = {
-    type: typeof USER_NETWORKING_USER_PROFILE_MESSAGE_TYPE;
-    id: number;
-    username: string;
-    characterDescription: CharacterDescription;
-};
-export type UserNetworkingDisconnectedMessage = {
-    type: typeof USER_NETWORKING_DISCONNECTED_MESSAGE_TYPE;
-    id: number;
+export declare class UserNetworkingServerError extends DeltaNetServerError {
+}
+export type ClientChatMessage = {
+    message: string;
 };
-export declare const USER_NETWORKING_CONNECTION_LIMIT_REACHED_ERROR_TYPE = "CONNECTION_LIMIT_REACHED";
-export declare const USER_NETWORKING_AUTHENTICATION_FAILED_ERROR_TYPE = "AUTHENTICATION_FAILED";
-export declare const USER_NETWORKING_SERVER_SHUTDOWN_ERROR_TYPE = "SERVER_SHUTDOWN";
-export declare const USER_NETWORKING_UNKNOWN_ERROR = "UNKNOWN_ERROR";
-export type UserNetworkingServerErrorType = typeof USER_NETWORKING_CONNECTION_LIMIT_REACHED_ERROR_TYPE | typeof USER_NETWORKING_AUTHENTICATION_FAILED_ERROR_TYPE | typeof USER_NETWORKING_SERVER_SHUTDOWN_ERROR_TYPE | typeof USER_NETWORKING_UNKNOWN_ERROR;
-export type UserNetworkingServerError = {
-    type: typeof USER_NETWORKING_SERVER_ERROR_MESSAGE_TYPE;
-    errorType: UserNetworkingServerErrorType;
+export type ServerChatMessage = {
+    fromUserId: number;
     message: string;
 };
-export type UserNetworkingServerBroadcast = {
-    type: typeof USER_NETWORKING_SERVER_BROADCAST_MESSAGE_TYPE;
+export type ServerBroadcastMessage = {
     broadcastType: string;
     payload: any;
 };
-export type UserNetworkingServerPingMessage = {
-    type: typeof USER_NETWORKING_PING_MESSAGE_TYPE;
-};
-export type FromUserNetworkingServerMessage = UserNetworkingIdentityMessage | UserNetworkingProfileMessage | UserNetworkingDisconnectedMessage | UserNetworkingServerPingMessage | UserNetworkingServerBroadcast | UserNetworkingServerError;
-export type UserNetworkingClientPongMessage = {
-    type: typeof USER_NETWORKING_PONG_MESSAGE_TYPE;
-};
-export type UserIdentity = {
-    characterDescription: CharacterDescription | null;
-    username: string | null;
-};
-export type UserNetworkingAuthenticateMessage = {
-    type: typeof USER_NETWORKING_USER_AUTHENTICATE_MESSAGE_TYPE;
-    sessionToken: string;
-    userIdentity?: UserIdentity;
-};
-export type UserNetworkingUserUpdateMessage = {
-    type: typeof USER_NETWORKING_USER_UPDATE_MESSAGE_TYPE;
-    userIdentity: UserIdentity;
-};
-export type FromUserNetworkingClientMessage = UserNetworkingClientPongMessage | UserNetworkingAuthenticateMessage | UserNetworkingUserUpdateMessage;
+export declare const SERVER_BROADCAST_MESSAGE_TYPE = 1;
+export declare const FROM_CLIENT_CHAT_MESSAGE_TYPE = 2;
+export declare const FROM_SERVER_CHAT_MESSAGE_TYPE = 3;
+export declare function parseClientChatMessage(contents: string): ClientChatMessage | Error;
+export declare function parseServerChatMessage(contents: string): ServerChatMessage | Error;
+export declare function parseServerBroadcastMessage(contents: string): ServerBroadcastMessage | Error;

package/build/UserNetworkingServer.d.ts

@@ -1,38 +1,49 @@
-import WebSocket from "ws";
+import { DeltaNetV01Connection } from "@mml-io/delta-net-server";
+import { LegacyUserIdentity, LegacyCharacterDescription } from "./legacy/LegacyUserNetworkingMessages";
 import { UserData } from "./UserData";
-import { UserNetworkingClientUpdate } from "./UserNetworkingCodec";
-import { UserIdentity, UserNetworkingServerError } from "./UserNetworkingMessages";
+import { UserNetworkingLogger } from "./UserNetworkingLogger";
+import { UserNetworkingServerError, CharacterDescription } from "./UserNetworkingMessages";
 export type UserNetworkingServerClient = {
     socket: WebSocket;
     id: number;
     lastPong: number;
-    update: UserNetworkingClientUpdate;
     authenticatedUser: UserData | null;
+    deltaNetConnection: DeltaNetV01Connection | null;
 };
 export type UserNetworkingServerOptions = {
-    connectionLimit?: number;
-    onClientConnect: (clientId: number, sessionToken: string, userIdentity?: UserIdentity) => Promise<UserData | null> | UserData | null;
-    onClientUserIdentityUpdate: (clientId: number, userIdentity: UserIdentity) => Promise<UserData | null> | UserData | null;
+    legacyAdapterEnabled?: boolean;
+    onClientConnect: (clientId: number, sessionToken: string, userIdentity?: UserData) => Promise<UserData | true | Error> | UserData | true | Error;
+    onClientUserIdentityUpdate: (clientId: number, userIdentity: UserData) => Promise<UserData | null | false | true | Error> | UserData | null | false | true | Error;
     onClientDisconnect: (clientId: number) => void;
 };
 export declare class UserNetworkingServer {
     private options;
-    private allClientsById;
+    private logger;
+    private deltaNetServer;
     private authenticatedClientsById;
-    private sendUpdatesIntervalTimer;
-    private pingClientsIntervalTimer;
-    private heartbeatIntervalTimer;
-    constructor(options: UserNetworkingServerOptions);
-    private heartBeat;
-    private pingClients;
-    private getId;
-    broadcastMessage(broadcastType: string, broadcastPayload: any): void;
+    private tickInterval;
+    private legacyAdapter;
+    private updatedUserProfilesInTick;
+    constructor(options: UserNetworkingServerOptions, logger?: UserNetworkingLogger);
+    getCharacterDescription(connectionId: number): LegacyCharacterDescription;
+    getUsername(connectionId: number): string;
+    getLegacyClientId(): number;
+    hasCapacityForLegacyClient(): boolean;
+    onLegacyClientConnect(id: number, sessionToken: string, userIdentity: LegacyUserIdentity | undefined): Promise<UserData | true | Error> | UserData | true | Error;
+    setAuthenticatedLegacyClientConnection(clientId: number, webSocket: WebSocket, userData: UserData): void;
+    onLegacyClientDisconnect(id: number): void;
+    private handleStatesUpdate;
+    private handleJoiner;
+    private handleLeave;
+    private handleCustomMessage;
+    private handleDeltaNetAuthentication;
     connectClient(socket: WebSocket): void;
-    private handleDisconnectedClient;
-    private handleUserAuth;
+    broadcastMessage(broadcastType: number, broadcastPayload: string): void;
     updateUserCharacter(clientId: number, userData: UserData): void;
+    updateUserUsername(clientId: number, username: string): void;
+    updateUserCharacterDescription(clientId: number, characterDescription: CharacterDescription): void;
+    updateUserColors(clientId: number, colors: Array<[number, number, number]>): void;
+    updateUserStates(clientId: number, updates: UserData): void;
     private internalUpdateUser;
-    private handleUserUpdate;
-    private sendUpdates;
     dispose(clientCloseError?: UserNetworkingServerError): void;
 }

package/build/index.d.ts

@@ -1,6 +1,9 @@
-export * from "./UserNetworkingCodec";
 export * from "./UserNetworkingServer";
 export * from "./UserNetworkingClient";
 export * from "./UserData";
-export * from "./ReconnectingWebSocket";
+export * from "./types";
 export * from "./UserNetworkingMessages";
+export * from "./legacy/LegacyUserNetworkingMessages";
+export * from "./DeltaNetComponentMapping";
+export * from "./UserNetworkingLogger";
+export { DeltaNetV01ServerErrors, deltaNetProtocolSubProtocol_v0_1, } from "@mml-io/delta-net-protocol";