@antha/multiplayer-p2p-lock-step 0.14.1 → 0.14.2

package/dist/antha-multiplayer-p2p-lock-step.mod.d.ts

@@ -11,7 +11,7 @@ export type AnthaMultiplayerP2pLockStepState<MultiplayerPacket extends JsonCompa
     debugMultiplayer?: boolean | undefined;
     /** P2p-lock-step controller state. */
     multiplayerP2pLockStep: {
-        /** Controller used to drive singleplayer or multiplayer frame sync. */
+        /** Multiplayer controller used to drive singleplayer or multiplayer frame sync. */
         multiplayerController: P2pLockStepMultiplayerController<MultiplayerPacket>;
         /** Current backend API and room connection state. */
         connectionState: ApiAndRoomConnectionState;

package/dist/antha-multiplayer-p2p-lock-step.mod.js

@@ -1,5 +1,5 @@
 import { defineAnthaMod } from '@antha/engine';
-import { ControllerConnectionEvent, emptyApiAndRoomConnectionState, } from '@antha/multiplayer-core';
+import { emptyApiAndRoomConnectionState, MultiplayerControllerConnectionEvent, } from '@antha/multiplayer-core';
 import { log, } from '@augment-vir/common';
 import { P2pLockStepMultiplayerController, } from './p2p-lock-step-multiplayer-controller.js';
 /**
@@ -25,7 +25,7 @@ export function createAnthaMultiplayerP2pLockStepMod(options = {}) {
                     }),
                     connectionState: emptyApiAndRoomConnectionState,
                 };
-                state.multiplayerP2pLockStep.multiplayerController.listen(ControllerConnectionEvent, ({ detail: newConnectionState }) => {
+                state.multiplayerP2pLockStep.multiplayerController.listen(MultiplayerControllerConnectionEvent, ({ detail: newConnectionState }) => {
                     if (!state.multiplayerP2pLockStep) {
                         return;
                     }

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

@@ -1,4 +1,4 @@
-import { type ApiAndRoomConnectionState, type ClientId, ControllerClientEvent, ControllerConnectionEvent, ControllerRoomListEvent, type ControllerRoomListListener, type MultiplayerInitParams, type MultiplayerRoomConnection, MultiplayerRoomController, type RoomInput, RoomRejectionError } from '@antha/multiplayer-core';
+import { type ApiAndRoomConnectionState, type ClientId, MultiplayerControllerClientEvent, MultiplayerControllerConnectionEvent, MultiplayerControllerRoomListEvent, type MultiplayerControllerRoomListListener, 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 RemoveListenerCallback, type TypedCustomEventInit } from 'typed-event-target';
@@ -12,7 +12,7 @@ export declare enum P2pLockStepMessageType {
     Frame = "frame"
 }
 /**
- * Data received from {@link ControllerFrameEvent}.
+ * Data received from {@link MultiplayerControllerFrameEvent}.
  *
  * @category Internal
  */
@@ -56,7 +56,7 @@ export type P2pLockStepMultiplayerControllerParams<Action extends JsonCompatible
      *
      * @default accept all connections
      */
-    acceptConnection?: ((connectingClientId: ClientId, controller: P2pLockStepMultiplayerController<Action>) => MaybePromise<boolean>) | undefined;
+    acceptConnection?: ((connectingClientId: ClientId, multiplayerController: P2pLockStepMultiplayerController<Action>) => MaybePromise<boolean>) | undefined;
     /** Enables verbose multiplayer debug logs. */
     debugMultiplayer?: boolean | undefined;
     /**
@@ -67,25 +67,25 @@ export type P2pLockStepMultiplayerControllerParams<Action extends JsonCompatible
      */
     frameDuration?: AnyDuration | undefined;
 }>;
-declare const ControllerFrameEvent_base: (new (eventInitDict: {
+declare const MultiplayerControllerFrameEvent_base: (new (eventInitDict: {
     bubbles?: boolean;
     cancelable?: boolean;
     composed?: boolean;
     detail: any;
-}) => import("typed-event-target").TypedCustomEvent<any, "controller-frame">) & Pick<{
+}) => import("typed-event-target").TypedCustomEvent<any, "multiplayer-controller-frame">) & Pick<{
     new (type: string, eventInitDict?: EventInit): Event;
     prototype: Event;
     readonly NONE: 0;
     readonly CAPTURING_PHASE: 1;
     readonly AT_TARGET: 2;
     readonly BUBBLING_PHASE: 3;
-}, "prototype" | "NONE" | "CAPTURING_PHASE" | "AT_TARGET" | "BUBBLING_PHASE"> & Pick<import("typed-event-target").TypedCustomEvent<any, "controller-frame">, "type">;
+}, "prototype" | "NONE" | "CAPTURING_PHASE" | "AT_TARGET" | "BUBBLING_PHASE"> & Pick<import("typed-event-target").TypedCustomEvent<any, "multiplayer-controller-frame">, "type">;
 /**
  * This is fired whenever a new p2p-lock-step frame is received from the host client.
  *
  * @category Events
  */
-export declare class ControllerFrameEvent<MultiplayerPacket extends JsonCompatibleValue> extends ControllerFrameEvent_base {
+export declare class MultiplayerControllerFrameEvent<MultiplayerPacket extends JsonCompatibleValue> extends MultiplayerControllerFrameEvent_base {
     detail: ReadonlyArray<FrameEventDetail<MultiplayerPacket>>;
     constructor(eventInitDict: TypedCustomEventInit<ReadonlyArray<FrameEventDetail<MultiplayerPacket>>>);
 }
@@ -94,13 +94,13 @@ export declare class ControllerFrameEvent<MultiplayerPacket extends JsonCompatib
  *
  * @category Internal
  */
-export type AllP2pLockStepMultiplayerControllerEvents<MultiplayerPacket extends JsonCompatibleValue> = ControllerFrameEvent<MultiplayerPacket> | ControllerRoomListEvent | ControllerClientEvent | ControllerConnectionEvent;
+export type AllP2pLockStepMultiplayerControllerEvents<MultiplayerPacket extends JsonCompatibleValue> = MultiplayerControllerFrameEvent<MultiplayerPacket> | MultiplayerControllerRoomListEvent | MultiplayerControllerClientEvent | MultiplayerControllerConnectionEvent;
 /**
  * Listener callback for p2p-lock-step frame events.
  *
  * @category Internal
  */
-export type ControllerFrameListener<MultiplayerPacket extends JsonCompatibleValue> = (event: Readonly<ControllerFrameEvent<MultiplayerPacket>>) => MaybePromise<void>;
+export type MultiplayerControllerFrameListener<MultiplayerPacket extends JsonCompatibleValue> = (event: Readonly<MultiplayerControllerFrameEvent<MultiplayerPacket>>) => MaybePromise<void>;
 /**
  * An all-in-one controller for singleplayer or p2p-lock-step multiplayer game state.
  *
@@ -112,11 +112,11 @@ export declare class P2pLockStepMultiplayerController<MultiplayerPacket extends
     readonly currentFps: number;
     /** All events emitted by this controller. */
     static readonly events: {
-        ControllerFrameEvent: typeof ControllerFrameEvent;
+        MultiplayerControllerFrameEvent: typeof MultiplayerControllerFrameEvent;
     };
     /** All events emitted by this controller. */
     readonly events: {
-        ControllerFrameEvent: typeof ControllerFrameEvent;
+        MultiplayerControllerFrameEvent: typeof MultiplayerControllerFrameEvent;
     };
     static readonly knownErrors: {
         RoomRejectionError: typeof RoomRejectionError;
@@ -149,9 +149,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): RemoveListenerCallback;
+    startRoomUpdates(callback: MultiplayerControllerRoomListListener): RemoveListenerCallback;
     startRoomUpdates(callback?: undefined): undefined;
-    startRoomUpdates(callback?: ControllerRoomListListener | undefined): RemoveListenerCallback | undefined;
+    startRoomUpdates(callback?: MultiplayerControllerRoomListListener | 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. */

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

@@ -1,4 +1,4 @@
-import { ControllerClientEvent, ControllerConnectionEvent, ControllerMessageEvent, ControllerRoomListEvent, createMultiplayerId, emptyApiAndRoomConnectionState, MultiplayerConnectionState, MultiplayerRoomController, RoomRejectionError, } from '@antha/multiplayer-core';
+import { createMultiplayerId, emptyApiAndRoomConnectionState, MultiplayerConnectionState, MultiplayerControllerClientEvent, MultiplayerControllerConnectionEvent, MultiplayerControllerMessageEvent, MultiplayerControllerRoomListEvent, 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';
@@ -17,7 +17,7 @@ export var P2pLockStepMessageType;
  *
  * @category Events
  */
-export class ControllerFrameEvent extends defineTypedCustomEvent()('controller-frame') {
+export class MultiplayerControllerFrameEvent extends defineTypedCustomEvent()('multiplayer-controller-frame') {
     constructor(eventInitDict) {
         super(eventInitDict);
     }
@@ -36,7 +36,7 @@ export class P2pLockStepMultiplayerController extends ListenTarget {
     currentFps = 0;
     /** All events emitted by this controller. */
     static events = {
-        ControllerFrameEvent,
+        MultiplayerControllerFrameEvent,
     };
     /** All events emitted by this controller. */
     events = P2pLockStepMultiplayerController.events;
@@ -159,7 +159,7 @@ export class P2pLockStepMultiplayerController extends ListenTarget {
         this.debugLog('starting singleplayer connection');
         this.singleplayer = true;
         this.finishFrame();
-        this.dispatch(new ControllerConnectionEvent({
+        this.dispatch(new MultiplayerControllerConnectionEvent({
             detail: {
                 ...emptyApiAndRoomConnectionState,
                 api: MultiplayerConnectionState.Connected,
@@ -282,14 +282,14 @@ export class P2pLockStepMultiplayerController extends ListenTarget {
     }
     /** Forward core room-controller events into this frame-sync controller. */
     listenToRoomController() {
-        this.roomController.listen(ControllerRoomListEvent, (event) => {
+        this.roomController.listen(MultiplayerControllerRoomListEvent, (event) => {
             this.dispatch(event);
         });
-        this.roomController.listen(ControllerConnectionEvent, (event) => {
+        this.roomController.listen(MultiplayerControllerConnectionEvent, (event) => {
             this.debugLog(`connection event received: api=${String(event.detail.api)} room=${String(event.detail.room)}`);
             this.dispatch(event);
         });
-        this.roomController.listen(ControllerClientEvent, (event) => {
+        this.roomController.listen(MultiplayerControllerClientEvent, (event) => {
             this.debugLog(`client event received: ${JSON.stringify(event.detail)}`);
             if ('newMember' in event.detail) {
                 this.syncNewMember(event.detail.newMember);
@@ -299,7 +299,7 @@ export class P2pLockStepMultiplayerController extends ListenTarget {
             }
             this.dispatch(event);
         });
-        this.roomController.listen((ControllerMessageEvent), (event) => {
+        this.roomController.listen((MultiplayerControllerMessageEvent), (event) => {
             this.debugLog(`message event received from ${event.sourceClientId}: type=${event.detail.type}`);
             this.handleReceivedMessage(event.sourceClientId, event.detail);
         });
@@ -379,7 +379,7 @@ export class P2pLockStepMultiplayerController extends ListenTarget {
                 sourceClientId: this.clientId,
                 type: P2pLockStepMessageType.Actions,
             });
-            this.dispatch(new ControllerFrameEvent({
+            this.dispatch(new MultiplayerControllerFrameEvent({
                 detail: message.actions,
             }));
         }
@@ -410,7 +410,7 @@ export class P2pLockStepMultiplayerController extends ListenTarget {
             type: P2pLockStepMessageType.Frame,
             actions: currentFrameActions,
         });
-        this.dispatch(new ControllerFrameEvent({
+        this.dispatch(new MultiplayerControllerFrameEvent({
             detail: currentFrameActions,
         }));
         this.frameTickReady = false;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@antha/multiplayer-p2p-lock-step",
-    "version": "0.14.1",
+    "version": "0.14.2",
     "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.14.1"
+        "@antha/multiplayer-core": "^0.14.2"
     },
     "engines": {
         "node": ">=22"