@mavonengine/core 0.0.2

package/dist/InputManager.cjs

@@ -0,0 +1,88 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var InputManager_exports = {};
+__export(InputManager_exports, {
+  default: () => InputManager
+});
+module.exports = __toCommonJS(InputManager_exports);
+var import_three = require("three");
+var import_Game = __toESM(require("./Game"), 1);
+var import_EventEmitter = __toESM(require("./Utils/EventEmitter"), 1);
+class InputManager extends import_EventEmitter.default {
+  constructor() {
+    super();
+    this.keysPressed = /* @__PURE__ */ new Map();
+    this.mousePressed = /* @__PURE__ */ new Map();
+    this.cursor = new import_three.Vector2();
+    window.addEventListener("keydown", (ev) => {
+      this.keysPressed.set(ev.code, true);
+      this.trigger("keydown", ev);
+    });
+    window.addEventListener("keyup", (ev) => {
+      this.keysPressed.delete(ev.code);
+      this.trigger("keyup", ev);
+    });
+    window.addEventListener("mousedown", (ev) => {
+      this.mousePressed.set(ev.button, true);
+      this.trigger("mousedown", ev);
+    });
+    window.addEventListener("mouseup", (ev) => {
+      this.mousePressed.delete(ev.button);
+    });
+    window.addEventListener("mousemove", (ev) => {
+      this.cursor.set(
+        ev.clientX / import_Game.default.instance().sizes.width * 2 - 1,
+        -(ev.clientY / import_Game.default.instance().sizes.height * 2 - 1)
+      );
+    });
+  }
+  /**
+   * Check where the player is currently pointing in the world
+   */
+  getPointerWorldPosition(except, only, returnObject = false) {
+    import_Game.default.instance().rayCaster.setFromCamera(import_Game.default.instance().input.cursor, import_Game.default.instance().camera.instance);
+    const collision = import_Game.default.instance().rayCaster.intersectObjects(
+      import_Game.default.instance().scene.children.filter((child) => {
+        if ((child instanceof import_three.Mesh || child instanceof import_three.Group) && !(except instanceof import_three.Object3D && child === except)) {
+          if (only && child.userData.type !== only) {
+            return null;
+          }
+          return child;
+        }
+        return null;
+      })
+    );
+    if (collision[0]) {
+      if (returnObject) {
+        return collision[0].object;
+      }
+      return collision[0].point;
+    }
+  }
+}

package/dist/InputManager.d.ts

@@ -0,0 +1,12 @@
+import { Object3D, Vector2 } from 'three';
+import EventEmitter from './Utils/EventEmitter';
+export default class InputManager extends EventEmitter {
+    keysPressed: Map<string, true>;
+    mousePressed: Map<number, true>;
+    cursor: Vector2;
+    constructor();
+    /**
+     * Check where the player is currently pointing in the world
+     */
+    getPointerWorldPosition(except?: Object3D, only?: string | null, returnObject?: boolean): import("three").Vector3 | Object3D<import("three").Object3DEventMap> | undefined;
+}

package/dist/InputManager.js

@@ -0,0 +1,50 @@
+import { Group, Mesh, Object3D, Vector2 } from 'three';
+import Game from './Game';
+import EventEmitter from './Utils/EventEmitter';
+export default class InputManager extends EventEmitter {
+    constructor() {
+        super();
+        this.keysPressed = new Map();
+        this.mousePressed = new Map();
+        this.cursor = new Vector2();
+        window.addEventListener('keydown', (ev) => {
+            this.keysPressed.set(ev.code, true);
+            this.trigger('keydown', ev);
+        });
+        window.addEventListener('keyup', (ev) => {
+            this.keysPressed.delete(ev.code);
+            this.trigger('keyup', ev);
+        });
+        window.addEventListener('mousedown', (ev) => {
+            this.mousePressed.set(ev.button, true);
+            this.trigger('mousedown', ev);
+        });
+        window.addEventListener('mouseup', (ev) => {
+            this.mousePressed.delete(ev.button);
+        });
+        window.addEventListener('mousemove', (ev) => {
+            this.cursor.set(ev.clientX / Game.instance().sizes.width * 2 - 1, -(ev.clientY / Game.instance().sizes.height * 2 - 1));
+        });
+    }
+    /**
+     * Check where the player is currently pointing in the world
+     */
+    getPointerWorldPosition(except, only, returnObject = false) {
+        Game.instance().rayCaster.setFromCamera(Game.instance().input.cursor, Game.instance().camera.instance);
+        const collision = Game.instance().rayCaster.intersectObjects(Game.instance().scene.children.filter((child) => {
+            if ((child instanceof Mesh || child instanceof Group) && !(except instanceof Object3D && child === except)) {
+                if (only && child.userData.type !== only) {
+                    return null;
+                }
+                return child;
+            }
+            return null;
+        }));
+        if (collision[0]) {
+            if (returnObject) {
+                return collision[0].object;
+            }
+            return collision[0].point;
+        }
+    }
+}

package/dist/Networking/Client/NetworkManager.cjs

@@ -0,0 +1,94 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var NetworkManager_exports = {};
+__export(NetworkManager_exports, {
+  default: () => NetworkManager
+});
+module.exports = __toCommonJS(NetworkManager_exports);
+var import_client = require("@geckos.io/client");
+var import_BaseGame = __toESM(require("../../BaseGame"), 1);
+var import_EventEmitter = __toESM(require("../../Utils/EventEmitter"), 1);
+let instance;
+class NetworkManager extends import_EventEmitter.default {
+  constructor(options) {
+    super();
+    this.ping = 1e3;
+    this.pingNow = 0;
+    this._connected = false;
+    instance = this;
+    this._socket = (0, import_client.geckos)(options);
+    this._socket.onConnect((error) => {
+      if (error) {
+        import_BaseGame.default.instance().logger?.error(`Socket error: ${error.message}`);
+        return;
+      }
+      import_BaseGame.default.instance().logger?.info(`Socket connection established: ${this._socket.id}`);
+      this._connected = true;
+      this.onConnect();
+    });
+    this._socket.onDisconnect(() => {
+      import_BaseGame.default.instance().logger?.info("Socket disconnected");
+      this._connected = false;
+      this.onDisconnect();
+    });
+    import_BaseGame.default.instance().on("editorBoot", () => {
+      this._socket.close();
+    });
+  }
+  onConnect() {
+    setInterval(() => this.pingCheck(), 1e3);
+    this._socket.on("pong", () => {
+      this.ping = Math.ceil(performance.now() - this.pingNow);
+      this.onPong();
+    });
+  }
+  destroy() {
+    if (this._connected)
+      this._socket.close();
+    this._connected = false;
+    instance = void 0;
+  }
+  onPong() {
+  }
+  onDisconnect() {
+  }
+  pingCheck() {
+    this.pingNow = performance.now();
+    this._socket.emit("ping");
+  }
+  get socket() {
+    return this._socket;
+  }
+  get connected() {
+    return this._connected;
+  }
+  static getInstance() {
+    return instance;
+  }
+}

package/dist/Networking/Client/NetworkManager.d.ts

@@ -0,0 +1,18 @@
+import type { ClientChannel } from '@geckos.io/client';
+import type { ClientOptions } from '@geckos.io/common/lib/types';
+import EventEmitter from '../../Utils/EventEmitter';
+export default class NetworkManager extends EventEmitter {
+    protected _socket: ClientChannel;
+    ping: number;
+    pingNow: number;
+    private _connected;
+    constructor(options: ClientOptions);
+    protected onConnect(): void;
+    destroy(): void;
+    protected onPong(): void;
+    protected onDisconnect(): void;
+    protected pingCheck(): void;
+    get socket(): ClientChannel;
+    get connected(): boolean;
+    static getInstance(): NetworkManager;
+}

package/dist/Networking/Client/NetworkManager.js

@@ -0,0 +1,60 @@
+import { geckos } from '@geckos.io/client';
+import Game from '../../BaseGame';
+import EventEmitter from '../../Utils/EventEmitter';
+let instance;
+export default class NetworkManager extends EventEmitter {
+    constructor(options) {
+        super();
+        this.ping = 1000;
+        this.pingNow = 0;
+        this._connected = false;
+        // eslint-disable-next-line ts/no-this-alias
+        instance = this;
+        this._socket = geckos(options);
+        this._socket.onConnect((error) => {
+            if (error) {
+                Game.instance().logger?.error(`Socket error: ${error.message}`);
+                return;
+            }
+            Game.instance().logger?.info(`Socket connection established: ${this._socket.id}`);
+            this._connected = true;
+            this.onConnect();
+        });
+        this._socket.onDisconnect(() => {
+            Game.instance().logger?.info('Socket disconnected');
+            this._connected = false;
+            this.onDisconnect();
+        });
+        Game.instance().on('editorBoot', () => {
+            this._socket.close();
+        });
+    }
+    onConnect() {
+        setInterval(() => this.pingCheck(), 1000);
+        this._socket.on('pong', () => {
+            this.ping = Math.ceil(performance.now() - this.pingNow);
+            this.onPong();
+        });
+    }
+    destroy() {
+        if (this._connected)
+            this._socket.close();
+        this._connected = false;
+        instance = undefined;
+    }
+    onPong() { }
+    onDisconnect() { }
+    pingCheck() {
+        this.pingNow = performance.now();
+        this._socket.emit('ping');
+    }
+    get socket() {
+        return this._socket;
+    }
+    get connected() {
+        return this._connected;
+    }
+    static getInstance() {
+        return instance;
+    }
+}

package/dist/Networking/Entities/Player.cjs

@@ -0,0 +1,47 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var Player_exports = {};
+__export(Player_exports, {
+  default: () => Player
+});
+module.exports = __toCommonJS(Player_exports);
+var import_NetworkedLivingActor = __toESM(require("../NetworkedLivingActor"), 1);
+class Player extends import_NetworkedLivingActor.default {
+  constructor() {
+    super(...arguments);
+    this.$typeName = "player";
+    this.trackedEntities = /* @__PURE__ */ new Set();
+  }
+  serialize() {
+    return {
+      ...super.serialize(),
+      $typeName: this.$typeName
+    };
+  }
+}

package/dist/Networking/Entities/Player.d.ts

@@ -0,0 +1,9 @@
+import NetworkedLivingActor from '../NetworkedLivingActor';
+/**
+ * Base class for connected clients / Players
+ */
+export default abstract class Player extends NetworkedLivingActor {
+    $typeName: string;
+    trackedEntities: Set<string>;
+    serialize(): object;
+}

package/dist/Networking/Entities/Player.js

@@ -0,0 +1,17 @@
+import NetworkedLivingActor from '../NetworkedLivingActor';
+/**
+ * Base class for connected clients / Players
+ */
+export default class Player extends NetworkedLivingActor {
+    constructor() {
+        super(...arguments);
+        this.$typeName = 'player';
+        this.trackedEntities = new Set();
+    }
+    serialize() {
+        return {
+            ...super.serialize(),
+            $typeName: this.$typeName,
+        };
+    }
+}

package/dist/Networking/NetworkedActor.cjs

@@ -0,0 +1,43 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var NetworkedActor_exports = {};
+__export(NetworkedActor_exports, {
+  default: () => NetworkedActor
+});
+module.exports = __toCommonJS(NetworkedActor_exports);
+var import_Actor = __toESM(require("../World/Actor"), 1);
+var import_NetworkedGameObject = require("./NetworkedGameObject");
+class NetworkedActor extends (0, import_NetworkedGameObject.NetworkedGameObjectMixin)(import_Actor.default) {
+  /**
+   * This is for winston logger meta info
+   */
+  get message() {
+    return `${super.message} - ${this.$typeName}`;
+  }
+}

package/dist/Networking/NetworkedActor.d.ts

@@ -0,0 +1,31 @@
+import type NetworkedEntity from './NetworkedEntity';
+import type NetworkedEntityState from './NetworkedEntityState';
+import Actor from '../World/Actor';
+declare const NetworkedActor_base: (abstract new (...args: any[]) => {
+    $typeName: string;
+    updateFromNetwork(data: object): void;
+    previousStateHash: string;
+    needsSync: boolean;
+    markSyncd(): void;
+    garbageCollect: boolean;
+    position: import("three").Vector3;
+    rotation: import("three").Vector3;
+    scale: import("three").Vector3;
+    colliderMesh?: import("three").Mesh;
+    get message(): string;
+    update(delta: number): void;
+    serialize(): object;
+    destroy(): void;
+    id: string;
+    makeid(length?: number): string;
+}) & typeof Actor;
+export default abstract class NetworkedActor extends NetworkedActor_base implements NetworkedEntity {
+    abstract $typeName: string;
+    state: NetworkedEntityState[];
+    /**
+     * This is for winston logger meta info
+     */
+    get message(): string;
+    abstract updateFromNetwork: (data: object) => void;
+}
+export {};

package/dist/Networking/NetworkedActor.js

@@ -0,0 +1,10 @@
+import Actor from '../World/Actor';
+import { NetworkedGameObjectMixin } from './NetworkedGameObject';
+export default class NetworkedActor extends NetworkedGameObjectMixin(Actor) {
+    /**
+     * This is for winston logger meta info
+     */
+    get message() {
+        return `${super.message} - ${this.$typeName}`;
+    }
+}

package/dist/Networking/NetworkedEntity.cjs

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var NetworkedEntity_exports = {};
+module.exports = __toCommonJS(NetworkedEntity_exports);

package/dist/Networking/NetworkedEntity.d.ts

@@ -0,0 +1,7 @@
+export default interface NetworkedEntity {
+    $typeName: string;
+    updateFromNetwork(data: object): void;
+    previousStateHash: string;
+    needsSync: boolean;
+    markSyncd(): void;
+}

package/dist/Networking/NetworkedEntity.js

@@ -0,0 +1 @@
+export {};

package/dist/Networking/NetworkedEntityState.cjs

@@ -0,0 +1,44 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var NetworkedEntityState_exports = {};
+__export(NetworkedEntityState_exports, {
+  default: () => NetworkedEntityState
+});
+module.exports = __toCommonJS(NetworkedEntityState_exports);
+var import_State = __toESM(require("../World/Entity/State"), 1);
+class NetworkedEntityState extends import_State.default {
+  toJSON() {
+    return this.serialize();
+  }
+  serialize() {
+    return {
+      stateName: this.stateName
+    };
+  }
+}

package/dist/Networking/NetworkedEntityState.d.ts

@@ -0,0 +1,10 @@
+import EntityState from '../World/Entity/State';
+export default abstract class NetworkedEntityState extends EntityState {
+    abstract readonly stateName: string;
+    toJSON(): {
+        stateName: string;
+    };
+    serialize(): {
+        stateName: string;
+    };
+}

package/dist/Networking/NetworkedEntityState.js

@@ -0,0 +1,11 @@
+import EntityState from '../World/Entity/State';
+export default class NetworkedEntityState extends EntityState {
+    toJSON() {
+        return this.serialize();
+    }
+    serialize() {
+        return {
+            stateName: this.stateName,
+        };
+    }
+}

package/dist/Networking/NetworkedGameObject.cjs

@@ -0,0 +1,74 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var NetworkedGameObject_exports = {};
+__export(NetworkedGameObject_exports, {
+  NetworkedGameObjectMixin: () => NetworkedGameObjectMixin,
+  default: () => NetworkedGameObject
+});
+module.exports = __toCommonJS(NetworkedGameObject_exports);
+var import_GameObject = __toESM(require("../World/GameObject"), 1);
+class NetworkedGameObject extends import_GameObject.default {
+  constructor(id, position, rotation, scale) {
+    super(id, position, rotation, scale);
+    this.previousStateHash = "";
+    this.needsSync = true;
+  }
+  updateFromNetwork(_data) {
+    throw new Error("Not implemented");
+  }
+  markSyncd() {
+    this.needsSync = false;
+  }
+  /**
+   * We need this so we can use instanceof on these instances
+   */
+  static [Symbol.hasInstance](instance) {
+    if (!instance || typeof instance !== "object")
+      return false;
+    const candidate = instance;
+    return candidate instanceof import_GameObject.default && typeof candidate.$typeName === "string" && typeof candidate.updateFromNetwork === "function" && typeof candidate.markSyncd === "function" && typeof candidate.needsSync === "boolean" && typeof candidate.previousStateHash === "string";
+  }
+}
+function NetworkedGameObjectMixin(Base) {
+  class NetworkedGameObjectBase extends Base {
+    constructor() {
+      super(...arguments);
+      this.previousStateHash = "";
+      this.needsSync = true;
+    }
+    markSyncd() {
+      this.needsSync = false;
+    }
+  }
+  return NetworkedGameObjectBase;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NetworkedGameObjectMixin
+});