@antha/multiplayer-p2p-lock-step 0.0.3 → 0.0.5

package/dist/p2p-lock-step-multiplayer-controller.d.ts

@@ -1,7 +1,7 @@
 import { type ApiAndRoomConnectionState, type ClientId, ControllerClientEvent, ControllerConnectionEvent, ControllerRoomListEvent, type ControllerRoomListListener, type MultiplayerInitParams, type MultiplayerRoomConnection, MultiplayerRoomController, type RoomInput, RoomRejectionError } from '@antha/multiplayer-core';
 import { type JsonCompatibleValue, type MaybePromise, type PartialWithUndefined } from '@augment-vir/common';
 import { type AnyDuration } from 'date-vir';
-import { ListenTarget, type TypedCustomEventInit } from 'typed-event-target';
+import { ListenTarget, type RemoveListenerCallback, type TypedCustomEventInit } from 'typed-event-target';
 /**
  * Message type for {@link P2pLockStepMessage}.
  *
@@ -18,7 +18,7 @@ export declare enum P2pLockStepMessageType {
  */
 export type FrameEventDetail<MultiplayerPacket extends JsonCompatibleValue> = {
     packet: MultiplayerPacket;
-    clientId: ClientId;
+    sourceClientId: ClientId;
 };
 /**
  * Message exchanged by p2p-lock-step clients.
@@ -31,7 +31,9 @@ export type P2pLockStepMessage<MultiplayerPacket extends JsonCompatibleValue> =
     type: P2pLockStepMessageType.Actions;
     sourceClientId: ClientId;
     actions: MultiplayerPacket[];
-} | {
+}
+/** Sent from the host to clients when a frame is ready. */
+ | {
     type: P2pLockStepMessageType.Frame;
     actions: FrameEventDetail<MultiplayerPacket>[];
 };
@@ -146,7 +148,9 @@ export declare class P2pLockStepMultiplayerController<MultiplayerPacket extends
      *
      * If a callback is provided, it is called each time the room list is updated.
      */
-    startRoomUpdates(callback?: ControllerRoomListListener | undefined): import("typed-event-target").RemoveListenerCallback;
+    startRoomUpdates(callback: ControllerRoomListListener): RemoveListenerCallback;
+    startRoomUpdates(callback?: undefined): undefined;
+    startRoomUpdates(callback?: ControllerRoomListListener | undefined): RemoveListenerCallback | undefined;
     /** Turn off room list updates and remove callbacks added via `startRoomUpdates`. */
     stopRoomUpdates(): void;
     /** Currently joined room id. If a room has not been joined yet, this will be empty. */
@@ -202,12 +206,13 @@ export declare class P2pLockStepMultiplayerController<MultiplayerPacket extends
     isConnected(): boolean;
     /** Cleanup everything. */
     destroy(): void;
-    /**
-     * Join or create a room.
-     *
-     * @throws `Error` if this controller is already connected to a room.
-     */
+    /** Join or create a room. */
     joinOrCreateRoom(room: Readonly<RoomInput>): Promise<void>;
+    /** Join through the core room controller while preserving the wrapper connection on failure. */
+    protected joinRoom({ previousRoomConnection, room, }: Readonly<{
+        previousRoomConnection: MultiplayerRoomConnection<P2pLockStepMessage<MultiplayerPacket>> | undefined;
+        room: Readonly<RoomInput>;
+    }>): Promise<MultiplayerRoomConnection<P2pLockStepMessage<MultiplayerPacket>>>;
     /** Leave the current room or single player connection. */
     leaveRoom(): void;
     /** Forward core room-controller events into this frame-sync controller. */

package/dist/p2p-lock-step-multiplayer-controller.js

@@ -1,7 +1,7 @@
 import { ControllerClientEvent, ControllerConnectionEvent, ControllerMessageEvent, ControllerRoomListEvent, createMultiplayerId, emptyApiAndRoomConnectionState, MultiplayerConnectionState, MultiplayerRoomController, RoomRejectionError, } from '@antha/multiplayer-core';
 import { ensureArray, log, makeWritable, } from '@augment-vir/common';
 import { convertDuration } from 'date-vir';
-import { defineTypedCustomEvent, ListenTarget } from 'typed-event-target';
+import { defineTypedCustomEvent, ListenTarget, } from 'typed-event-target';
 /**
  * Message type for {@link P2pLockStepMessage}.
  *
@@ -85,11 +85,6 @@ export class P2pLockStepMultiplayerController extends ListenTarget {
     get clientId() {
         return this.roomConnection?.clientId || this.localClientId;
     }
-    /**
-     * Listen for room list updates, including while connected to a room.
-     *
-     * If a callback is provided, it is called each time the room list is updated.
-     */
     startRoomUpdates(callback) {
         return this.roomController.startRoomUpdates(callback);
     }
@@ -203,7 +198,7 @@ export class P2pLockStepMultiplayerController extends ListenTarget {
             ...this.frameActions,
             ...actionArray.map((packet) => {
                 return {
-                    clientId: this.clientId,
+                    sourceClientId: this.clientId,
                     packet,
                 };
             }),
@@ -226,28 +221,39 @@ export class P2pLockStepMultiplayerController extends ListenTarget {
         this.roomController.destroy();
         super.destroy();
     }
-    /**
-     * Join or create a room.
-     *
-     * @throws `Error` if this controller is already connected to a room.
-     */
+    /** Join or create a room. */
     async joinOrCreateRoom(room) {
-        if (this.currentConnection) {
+        if (this.singleplayer) {
             throw new Error('Cannot join room: connection already established.');
         }
+        const previousRoomConnection = this.roomConnection;
         this.debugLog(`joining or creating room '${room.roomName}' (${room.roomId})`);
+        const roomConnection = await this.joinRoom({
+            previousRoomConnection,
+            room,
+        });
+        if (previousRoomConnection) {
+            globalThis.clearTimeout(this.timeoutId);
+            this.clientsResponded = {};
+            this.frameActions = [];
+            this.frameTickReady = true;
+        }
+        this.attachMultiplayerRoomConnection(roomConnection);
+        this.debugLog(`attached p2p-lock-step connection; client=${this.getClientId() || 'unknown'} host=${this.isHost()} connected=${this.isConnected()}`);
+    }
+    /** Join through the core room controller while preserving the wrapper connection on failure. */
+    async joinRoom({ previousRoomConnection, room, }) {
         try {
             await this.roomController.joinOrCreateRoom(room);
             this.debugLog(`room controller joined room '${room.roomName}' (${room.roomId}); client=${this.roomController.getClientId() || 'unknown'} host=${this.roomController.isHost()}`);
             if (!this.roomController.currentConnection) {
                 throw new Error('Cannot start p2p-lock-step multiplayer: room connection is missing.');
             }
-            this.attachMultiplayerRoomConnection(this.roomController.currentConnection);
-            this.debugLog(`attached p2p-lock-step connection; client=${this.getClientId() || 'unknown'} host=${this.isHost()} connected=${this.isConnected()}`);
+            return this.roomController.currentConnection;
         }
         catch (error) {
             this.debugLog(`join room failed: ${String(error)}`);
-            this.roomConnection = undefined;
+            this.roomConnection = previousRoomConnection;
             throw error;
         }
     }
@@ -327,7 +333,7 @@ export class P2pLockStepMultiplayerController extends ListenTarget {
                 ...this.frameActions,
                 ...message.actions.map((packet) => {
                     return {
-                        clientId: sourceClientId,
+                        sourceClientId,
                         packet,
                     };
                 }),

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@antha/multiplayer-p2p-lock-step",
-    "version": "0.0.3",
+    "version": "0.0.5",
     "description": "Multiplayer mod for the Antha engine.",
     "keywords": [
         "vir",
@@ -49,7 +49,7 @@
         "istanbul-smart-text-reporter": "^1.1.5"
     },
     "peerDependencies": {
-        "@antha/multiplayer-core": "^0.0.3"
+        "@antha/multiplayer-core": "^0.0.5"
     },
     "engines": {
         "node": ">=22"