@mavonengine/core 0.0.2

package/dist/World/Entity/State.cjs

@@ -0,0 +1,52 @@
+"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 State_exports = {};
+__export(State_exports, {
+  default: () => EntityState
+});
+module.exports = __toCommonJS(State_exports);
+class EntityState {
+  constructor(entity) {
+    this.entity = entity;
+    this.enter();
+  }
+  /**
+   * Start playing any sounds or animations
+   */
+  enter() {
+  }
+  /**
+   * Stop playing any sounds or animations
+   */
+  suspend() {
+  }
+  /**
+   * Remove any buffered sounds / particles / entities etc
+   */
+  destroy() {
+  }
+  leave() {
+    this.suspend();
+    this.destroy();
+    this.entity.state.pop();
+    if (this.entity.state.length) {
+      this.entity.state[this.entity.state.length - 1].enter();
+    }
+  }
+}

package/dist/World/Entity/State.d.ts

@@ -0,0 +1,20 @@
+import type Actor from '../Actor';
+import type GameObject from '../GameObject';
+export default abstract class EntityState {
+    entity: Actor;
+    constructor(entity: Actor);
+    /**
+     * Start playing any sounds or animations
+     */
+    enter(): void;
+    /**
+     * Stop playing any sounds or animations
+     */
+    suspend(): void;
+    /**
+     * Remove any buffered sounds / particles / entities etc
+     */
+    private destroy;
+    leave(): void;
+    abstract update(delta: number, entity?: GameObject): EntityState | void;
+}

package/dist/World/Entity/State.js

@@ -0,0 +1,32 @@
+export default class EntityState {
+    constructor(entity) {
+        this.entity = entity;
+        this.enter();
+    }
+    /**
+     * Start playing any sounds or animations
+     */
+    enter() {
+    }
+    /**
+     * Stop playing any sounds or animations
+     */
+    suspend() {
+    }
+    /**
+     * Remove any buffered sounds / particles / entities etc
+     */
+    destroy() {
+    }
+    leave() {
+        this.suspend();
+        this.destroy();
+        this.entity.state.pop();
+        /**
+         * Enter the previous state again
+         */
+        if (this.entity.state.length) {
+            this.entity.state[this.entity.state.length - 1].enter();
+        }
+    }
+}

package/dist/World/Entity/interface/Damageable.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 Damageable_exports = {};
+module.exports = __toCommonJS(Damageable_exports);

package/dist/World/Entity/interface/Damageable.d.ts

@@ -0,0 +1,7 @@
+export interface Damageable {
+    health: number;
+    maxHealth: number;
+    isDead(): boolean;
+    takeDamage(amount: number): void;
+    heal(amount: number): void;
+}

package/dist/World/Entity/interface/Damageable.js

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

package/dist/World/Entity/interface/LivingEntity.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 LivingEntity_exports = {};
+module.exports = __toCommonJS(LivingEntity_exports);

package/dist/World/Entity/interface/LivingEntity.d.ts

@@ -0,0 +1,3 @@
+import type { Damageable } from './Damageable';
+export default interface LivingEntity extends Damageable {
+}

package/dist/World/Entity/interface/LivingEntity.js

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

package/dist/World/Entity3D.cjs

@@ -0,0 +1,92 @@
+"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 Entity3D_exports = {};
+__export(Entity3D_exports, {
+  default: () => Entity3D
+});
+module.exports = __toCommonJS(Entity3D_exports);
+var import_three = require("three");
+var import_SkeletonUtils = require("three/examples/jsm/utils/SkeletonUtils.js");
+var import_Game = __toESM(require("../Game"), 1);
+var import_Actor = __toESM(require("./Actor"), 1);
+class Entity3D extends import_Actor.default {
+  constructor() {
+    super(...arguments);
+    this.animationsMap = /* @__PURE__ */ new Map();
+  }
+  initModel(model) {
+    this.instance = (0, import_SkeletonUtils.clone)(model.scene);
+    this.instance.traverse((o) => {
+      if (o instanceof import_three.Mesh) {
+        o.castShadow = true;
+        o.receiveShadow = true;
+        const geometry = o.geometry;
+        geometry.computeBoundingBox();
+        geometry.computeBoundingSphere();
+        if (geometry.boundingBox) {
+          geometry.boundingBox.min.multiplyScalar(400);
+          geometry.boundingBox.max.multiplyScalar(400);
+        }
+        if (geometry.boundingSphere) {
+          geometry.boundingSphere.radius *= 400;
+        }
+      }
+    });
+    this.animationMixer = new import_three.AnimationMixer(this.instance);
+    model.animations.forEach((a) => this.animationsMap.set(a.name, this.animationMixer.clipAction(a)));
+    import_Game.default.instance().scene.add(this.instance);
+  }
+  destroy() {
+    super.destroy();
+    this.instance?.traverse((o) => {
+      if (o instanceof import_three.Mesh) {
+        o.geometry.dispose();
+      }
+    });
+    if (this.instance)
+      import_Game.default.instance().scene.remove(this.instance);
+  }
+  update(delta) {
+    this.animationMixer?.update(delta);
+    super.update(delta);
+  }
+  /**
+   * Blend between different animation states for this Entity3D
+   *
+   * https://threejs.org/examples/?q=skin#webgl_animation_skinning_morph
+   */
+  fadeToAction(action, duration) {
+    this.previousAction = this.activeAction;
+    this.activeAction = action;
+    if (this.previousAction !== this.activeAction) {
+      this.previousAction?.fadeOut(duration);
+    }
+    action.reset().setEffectiveTimeScale(1).setEffectiveWeight(1).fadeIn(duration).play();
+  }
+}

package/dist/World/Entity3D.d.ts

@@ -0,0 +1,23 @@
+import type { AnimationAction, Group, Object3DEventMap } from 'three';
+import type { GLTF } from 'three/examples/jsm/loaders/GLTFLoader.js';
+import { AnimationMixer } from 'three';
+import Actor from './Actor';
+/**
+ * An object in the game world with an Object3D (or Mesh).
+ */
+export default class Entity3D extends Actor {
+    instance: Group<Object3DEventMap>;
+    animationMixer?: AnimationMixer;
+    animationsMap: Map<string, AnimationAction>;
+    previousAction?: AnimationAction;
+    activeAction?: AnimationAction;
+    protected initModel(model: GLTF): void;
+    destroy(): void;
+    update(delta: number): void;
+    /**
+     * Blend between different animation states for this Entity3D
+     *
+     * https://threejs.org/examples/?q=skin#webgl_animation_skinning_morph
+     */
+    fadeToAction(action: AnimationAction, duration: number): void;
+}

package/dist/World/Entity3D.js

@@ -0,0 +1,67 @@
+import { AnimationMixer, Mesh } from 'three';
+import { clone } from 'three/examples/jsm/utils/SkeletonUtils.js';
+import Game from '../Game';
+import Actor from './Actor';
+/**
+ * An object in the game world with an Object3D (or Mesh).
+ */
+export default class Entity3D extends Actor {
+    constructor() {
+        super(...arguments);
+        this.animationsMap = new Map();
+    }
+    initModel(model) {
+        this.instance = clone(model.scene);
+        this.instance.traverse((o) => {
+            if (o instanceof Mesh) {
+                o.castShadow = true;
+                o.receiveShadow = true;
+                const geometry = o.geometry;
+                geometry.computeBoundingBox();
+                geometry.computeBoundingSphere();
+                if (geometry.boundingBox) {
+                    geometry.boundingBox.min.multiplyScalar(400);
+                    geometry.boundingBox.max.multiplyScalar(400);
+                }
+                if (geometry.boundingSphere) {
+                    geometry.boundingSphere.radius *= 400;
+                }
+            }
+        });
+        this.animationMixer = new AnimationMixer(this.instance);
+        model.animations.forEach(a => this.animationsMap.set(a.name, this.animationMixer.clipAction(a)));
+        Game.instance().scene.add(this.instance);
+    }
+    destroy() {
+        super.destroy();
+        this.instance?.traverse((o) => {
+            if (o instanceof Mesh) {
+                o.geometry.dispose();
+            }
+        });
+        if (this.instance)
+            Game.instance().scene.remove(this.instance);
+    }
+    update(delta) {
+        this.animationMixer?.update(delta);
+        super.update(delta);
+    }
+    /**
+     * Blend between different animation states for this Entity3D
+     *
+     * https://threejs.org/examples/?q=skin#webgl_animation_skinning_morph
+     */
+    fadeToAction(action, duration) {
+        this.previousAction = this.activeAction;
+        this.activeAction = action;
+        if (this.previousAction !== this.activeAction) {
+            this.previousAction?.fadeOut(duration);
+        }
+        action
+            .reset()
+            .setEffectiveTimeScale(1)
+            .setEffectiveWeight(1)
+            .fadeIn(duration)
+            .play();
+    }
+}

package/dist/World/Environment.cjs

@@ -0,0 +1,59 @@
+"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 Environment_exports = {};
+__export(Environment_exports, {
+  default: () => Environment
+});
+module.exports = __toCommonJS(Environment_exports);
+var import_three = require("three");
+var import_Game = __toESM(require("../Game"), 1);
+class Environment {
+  constructor() {
+    this.sunLight = new import_three.DirectionalLight("#ffffff", 1);
+    this.sunLight.castShadow = true;
+    this.sunLight.shadow.mapSize.set(2048, 2048);
+    this.sunLight.shadow.normalBias = 0.05;
+    this.sunLight.position.set(0, 20, 40);
+    this.sunLight.shadow.camera.left = -50;
+    this.sunLight.shadow.camera.right = 50;
+    this.sunLight.shadow.camera.top = 50;
+    this.sunLight.shadow.camera.bottom = -50;
+    this.sunLight.shadow.camera.far = 100;
+    this.sunLight.shadow.camera.updateProjectionMatrix();
+    if (import_Game.default.instance().debug.active) {
+      import_Game.default.instance().scene.add(new import_three.DirectionalLightHelper(this.sunLight));
+      import_Game.default.instance().scene.add(new import_three.CameraHelper(this.sunLight.shadow.camera));
+    }
+    import_Game.default.instance().scene.add(this.sunLight);
+  }
+  setEnvironmentMap(texture, intensity) {
+    import_Game.default.instance().scene.environment = texture;
+    import_Game.default.instance().scene.environmentIntensity = intensity;
+  }
+}

package/dist/World/Environment.d.ts

@@ -0,0 +1,7 @@
+import type { Texture } from 'three';
+import { DirectionalLight } from 'three';
+export default class Environment {
+    sunLight: DirectionalLight;
+    constructor();
+    setEnvironmentMap(texture: Texture, intensity: number): void;
+}

package/dist/World/Environment.js

@@ -0,0 +1,26 @@
+import { CameraHelper, DirectionalLight, DirectionalLightHelper } from 'three';
+import Game from '../Game';
+export default class Environment {
+    constructor() {
+        this.sunLight = new DirectionalLight('#ffffff', 1);
+        this.sunLight.castShadow = true;
+        this.sunLight.shadow.mapSize.set(2048, 2048);
+        this.sunLight.shadow.normalBias = 0.05;
+        this.sunLight.position.set(0, 20, 40);
+        this.sunLight.shadow.camera.left = -50;
+        this.sunLight.shadow.camera.right = 50;
+        this.sunLight.shadow.camera.top = 50;
+        this.sunLight.shadow.camera.bottom = -50;
+        this.sunLight.shadow.camera.far = 100;
+        this.sunLight.shadow.camera.updateProjectionMatrix(); // Make sure it updates
+        if (Game.instance().debug.active) {
+            Game.instance().scene.add(new DirectionalLightHelper(this.sunLight));
+            Game.instance().scene.add(new CameraHelper(this.sunLight.shadow.camera));
+        }
+        Game.instance().scene.add(this.sunLight);
+    }
+    setEnvironmentMap(texture, intensity) {
+        Game.instance().scene.environment = texture;
+        Game.instance().scene.environmentIntensity = intensity;
+    }
+}

package/dist/World/GameObject.cjs

@@ -0,0 +1,59 @@
+"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 GameObject_exports = {};
+__export(GameObject_exports, {
+  default: () => GameObject
+});
+module.exports = __toCommonJS(GameObject_exports);
+var import_three = require("three");
+var import_Client = __toESM(require("../Networking/Server/Client"), 1);
+class GameObject extends import_Client.default {
+  constructor(id, position = new import_three.Vector3(), rotation = new import_three.Vector3(), scale = new import_three.Vector3(1)) {
+    super(id);
+    this.garbageCollect = false;
+    this.position = position;
+    this.scale = scale;
+    this.rotation = rotation;
+    this.rotation.add(rotation);
+  }
+  get message() {
+    return this.id;
+  }
+  serialize() {
+    return {
+      id: this.id,
+      position: this.position,
+      rotation: this.rotation,
+      scale: this.scale
+    };
+  }
+  destroy() {
+    this.garbageCollect = true;
+  }
+}

package/dist/World/GameObject.d.ts

@@ -0,0 +1,16 @@
+import type { Mesh } from 'three';
+import type GameObjectInterface from './GameObjectInterface';
+import { Vector3 } from 'three';
+import Entity from '../Networking/Server/Client';
+export default abstract class GameObject extends Entity implements GameObjectInterface {
+    garbageCollect: boolean;
+    position: Vector3;
+    rotation: Vector3;
+    scale: Vector3;
+    colliderMesh?: Mesh;
+    constructor(id?: string, position?: Vector3, rotation?: Vector3, scale?: Vector3);
+    get message(): string;
+    abstract update(delta: number): void;
+    serialize(): object;
+    destroy(): void;
+}

package/dist/World/GameObject.js

@@ -0,0 +1,26 @@
+import { Vector3 } from 'three';
+import Entity from '../Networking/Server/Client';
+export default class GameObject extends Entity {
+    constructor(id, position = new Vector3(), rotation = new Vector3(), scale = new Vector3(1)) {
+        super(id);
+        this.garbageCollect = false;
+        this.position = position;
+        this.scale = scale;
+        this.rotation = rotation;
+        this.rotation.add(rotation);
+    }
+    get message() {
+        return this.id;
+    }
+    serialize() {
+        return {
+            id: this.id,
+            position: this.position,
+            rotation: this.rotation,
+            scale: this.scale,
+        };
+    }
+    destroy() {
+        this.garbageCollect = true;
+    }
+}

package/dist/World/GameObjectInterface.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 GameObjectInterface_exports = {};
+module.exports = __toCommonJS(GameObjectInterface_exports);

package/dist/World/GameObjectInterface.d.ts

@@ -0,0 +1,4 @@
+export default interface GameObjectInterface {
+    update(delta: number): void;
+    destroy(): void;
+}

package/dist/World/GameObjectInterface.js

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

package/dist/World/LivingActor.cjs

@@ -0,0 +1,42 @@
+"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 LivingActor_exports = {};
+__export(LivingActor_exports, {
+  default: () => LivingActor
+});
+module.exports = __toCommonJS(LivingActor_exports);
+var import_Actor = __toESM(require("./Actor"), 1);
+class LivingActor extends import_Actor.default {
+  serialize() {
+    return {
+      ...super.serialize(),
+      health: this.health
+    };
+  }
+}

package/dist/World/LivingActor.d.ts

@@ -0,0 +1,10 @@
+import type LivingEntity from './Entity/interface/LivingEntity';
+import Actor from './Actor';
+export default abstract class LivingActor extends Actor implements LivingEntity {
+    abstract health: number;
+    abstract maxHealth: number;
+    abstract isDead(): boolean;
+    abstract takeDamage(amount: number): void;
+    abstract heal(amount: number): void;
+    serialize(): object;
+}

package/dist/World/LivingActor.js

@@ -0,0 +1,9 @@
+import Actor from './Actor';
+export default class LivingActor extends Actor {
+    serialize() {
+        return {
+            ...super.serialize(),
+            health: this.health,
+        };
+    }
+}