@antha/multiplayer-p2p-authoritative-host 0.14.1 → 0.15.0

package/dist/antha-multiplayer-p2p-authoritative-host.mod.d.ts

@@ -9,7 +9,7 @@ import { P2pAuthoritativeHostMultiplayerController, type P2pAuthoritativeHostMul
 export type AnthaMultiplayerP2pAuthoritativeHostState<Input extends JsonCompatibleValue = any, MultiplayerGameState extends JsonCompatibleValue = any> = {
     /** P2p-authoritative-host controller state. */
     multiplayerP2pAuthoritativeHost: {
-        /** Controller used to drive singleplayer or multiplayer state sync. */
+        /** Multiplayer controller used to drive singleplayer or multiplayer state sync. */
         multiplayerController: P2pAuthoritativeHostMultiplayerController<Input, MultiplayerGameState>;
         /** Current backend API and room connection state. */
         connectionState: ApiAndRoomConnectionState;

package/dist/antha-multiplayer-p2p-authoritative-host.mod.js

@@ -1,6 +1,6 @@
 import { defineAnthaMod } from '@antha/engine';
-import { ControllerConnectionEvent, emptyApiAndRoomConnectionState, } from '@antha/multiplayer-core';
-import { ControllerStateEvent, P2pAuthoritativeHostMultiplayerController, } from './p2p-authoritative-host-multiplayer-controller.js';
+import { MultiplayerControllerConnectionEvent, emptyApiAndRoomConnectionState, } from '@antha/multiplayer-core';
+import { MultiplayerControllerStateEvent, P2pAuthoritativeHostMultiplayerController, } from './p2p-authoritative-host-multiplayer-controller.js';
 /**
  * Create the engine mod that owns p2p-authoritative-host multiplayer state.
  *
@@ -12,13 +12,13 @@ export function createAnthaMultiplayerP2pAuthoritativeHostMod(options) {
         execute({ state }) {
             if (!state.multiplayerP2pAuthoritativeHost) {
                 state.multiplayerP2pAuthoritativeHost = createP2pAuthoritativeHostState(options);
-                state.multiplayerP2pAuthoritativeHost.multiplayerController.listen(ControllerConnectionEvent, ({ detail: newConnectionState }) => {
+                state.multiplayerP2pAuthoritativeHost.multiplayerController.listen(MultiplayerControllerConnectionEvent, ({ detail: newConnectionState }) => {
                     if (!state.multiplayerP2pAuthoritativeHost) {
                         return;
                     }
                     state.multiplayerP2pAuthoritativeHost.connectionState = newConnectionState;
                 });
-                state.multiplayerP2pAuthoritativeHost.multiplayerController.listen((ControllerStateEvent), ({ detail }) => {
+                state.multiplayerP2pAuthoritativeHost.multiplayerController.listen((MultiplayerControllerStateEvent), ({ detail }) => {
                     if (!state.multiplayerP2pAuthoritativeHost) {
                         return;
                     }

package/dist/p2p-authoritative-host-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, type SocketMessageId } from '@antha/multiplayer-core';
+import { type ApiAndRoomConnectionState, type ClientId, MultiplayerControllerClientEvent, MultiplayerControllerConnectionEvent, MultiplayerControllerRoomListEvent, type MultiplayerControllerRoomListListener, type MultiplayerInitParams, type MultiplayerRoomConnection, MultiplayerRoomController, type RoomInput, RoomRejectionError, type SocketMessageId } from '@antha/multiplayer-core';
 import { type JsonCompatibleValue, type MaybePromise, type PartialWithUndefined } from '@augment-vir/common';
 import { ListenTarget, type RemoveListenerCallback, type TypedCustomEventInit } from 'typed-event-target';
 /**
@@ -24,7 +24,7 @@ export type P2pAuthoritativeHostStateSnapshot<MultiplayerGameState extends JsonC
     stateSyncId: SocketMessageId;
 }>;
 /**
- * Data received from {@link ControllerStateEvent}.
+ * Data received from {@link MultiplayerControllerStateEvent}.
  *
  * @category Internal
  */
@@ -91,27 +91,27 @@ export type P2pAuthoritativeHostMultiplayerControllerParams<Input extends JsonCo
      *
      * @default accept all connections
      */
-    acceptConnection?: ((connectingClientId: ClientId, controller: P2pAuthoritativeHostMultiplayerController<Input, MultiplayerGameState>) => MaybePromise<boolean>) | undefined;
+    acceptConnection?: ((connectingClientId: ClientId, multiplayerController: P2pAuthoritativeHostMultiplayerController<Input, MultiplayerGameState>) => MaybePromise<boolean>) | undefined;
 }>;
-declare const ControllerStateEvent_base: (new (eventInitDict: {
+declare const MultiplayerControllerStateEvent_base: (new (eventInitDict: {
     bubbles?: boolean;
     cancelable?: boolean;
     composed?: boolean;
     detail: any;
-}) => import("typed-event-target").TypedCustomEvent<any, "controller-state">) & Pick<{
+}) => import("typed-event-target").TypedCustomEvent<any, "multiplayer-controller-state">) & 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-state">, "type">;
+}, "prototype" | "NONE" | "CAPTURING_PHASE" | "AT_TARGET" | "BUBBLING_PHASE"> & Pick<import("typed-event-target").TypedCustomEvent<any, "multiplayer-controller-state">, "type">;
 /**
  * This is fired whenever the local authoritative-host state view updates.
  *
  * @category Events
  */
-export declare class ControllerStateEvent<MultiplayerGameState extends JsonCompatibleValue, Input extends JsonCompatibleValue = any> extends ControllerStateEvent_base {
+export declare class MultiplayerControllerStateEvent<MultiplayerGameState extends JsonCompatibleValue, Input extends JsonCompatibleValue = any> extends MultiplayerControllerStateEvent_base {
     detail: Readonly<StateEventDetail<Input, MultiplayerGameState>>;
     constructor(eventInitDict: TypedCustomEventInit<Readonly<StateEventDetail<Input, MultiplayerGameState>>>);
 }
@@ -120,7 +120,7 @@ export declare class ControllerStateEvent<MultiplayerGameState extends JsonCompa
  *
  * @category Internal
  */
-export type AllP2pAuthoritativeHostMultiplayerControllerEvents<Input extends JsonCompatibleValue, MultiplayerGameState extends JsonCompatibleValue> = ControllerStateEvent<MultiplayerGameState, Input> | ControllerRoomListEvent | ControllerClientEvent | ControllerConnectionEvent;
+export type AllP2pAuthoritativeHostMultiplayerControllerEvents<Input extends JsonCompatibleValue, MultiplayerGameState extends JsonCompatibleValue> = MultiplayerControllerStateEvent<MultiplayerGameState, Input> | MultiplayerControllerRoomListEvent | MultiplayerControllerClientEvent | MultiplayerControllerConnectionEvent;
 /**
  * An all-in-one controller for singleplayer or p2p-authoritative-host multiplayer game state.
  *
@@ -130,11 +130,11 @@ export declare class P2pAuthoritativeHostMultiplayerController<Input extends Jso
     protected readonly params: P2pAuthoritativeHostMultiplayerControllerParams<Input, MultiplayerGameState>;
     /** All events emitted by this controller. */
     static readonly events: {
-        ControllerStateEvent: typeof ControllerStateEvent;
+        MultiplayerControllerStateEvent: typeof MultiplayerControllerStateEvent;
     };
     /** All events emitted by this controller. */
     readonly events: {
-        ControllerStateEvent: typeof ControllerStateEvent;
+        MultiplayerControllerStateEvent: typeof MultiplayerControllerStateEvent;
     };
     static readonly knownErrors: {
         RoomRejectionError: typeof RoomRejectionError;
@@ -160,9 +160,9 @@ export declare class P2pAuthoritativeHostMultiplayerController<Input extends Jso
      *
      * 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-authoritative-host-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 { assertWrap, waitUntil } from '@augment-vir/assert';
 import { defineTypedCustomEvent, ListenTarget, } from 'typed-event-target';
 /**
@@ -17,7 +17,7 @@ export var P2pAuthoritativeHostMessageType;
  *
  * @category Events
  */
-export class ControllerStateEvent extends defineTypedCustomEvent()('controller-state') {
+export class MultiplayerControllerStateEvent extends defineTypedCustomEvent()('multiplayer-controller-state') {
     constructor(eventInitDict) {
         super(eventInitDict);
     }
@@ -31,7 +31,7 @@ export class P2pAuthoritativeHostMultiplayerController extends ListenTarget {
     params;
     /** All events emitted by this controller. */
     static events = {
-        ControllerStateEvent,
+        MultiplayerControllerStateEvent,
     };
     /** All events emitted by this controller. */
     events = P2pAuthoritativeHostMultiplayerController.events;
@@ -146,7 +146,7 @@ export class P2pAuthoritativeHostMultiplayerController extends ListenTarget {
         }
         this.singleplayer = true;
         this.dispatchState(this.createStateEventDetail());
-        this.dispatch(new ControllerConnectionEvent({
+        this.dispatch(new MultiplayerControllerConnectionEvent({
             detail: {
                 ...emptyApiAndRoomConnectionState,
                 api: MultiplayerConnectionState.Connected,
@@ -220,16 +220,16 @@ export class P2pAuthoritativeHostMultiplayerController extends ListenTarget {
     }
     /** Forward core room-controller events into this state-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.dispatch(event);
         });
-        this.roomController.listen(ControllerClientEvent, (event) => {
+        this.roomController.listen(MultiplayerControllerClientEvent, (event) => {
             this.dispatch(event);
         });
-        this.roomController.listen((ControllerMessageEvent), (event) => {
+        this.roomController.listen((MultiplayerControllerMessageEvent), (event) => {
             this.handleReceivedMessage(event.sourceClientId, event.detail);
         });
     }
@@ -345,7 +345,7 @@ export class P2pAuthoritativeHostMultiplayerController extends ListenTarget {
     }
     /** Dispatch the typed state event to local listeners. */
     dispatchState(detail) {
-        this.dispatch(new ControllerStateEvent({
+        this.dispatch(new MultiplayerControllerStateEvent({
             detail,
         }));
     }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@antha/multiplayer-p2p-authoritative-host",
-    "version": "0.14.1",
+    "version": "0.15.0",
     "description": "P2P authoritative-host multiplayer strategy for the Antha engine.",
     "keywords": [
         "vir",
@@ -36,19 +36,19 @@
         "test:docs": "virmator docs check"
     },
     "dependencies": {
-        "@augment-vir/assert": "^32.2.4",
-        "@augment-vir/common": "^32.2.4",
+        "@augment-vir/assert": "^32.3.0",
+        "@augment-vir/common": "^32.3.0",
         "typed-event-target": "^4.3.3"
     },
     "devDependencies": {
-        "@augment-vir/test": "^32.2.4",
+        "@augment-vir/test": "^32.3.0",
         "@web/dev-server-esbuild": "^2.0.0",
         "@web/test-runner": "^1.0.0",
         "@web/test-runner-playwright": "^1.0.0",
         "istanbul-smart-text-reporter": "^1.1.5"
     },
     "peerDependencies": {
-        "@antha/multiplayer-core": "^0.14.1"
+        "@antha/multiplayer-core": "^0.15.0"
     },
     "engines": {
         "node": ">=22"