@needle-tools/engine 4.7.0-alpha → 4.7.0-next.da47826

package/lib/engine-components-experimental/networking/PlayerSync.js

@@ -1,378 +1,378 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-import { Object3D } from "three";
-import { AssetReference } from "../../engine/engine_addressables.js";
-import { RoomEvents } from "../../engine/engine_networking.js";
-import { syncField } from "../../engine/engine_networking_auto.js";
-import { syncDestroy } from "../../engine/engine_networking_instantiate.js";
-import { serializable } from "../../engine/engine_serialization_decorator.js";
-import { delay, getParam } from "../../engine/engine_utils.js";
-import { Behaviour, Component, GameObject } from "../../engine-components/Component.js";
-import { EventList } from "../../engine-components/EventList.js";
-const debug = getParam("debugplayersync");
-/**
- * This component instantiates an asset for each player that joins a networked room. The asset will be destroyed when the player leaves the room.
- * The asset should have a PlayerState component, and can have other components like SyncedTransform, custom components, etc.
- * @category Networking
- */
-export class PlayerSync extends Behaviour {
-    /**
-     * This API is experimental and may change or be removed in the future.
-     * Creates a PlayerSync instance at runtime from a given URL and sets it up for networking
-     * @param url Path to the asset that should be instantiated for each player
-     * @param init Optional initialization parameters for the PlayerSync component
-     * @returns Promise resolving to a PlayerSync instance with a guaranteed asset property
-     * @example
-     * ```typescript
-     * const res = await PlayerSync.setupFrom("/assets/demo.glb");
-     * addComponent(res.asset?.asset, DragControls);
-     * addComponent(res.asset?.asset, SyncedTransform);
-     * scene.add(res.gameObject);
-     * ```
-     */
-    static async setupFrom(url, init) {
-        const assetReference = AssetReference.getOrCreateFromUrl(url);
-        if (!assetReference.asset) {
-            const i = await assetReference.loadAssetAsync();
-            if (i)
-                GameObject.getOrAddComponent(i, PlayerState);
-        }
-        const ps = new PlayerSync();
-        ps._internalInit(init);
-        ps.asset = assetReference;
-        const obj = new Object3D();
-        obj["guid"] = url;
-        GameObject.addComponent(obj, ps);
-        return ps;
-    }
-    /**
-     * When enabled, PlayerSync will automatically load and instantiate the assigned asset when joining a networked room
-     */
-    autoSync = true;
-    /**
-     * The asset that will be loaded and instantiated when PlayerSync becomes active and joins a networked room
-     */
-    asset;
-    /**
-     * Event invoked when a player instance is spawned with the spawned {@link Object3D} as parameter
-     * @serializable
-     */
-    onPlayerSpawned;
-    _localInstance;
-    awake() {
-        this.watchTabVisible();
-        if (!this.onPlayerSpawned)
-            this.onPlayerSpawned = new EventList();
-    }
-    onEnable() {
-        this.context.connection.beginListen(RoomEvents.RoomStateSent, this.onJoinedRoom);
-        this.context.connection.beginListen(RoomEvents.JoinedRoom, this.onJoinedRoom);
-        this.context.connection.beginListen(RoomEvents.LeftRoom, this.destroyInstance);
-        if (this.context.connection.isInRoom) {
-            this.onJoinedRoom();
-        }
-    }
-    onDisable() {
-        this.context.connection.stopListen(RoomEvents.RoomStateSent, this.onJoinedRoom);
-        this.context.connection.stopListen(RoomEvents.JoinedRoom, this.onJoinedRoom);
-        this.context.connection.stopListen(RoomEvents.LeftRoom, this.destroyInstance);
-    }
-    onJoinedRoom = () => {
-        if (debug)
-            console.log("PlayerSync.joinedRoom. autoSync is set to " + this.autoSync);
-        if (this.autoSync)
-            this.getInstance();
-    };
-    /**
-     * Gets or creates an instance of the assigned asset for the local player
-     * @returns Promise resolving to the instantiated player object or null if creation failed
-     */
-    async getInstance() {
-        if (this._localInstance)
-            return this._localInstance;
-        if (debug)
-            console.log("PlayerSync.createInstance", this.asset?.url);
-        if (!this.asset?.asset && !this.asset?.url) {
-            console.error("PlayerSync: can not create an instance because \"asset\" is not set and or has no URL!");
-            return null;
-        }
-        if (!this.gameObject.guid) {
-            console.warn("PlayerSync: gameObject has no guid! This might cause issues with syncing the player state.");
-        }
-        this._localInstance = this.asset?.instantiateSynced({ parent: this.gameObject, deleteOnDisconnect: true }, true);
-        const instance = await this._localInstance;
-        if (instance) {
-            const pl = GameObject.getComponentsInChildren(instance, PlayerState);
-            if (debug)
-                console.log(`PlayerSync.createInstance: found ${pl?.length} PlayerState components. Owner: ${this.context.connection.connectionId}`);
-            if (pl?.length) {
-                for (const state of pl)
-                    state.owner = this.context.connection.connectionId;
-                this.onPlayerSpawned?.invoke(instance);
-            }
-            else {
-                this._localInstance = undefined;
-                console.error("<strong>Failed finding PlayerState on " + this.asset?.url + "</strong>: please make sure the asset has a PlayerState component!");
-                GameObject.destroySynced(instance);
-            }
-        }
-        else {
-            this._localInstance = undefined;
-            console.warn("PlayerSync: failed instantiating asset!");
-        }
-        return this._localInstance;
-    }
-    /**
-     * Destroys the current player instance and cleans up networking state
-     */
-    destroyInstance = () => {
-        this._localInstance?.then(go => {
-            if (debug)
-                console.log("PlayerSync.destroyInstance", go);
-            syncDestroy(go, this.context.connection, true, { saveInRoom: false });
-        });
-        this._localInstance = undefined;
-    };
-    /**
-     * Sets up visibility change listeners to handle player cleanup when browser tab visibility changes
-     */
-    watchTabVisible() {
-        window.addEventListener("visibilitychange", _ => {
-            if (document.visibilityState === "visible") {
-                for (let i = PlayerState.all.length - 1; i >= 0; i--) {
-                    const pl = PlayerState.all[i];
-                    if (!pl.owner || !this.context.connection.userIsInRoom(pl.owner)) {
-                        pl.doDestroy();
-                    }
-                }
-            }
-        });
-    }
-}
-__decorate([
-    serializable()
-], PlayerSync.prototype, "autoSync", void 0);
-__decorate([
-    serializable(AssetReference)
-], PlayerSync.prototype, "asset", void 0);
-__decorate([
-    serializable(EventList)
-], PlayerSync.prototype, "onPlayerSpawned", void 0);
-/**
- * Enum defining events that can be triggered by PlayerState
- */
-export var PlayerStateEvent;
-(function (PlayerStateEvent) {
-    /** Triggered when a PlayerState's owner property changes */
-    PlayerStateEvent["OwnerChanged"] = "ownerChanged";
-})(PlayerStateEvent || (PlayerStateEvent = {}));
-/**
- * Represents a player instance in the networked environment.
- * Handles ownership, synchronization, and lifecycle management of player objects.
- */
-export class PlayerState extends Behaviour {
-    static _all = [];
-    /** All PlayerState instances for all players in the scene */
-    static get all() {
-        return PlayerState._all;
-    }
-    ;
-    static _local = [];
-    /** All PlayerState instances that belong to the local player */
-    static get local() {
-        return PlayerState._local;
-    }
-    /**
-     * Gets the PlayerState component for a given object or component
-     * @param obj Object3D or Component to find the PlayerState for
-     * @returns The PlayerState component if found, undefined otherwise
-     */
-    static getFor(obj) {
-        if (obj instanceof Object3D) {
-            return GameObject.getComponentInParent(obj, PlayerState);
-        }
-        else if (obj instanceof Component) {
-            return GameObject.getComponentInParent(obj.gameObject, PlayerState);
-        }
-        return undefined;
-    }
-    /**
-     * Checks if a given object or component belongs to the local player
-     * @param obj Object3D or Component to check
-     * @returns True if the object belongs to the local player, false otherwise
-     */
-    static isLocalPlayer(obj) {
-        const state = PlayerState.getFor(obj);
-        return state?.isLocalPlayer ?? false;
-    }
-    static _callbacks = {};
-    /**
-     * Registers a callback for a specific PlayerState event
-     * @param event The event to listen for
-     * @param cb Callback function that will be invoked when the event occurs
-     * @returns The provided callback function for chaining
-     */
-    static addEventListener(event, cb) {
-        if (!this._callbacks[event])
-            this._callbacks[event] = [];
-        this._callbacks[event].push(cb);
-        return cb;
-    }
-    /**
-     * Removes a previously registered event callback
-     * @param event The event type to remove the callback from
-     * @param cb The callback function to remove
-     */
-    static removeEventListener(event, cb) {
-        if (!this._callbacks[event])
-            return;
-        const index = this._callbacks[event].indexOf(cb);
-        if (index >= 0)
-            this._callbacks[event].splice(index, 1);
-    }
-    static dispatchEvent(event, args) {
-        if (!this._callbacks[event])
-            return;
-        for (const cb of this._callbacks[event]) {
-            cb(args);
-        }
-    }
-    /** Event triggered when the owner of this PlayerState changes */
-    onOwnerChangeEvent = new EventList();
-    /** Event triggered the first time an owner is assigned to this PlayerState */
-    onFirstOwnerChangeEvent = new EventList();
-    /** Indicates if this PlayerState has an owner assigned */
-    hasOwner = false;
-    /**
-     * The connection ID of the player who owns this PlayerState instance
-     * @syncField Synchronized across the network
-     */
-    owner;
-    /**
-     * When enabled, PlayerState will not destroy itself when the owner is not connected anymore
-     */
-    dontDestroy = false;
-    /**
-     * Indicates if this PlayerState belongs to the local player
-     */
-    get isLocalPlayer() {
-        return this.owner === this.context.connection.connectionId;
-    }
-    /**
-     * Handles owner change events and updates relevant state
-     * @param newOwner The new owner's connection ID
-     * @param oldOwner The previous owner's connection ID
-     */
-    onOwnerChange(newOwner, oldOwner) {
-        if (debug)
-            console.log(`PlayerSync.onOwnerChange: ${oldOwner} → ${newOwner} (me: ${this.context.connection.connectionId})`);
-        // Remove from local owner array if it was local before
-        const index = PlayerState._local.indexOf(this);
-        if (index >= 0)
-            PlayerState._local.splice(index, 1);
-        // Args to use for dispatching events
-        const detail = {
-            playerState: this,
-            oldValue: oldOwner,
-            newValue: newOwner
-        };
-        // call local events
-        if (!this.hasOwner) {
-            this.hasOwner = true;
-            this.onFirstOwnerChangeEvent?.invoke(detail);
-        }
-        this.onOwnerChangeEvent?.invoke(detail);
-        // call remote events
-        if (this.owner === this.context.connection.connectionId) {
-            PlayerState._local.push(this);
-            // console.warn(this.gameObject.guid, this.guid, this.owner, this.isLocalPlayer, PlayerState.isLocalPlayer(this));
-            const evt = new CustomEvent("local-owner-changed", { detail: detail });
-            this.dispatchEvent(evt);
-        }
-        const evt = new CustomEvent("owner-changed", { detail: detail });
-        this.dispatchEvent(evt);
-        PlayerState.dispatchEvent(PlayerStateEvent.OwnerChanged, evt);
-    }
-    /** @internal */
-    awake() {
-        PlayerState.all.push(this);
-        if (debug)
-            console.log("Registered new PlayerState", this.guid, PlayerState.all.length - 1, PlayerState.all);
-        this.context.connection.beginListen(RoomEvents.UserLeftRoom, this.onUserLeftRoom);
-    }
-    /** @internal */
-    async start() {
-        if (debug)
-            console.log("PLAYERSTATE.START, owner: " + this.owner, this.context.connection.usersInRoom([]));
-        // If a player is spawned but not in the room anymore we want to destroy it
-        // this might happen in a case where all users get disconnected at once and the server 
-        // still has the syncInstantiate messages that are sent to all clients
-        if (this.owner) {
-            // a slight delay is necessary right now because the syncInstantiate call might has created this object already with the owner assigned but the user has not yet joined the room
-            if (!this.context.connection.isInRoom)
-                await delay(300);
-            if (this.context.connection.userIsInRoom(this.owner) == false) {
-                if (debug)
-                    console.log(`PlayerSync.start → doDestroy \"${this.name}\" because user \"${this.owner}\" is not in room anymore...`, "Currently in room:", ...this.context.connection.usersInRoom());
-                this.doDestroy();
-            }
-        }
-        else if (!this.owner) {
-            if (debug)
-                console.warn("PlayerState.start → owner is undefined!", this.name);
-            // we can delete it here immediately because it is not synced anymore or the owner has left the room
-            // we could also do this in a timeout and check if the owner is still not assigned after a second (but that would be a hack)
-            setTimeout(() => {
-                if (!this.destroyed && !this.owner) {
-                    if (!this.dontDestroy) {
-                        if (debug)
-                            console.warn(`PlayerState.start → owner is still undefined: destroying \"${this.name}\" instance now`);
-                        this.doDestroy();
-                    }
-                    else if (debug)
-                        console.warn("PlayerState.start → owner is still undefined but dontDestroy is set to true", this.name);
-                }
-                else if (debug)
-                    console.log("PlayerState.start → owner is assigned", this.owner);
-            }, 2000);
-        }
-    }
-    /** Tells the server that this client has been destroyed, and the networking message for the instantiate will be removed      */
-    doDestroy() {
-        if (debug)
-            console.log("PlayerSync.doDestroy → syncDestroy", this.name);
-        syncDestroy(this.gameObject, this.context.connection, true, { saveInRoom: false });
-    }
-    /** @internal */
-    onDestroy() {
-        if (debug)
-            console.warn("PlayerState.onDestroy", this.owner);
-        this.context.connection.stopListen(RoomEvents.UserLeftRoom, this.onUserLeftRoom);
-        PlayerState.all.splice(PlayerState.all.indexOf(this), 1);
-        if (this.isLocalPlayer) {
-            const index = PlayerState._local.indexOf(this);
-            if (index >= 0)
-                PlayerState._local.splice(index, 1);
-        }
-    }
-    /**
-     * Handler for when a user leaves the networked room
-     * @param model Object containing the ID of the user who left
-     */
-    onUserLeftRoom = (model) => {
-        if (model.userId === this.owner) {
-            if (debug)
-                console.log("PLAYERSYNC LEFT", this.owner);
-            this.doDestroy();
-            return;
-        }
-    };
-}
-__decorate([
-    syncField(PlayerState.prototype.onOwnerChange)
-], PlayerState.prototype, "owner", void 0);
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Object3D } from "three";
+import { AssetReference } from "../../engine/engine_addressables.js";
+import { RoomEvents } from "../../engine/engine_networking.js";
+import { syncField } from "../../engine/engine_networking_auto.js";
+import { syncDestroy } from "../../engine/engine_networking_instantiate.js";
+import { serializable } from "../../engine/engine_serialization_decorator.js";
+import { delay, getParam } from "../../engine/engine_utils.js";
+import { Behaviour, Component, GameObject } from "../../engine-components/Component.js";
+import { EventList } from "../../engine-components/EventList.js";
+const debug = getParam("debugplayersync");
+/**
+ * This component instantiates an asset for each player that joins a networked room. The asset will be destroyed when the player leaves the room.
+ * The asset should have a PlayerState component, and can have other components like SyncedTransform, custom components, etc.
+ * @category Networking
+ */
+export class PlayerSync extends Behaviour {
+    /**
+     * This API is experimental and may change or be removed in the future.
+     * Creates a PlayerSync instance at runtime from a given URL and sets it up for networking
+     * @param url Path to the asset that should be instantiated for each player
+     * @param init Optional initialization parameters for the PlayerSync component
+     * @returns Promise resolving to a PlayerSync instance with a guaranteed asset property
+     * @example
+     * ```typescript
+     * const res = await PlayerSync.setupFrom("/assets/demo.glb");
+     * addComponent(res.asset?.asset, DragControls);
+     * addComponent(res.asset?.asset, SyncedTransform);
+     * scene.add(res.gameObject);
+     * ```
+     */
+    static async setupFrom(url, init) {
+        const assetReference = AssetReference.getOrCreateFromUrl(url);
+        if (!assetReference.asset) {
+            const i = await assetReference.loadAssetAsync();
+            if (i)
+                GameObject.getOrAddComponent(i, PlayerState);
+        }
+        const ps = new PlayerSync();
+        ps._internalInit(init);
+        ps.asset = assetReference;
+        const obj = new Object3D();
+        obj["guid"] = url;
+        GameObject.addComponent(obj, ps);
+        return ps;
+    }
+    /**
+     * When enabled, PlayerSync will automatically load and instantiate the assigned asset when joining a networked room
+     */
+    autoSync = true;
+    /**
+     * The asset that will be loaded and instantiated when PlayerSync becomes active and joins a networked room
+     */
+    asset;
+    /**
+     * Event invoked when a player instance is spawned with the spawned {@link Object3D} as parameter
+     * @serializable
+     */
+    onPlayerSpawned;
+    _localInstance;
+    awake() {
+        this.watchTabVisible();
+        if (!this.onPlayerSpawned)
+            this.onPlayerSpawned = new EventList();
+    }
+    onEnable() {
+        this.context.connection.beginListen(RoomEvents.RoomStateSent, this.onJoinedRoom);
+        this.context.connection.beginListen(RoomEvents.JoinedRoom, this.onJoinedRoom);
+        this.context.connection.beginListen(RoomEvents.LeftRoom, this.destroyInstance);
+        if (this.context.connection.isInRoom) {
+            this.onJoinedRoom();
+        }
+    }
+    onDisable() {
+        this.context.connection.stopListen(RoomEvents.RoomStateSent, this.onJoinedRoom);
+        this.context.connection.stopListen(RoomEvents.JoinedRoom, this.onJoinedRoom);
+        this.context.connection.stopListen(RoomEvents.LeftRoom, this.destroyInstance);
+    }
+    onJoinedRoom = () => {
+        if (debug)
+            console.log("PlayerSync.joinedRoom. autoSync is set to " + this.autoSync);
+        if (this.autoSync)
+            this.getInstance();
+    };
+    /**
+     * Gets or creates an instance of the assigned asset for the local player
+     * @returns Promise resolving to the instantiated player object or null if creation failed
+     */
+    async getInstance() {
+        if (this._localInstance)
+            return this._localInstance;
+        if (debug)
+            console.log("PlayerSync.createInstance", this.asset?.url);
+        if (!this.asset?.asset && !this.asset?.url) {
+            console.error("PlayerSync: can not create an instance because \"asset\" is not set and or has no URL!");
+            return null;
+        }
+        if (!this.gameObject.guid) {
+            console.warn("PlayerSync: gameObject has no guid! This might cause issues with syncing the player state.");
+        }
+        this._localInstance = this.asset?.instantiateSynced({ parent: this.gameObject, deleteOnDisconnect: true }, true);
+        const instance = await this._localInstance;
+        if (instance) {
+            const pl = GameObject.getComponentsInChildren(instance, PlayerState);
+            if (debug)
+                console.log(`PlayerSync.createInstance: found ${pl?.length} PlayerState components. Owner: ${this.context.connection.connectionId}`);
+            if (pl?.length) {
+                for (const state of pl)
+                    state.owner = this.context.connection.connectionId;
+                this.onPlayerSpawned?.invoke(instance);
+            }
+            else {
+                this._localInstance = undefined;
+                console.error("<strong>Failed finding PlayerState on " + this.asset?.url + "</strong>: please make sure the asset has a PlayerState component!");
+                GameObject.destroySynced(instance);
+            }
+        }
+        else {
+            this._localInstance = undefined;
+            console.warn("PlayerSync: failed instantiating asset!");
+        }
+        return this._localInstance;
+    }
+    /**
+     * Destroys the current player instance and cleans up networking state
+     */
+    destroyInstance = () => {
+        this._localInstance?.then(go => {
+            if (debug)
+                console.log("PlayerSync.destroyInstance", go);
+            syncDestroy(go, this.context.connection, true, { saveInRoom: false });
+        });
+        this._localInstance = undefined;
+    };
+    /**
+     * Sets up visibility change listeners to handle player cleanup when browser tab visibility changes
+     */
+    watchTabVisible() {
+        window.addEventListener("visibilitychange", _ => {
+            if (document.visibilityState === "visible") {
+                for (let i = PlayerState.all.length - 1; i >= 0; i--) {
+                    const pl = PlayerState.all[i];
+                    if (!pl.owner || !this.context.connection.userIsInRoom(pl.owner)) {
+                        pl.doDestroy();
+                    }
+                }
+            }
+        });
+    }
+}
+__decorate([
+    serializable()
+], PlayerSync.prototype, "autoSync", void 0);
+__decorate([
+    serializable(AssetReference)
+], PlayerSync.prototype, "asset", void 0);
+__decorate([
+    serializable(EventList)
+], PlayerSync.prototype, "onPlayerSpawned", void 0);
+/**
+ * Enum defining events that can be triggered by PlayerState
+ */
+export var PlayerStateEvent;
+(function (PlayerStateEvent) {
+    /** Triggered when a PlayerState's owner property changes */
+    PlayerStateEvent["OwnerChanged"] = "ownerChanged";
+})(PlayerStateEvent || (PlayerStateEvent = {}));
+/**
+ * Represents a player instance in the networked environment.
+ * Handles ownership, synchronization, and lifecycle management of player objects.
+ */
+export class PlayerState extends Behaviour {
+    static _all = [];
+    /** All PlayerState instances for all players in the scene */
+    static get all() {
+        return PlayerState._all;
+    }
+    ;
+    static _local = [];
+    /** All PlayerState instances that belong to the local player */
+    static get local() {
+        return PlayerState._local;
+    }
+    /**
+     * Gets the PlayerState component for a given object or component
+     * @param obj Object3D or Component to find the PlayerState for
+     * @returns The PlayerState component if found, undefined otherwise
+     */
+    static getFor(obj) {
+        if (obj instanceof Object3D) {
+            return GameObject.getComponentInParent(obj, PlayerState);
+        }
+        else if (obj instanceof Component) {
+            return GameObject.getComponentInParent(obj.gameObject, PlayerState);
+        }
+        return undefined;
+    }
+    /**
+     * Checks if a given object or component belongs to the local player
+     * @param obj Object3D or Component to check
+     * @returns True if the object belongs to the local player, false otherwise
+     */
+    static isLocalPlayer(obj) {
+        const state = PlayerState.getFor(obj);
+        return state?.isLocalPlayer ?? false;
+    }
+    static _callbacks = {};
+    /**
+     * Registers a callback for a specific PlayerState event
+     * @param event The event to listen for
+     * @param cb Callback function that will be invoked when the event occurs
+     * @returns The provided callback function for chaining
+     */
+    static addEventListener(event, cb) {
+        if (!this._callbacks[event])
+            this._callbacks[event] = [];
+        this._callbacks[event].push(cb);
+        return cb;
+    }
+    /**
+     * Removes a previously registered event callback
+     * @param event The event type to remove the callback from
+     * @param cb The callback function to remove
+     */
+    static removeEventListener(event, cb) {
+        if (!this._callbacks[event])
+            return;
+        const index = this._callbacks[event].indexOf(cb);
+        if (index >= 0)
+            this._callbacks[event].splice(index, 1);
+    }
+    static dispatchEvent(event, args) {
+        if (!this._callbacks[event])
+            return;
+        for (const cb of this._callbacks[event]) {
+            cb(args);
+        }
+    }
+    /** Event triggered when the owner of this PlayerState changes */
+    onOwnerChangeEvent = new EventList();
+    /** Event triggered the first time an owner is assigned to this PlayerState */
+    onFirstOwnerChangeEvent = new EventList();
+    /** Indicates if this PlayerState has an owner assigned */
+    hasOwner = false;
+    /**
+     * The connection ID of the player who owns this PlayerState instance
+     * @syncField Synchronized across the network
+     */
+    owner;
+    /**
+     * When enabled, PlayerState will not destroy itself when the owner is not connected anymore
+     */
+    dontDestroy = false;
+    /**
+     * Indicates if this PlayerState belongs to the local player
+     */
+    get isLocalPlayer() {
+        return this.owner === this.context.connection.connectionId;
+    }
+    /**
+     * Handles owner change events and updates relevant state
+     * @param newOwner The new owner's connection ID
+     * @param oldOwner The previous owner's connection ID
+     */
+    onOwnerChange(newOwner, oldOwner) {
+        if (debug)
+            console.log(`PlayerSync.onOwnerChange: ${oldOwner} → ${newOwner} (me: ${this.context.connection.connectionId})`);
+        // Remove from local owner array if it was local before
+        const index = PlayerState._local.indexOf(this);
+        if (index >= 0)
+            PlayerState._local.splice(index, 1);
+        // Args to use for dispatching events
+        const detail = {
+            playerState: this,
+            oldValue: oldOwner,
+            newValue: newOwner
+        };
+        // call local events
+        if (!this.hasOwner) {
+            this.hasOwner = true;
+            this.onFirstOwnerChangeEvent?.invoke(detail);
+        }
+        this.onOwnerChangeEvent?.invoke(detail);
+        // call remote events
+        if (this.owner === this.context.connection.connectionId) {
+            PlayerState._local.push(this);
+            // console.warn(this.gameObject.guid, this.guid, this.owner, this.isLocalPlayer, PlayerState.isLocalPlayer(this));
+            const evt = new CustomEvent("local-owner-changed", { detail: detail });
+            this.dispatchEvent(evt);
+        }
+        const evt = new CustomEvent("owner-changed", { detail: detail });
+        this.dispatchEvent(evt);
+        PlayerState.dispatchEvent(PlayerStateEvent.OwnerChanged, evt);
+    }
+    /** @internal */
+    awake() {
+        PlayerState.all.push(this);
+        if (debug)
+            console.log("Registered new PlayerState", this.guid, PlayerState.all.length - 1, PlayerState.all);
+        this.context.connection.beginListen(RoomEvents.UserLeftRoom, this.onUserLeftRoom);
+    }
+    /** @internal */
+    async start() {
+        if (debug)
+            console.log("PLAYERSTATE.START, owner: " + this.owner, this.context.connection.usersInRoom([]));
+        // If a player is spawned but not in the room anymore we want to destroy it
+        // this might happen in a case where all users get disconnected at once and the server 
+        // still has the syncInstantiate messages that are sent to all clients
+        if (this.owner) {
+            // a slight delay is necessary right now because the syncInstantiate call might has created this object already with the owner assigned but the user has not yet joined the room
+            if (!this.context.connection.isInRoom)
+                await delay(300);
+            if (this.context.connection.userIsInRoom(this.owner) == false) {
+                if (debug)
+                    console.log(`PlayerSync.start → doDestroy \"${this.name}\" because user \"${this.owner}\" is not in room anymore...`, "Currently in room:", ...this.context.connection.usersInRoom());
+                this.doDestroy();
+            }
+        }
+        else if (!this.owner) {
+            if (debug)
+                console.warn("PlayerState.start → owner is undefined!", this.name);
+            // we can delete it here immediately because it is not synced anymore or the owner has left the room
+            // we could also do this in a timeout and check if the owner is still not assigned after a second (but that would be a hack)
+            setTimeout(() => {
+                if (!this.destroyed && !this.owner) {
+                    if (!this.dontDestroy) {
+                        if (debug)
+                            console.warn(`PlayerState.start → owner is still undefined: destroying \"${this.name}\" instance now`);
+                        this.doDestroy();
+                    }
+                    else if (debug)
+                        console.warn("PlayerState.start → owner is still undefined but dontDestroy is set to true", this.name);
+                }
+                else if (debug)
+                    console.log("PlayerState.start → owner is assigned", this.owner);
+            }, 2000);
+        }
+    }
+    /** Tells the server that this client has been destroyed, and the networking message for the instantiate will be removed      */
+    doDestroy() {
+        if (debug)
+            console.log("PlayerSync.doDestroy → syncDestroy", this.name);
+        syncDestroy(this.gameObject, this.context.connection, true, { saveInRoom: false });
+    }
+    /** @internal */
+    onDestroy() {
+        if (debug)
+            console.warn("PlayerState.onDestroy", this.owner);
+        this.context.connection.stopListen(RoomEvents.UserLeftRoom, this.onUserLeftRoom);
+        PlayerState.all.splice(PlayerState.all.indexOf(this), 1);
+        if (this.isLocalPlayer) {
+            const index = PlayerState._local.indexOf(this);
+            if (index >= 0)
+                PlayerState._local.splice(index, 1);
+        }
+    }
+    /**
+     * Handler for when a user leaves the networked room
+     * @param model Object containing the ID of the user who left
+     */
+    onUserLeftRoom = (model) => {
+        if (model.userId === this.owner) {
+            if (debug)
+                console.log("PLAYERSYNC LEFT", this.owner);
+            this.doDestroy();
+            return;
+        }
+    };
+}
+__decorate([
+    syncField(PlayerState.prototype.onOwnerChange)
+], PlayerState.prototype, "owner", void 0);
 //# sourceMappingURL=PlayerSync.js.map