@mavonengine/core 0.0.2

package/dist/cjs/Game.cjs

@@ -0,0 +1,131 @@
+"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 Game_exports = {};
+__export(Game_exports, {
+  default: () => Game
+});
+module.exports = __toCommonJS(Game_exports);
+var THREE = __toESM(require("three"), 1);
+var import_BaseGame = __toESM(require("./BaseGame"), 1);
+var import_Camera = __toESM(require("./Camera"), 1);
+var import_InputManager = __toESM(require("./InputManager"), 1);
+var import_ParticleSystem = __toESM(require("./Particles/System/ParticleSystem"), 1);
+var import_Renderer = __toESM(require("./Renderer"), 1);
+var import_PhysicsRenderer = require("./Renderer/PhysicsRenderer");
+var import_Debug = __toESM(require("./Utils/Debug"), 1);
+var import_LoadingScreen = __toESM(require("./Utils/LoadingScreen"), 1);
+var import_Logger = __toESM(require("./Utils/Logger"), 1);
+var import_Resources = __toESM(require("./Utils/Resources"), 1);
+var import_Sizes = __toESM(require("./Utils/Sizes"), 1);
+var import_World = __toESM(require("./World/World"), 1);
+var import_style = require("./style.css");
+class Game extends import_BaseGame.default {
+  /**
+   * @param sources The source files to load when launching the game
+   */
+  constructor(sources, physicsWorld, renderParameters = {}) {
+    super(
+      // eslint-disable-next-line node/prefer-global/process
+      new import_Logger.default(process.env.NODE_ENV === "production" ? "error" : "debug"),
+      physicsWorld
+    );
+    this.canvas = document.createElement("canvas");
+    this.uiRoot = document.createElement("div");
+    /**
+     * Removing the prevention of right clicking
+     * for in the editor
+     */
+    this.contextMenuAbort = new AbortController();
+    this.initDocument();
+    this.debug = new import_Debug.default();
+    window.Game = this;
+    this.sizes = new import_Sizes.default();
+    this.sizes.on("resize", () => {
+      this.resize();
+    });
+    this.resources = new import_Resources.default(sources);
+    this.loadingScreen = new import_LoadingScreen.default(this.resources);
+    this.audio = new THREE.Audio(new THREE.AudioListener());
+    this.camera = new import_Camera.default(this.audio.listener);
+    this.renderer = new import_Renderer.default({
+      canvas: this.canvas,
+      ...renderParameters
+    });
+    this.input = new import_InputManager.default();
+    this.particleSystem = new import_ParticleSystem.default();
+    this.physicsWorld = physicsWorld;
+    if (this.physicsWorld) {
+      this.physicsDebugRender = new import_PhysicsRenderer.RapierDebugRenderer(this.scene, this.physicsWorld);
+    }
+    this.world = new import_World.default();
+    if (this.isDevMode()) {
+      Game.devModeHook?.();
+    }
+    const render = () => {
+      const delta = this.clock.getDelta();
+      this.particleSystem.update(delta);
+      this.renderer.update(delta);
+      window.requestAnimationFrame(() => render());
+    };
+    render();
+  }
+  initDocument() {
+    document.body.appendChild(this.canvas);
+    this.uiRoot.setAttribute("id", "ui");
+    this.uiRoot.style.opacity = "0";
+    this.canvas.parentNode.insertBefore(this.uiRoot, this.canvas);
+    this.canvas.setAttribute("draggable", "false");
+    this.canvas.addEventListener("mousedown", (e) => {
+      e.preventDefault();
+    });
+    document.getElementsByTagName("body")[0].setAttribute("onContextMenu", "return false;");
+    document.addEventListener("contextmenu", (e) => {
+      e.preventDefault();
+    }, {
+      signal: this.contextMenuAbort.signal
+    });
+    queueMicrotask(() => this.trigger("documentReady"));
+  }
+  static instance() {
+    return super.instance();
+  }
+  resize() {
+    this.camera.resize();
+    this.renderer.resize();
+  }
+  update(delta) {
+    if (this.editor) {
+      this.editor.update(delta);
+    }
+    this.loadingScreen.update(delta);
+    super.update(delta);
+    this.physicsDebugRender?.update();
+    this.camera.update(delta);
+  }
+}

package/dist/cjs/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/cjs/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/cjs/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/cjs/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/cjs/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/cjs/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/cjs/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
+});

package/dist/cjs/Networking/NetworkedLivingActor.cjs

@@ -0,0 +1,62 @@
+"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 NetworkedLivingActor_exports = {};
+__export(NetworkedLivingActor_exports, {
+  default: () => NetworkedLivingActor
+});
+module.exports = __toCommonJS(NetworkedLivingActor_exports);
+var import_LivingActor = __toESM(require("../World/LivingActor"), 1);
+var import_NetworkedGameObject = require("./NetworkedGameObject");
+class NetworkedLivingActor extends (0, import_NetworkedGameObject.NetworkedGameObjectMixin)(import_LivingActor.default) {
+  /**
+   * This is for winston logger meta info
+   */
+  get message() {
+    return `${super.message} - ${this.$typeName}`;
+  }
+  update(delta) {
+    super.update(delta);
+    if (this.stateHash !== this.previousStateHash) {
+      this.previousStateHash = this.stateHash;
+      this.needsSync = true;
+    }
+  }
+  serialize() {
+    return {
+      ...super.serialize(),
+      state: this.state
+    };
+  }
+  isDead() {
+    return this.health <= 0;
+  }
+  kill(_hit, _direction) {
+    this.health = 0;
+  }
+}

package/dist/cjs/Networking/Server/Client.cjs

@@ -0,0 +1,37 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var Client_exports = {};
+__export(Client_exports, {
+  default: () => Entity
+});
+module.exports = __toCommonJS(Client_exports);
+class Entity {
+  constructor(id) {
+    this.id = id ?? this.makeid();
+  }
+  makeid(length = 5) {
+    let result = "";
+    const characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+    const charactersLength = characters.length;
+    for (let i = 0; i < length; i++) {
+      result += characters.charAt(Math.floor(Math.random() * charactersLength));
+    }
+    return result;
+  }
+}

package/dist/cjs/Networking/Server/Commands.cjs

@@ -0,0 +1,32 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var Commands_exports = {};
+__export(Commands_exports, {
+  ServerCommand: () => ServerCommand
+});
+module.exports = __toCommonJS(Commands_exports);
+var ServerCommand = /* @__PURE__ */ ((ServerCommand2) => {
+  ServerCommand2["SV_STATE"] = "SV_STATE";
+  ServerCommand2["SV_REMOVE_ENTITY"] = "SV_REMOVE_ENTITY";
+  return ServerCommand2;
+})(ServerCommand || {});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ServerCommand
+});