@mavonengine/core 0.0.2

package/dist/BaseGame.cjs

@@ -0,0 +1,112 @@
+"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 BaseGame_exports = {};
+__export(BaseGame_exports, {
+  default: () => BaseGame
+});
+module.exports = __toCommonJS(BaseGame_exports);
+var import_three = require("three");
+var import_package = require("../package.json");
+var import_EventEmitter = __toESM(require("./Utils/EventEmitter"), 1);
+var import_BaseWorld = __toESM(require("./World/BaseWorld"), 1);
+let instance;
+class BaseGame extends import_EventEmitter.default {
+  constructor(logger, physicsWorld) {
+    super();
+    this.updateCallbacks = /* @__PURE__ */ new Set();
+    this.tickRate = 30;
+    this.lastTickTime = 0;
+    instance = this;
+    this.logger = logger;
+    this.logger?.info([
+      "",
+      "",
+      "\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510",
+      "\u2502                                         \u2502",
+      "\u2502              MavonEngine                \u2502",
+      "\u2502                                         \u2502",
+      `\u2502  Version:  ${import_package.version.padEnd(28)} \u2502`,
+      // eslint-disable-next-line node/prefer-global/process
+      `\u2502  Mode:     ${(process.env.NODE_ENV ?? "development").padEnd(28)} \u2502`,
+      "\u2502                                         \u2502",
+      "\u2502  https://github.com/MavonEngine/core    \u2502",
+      "\u2502  https://mavonengine.com                \u2502",
+      "\u2502                                         \u2502",
+      "\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518",
+      ""
+    ].join("\n"));
+    this.physicsWorld = physicsWorld;
+    if (this.physicsWorld) {
+      this.characterController = this.physicsWorld.createCharacterController(0.01);
+      this.characterController.setApplyImpulsesToDynamicBodies(true);
+      this.characterController.enableSnapToGround(30);
+      this.characterController.setMaxSlopeClimbAngle(45 * Math.PI / 180);
+      this.characterController.setMinSlopeSlideAngle(30 * Math.PI / 180);
+    }
+    this.clock = new import_three.Clock();
+    this.clock.start();
+    this.scene = new import_three.Scene();
+    this.rayCaster = new import_three.Raycaster();
+    this.world = new import_BaseWorld.default();
+    setInterval(() => {
+      this.tick();
+    }, 1e3 / this.tickRate);
+  }
+  destroy() {
+    this.logger?.emerg("Destroy called on server game instance");
+  }
+  static instance() {
+    return instance;
+  }
+  tick() {
+    const tickNow = performance.now();
+    this.update((tickNow - this.lastTickTime) / 1e3);
+    this.lastTickTime = tickNow;
+  }
+  onUpdate(callback) {
+    this.updateCallbacks.add(callback);
+  }
+  unregisterOnUpdate(callback) {
+    this.updateCallbacks.delete(callback);
+  }
+  update(delta) {
+    if (this.physicsWorld) {
+      this.physicsWorld.timestep = delta;
+      this.physicsWorld.step();
+    }
+    this.world.update(delta);
+    this.updateCallbacks.forEach((callbackFn) => callbackFn(delta));
+  }
+  isDevMode() {
+    return process.env.NODE_ENV !== "production";
+  }
+  isProductionMode() {
+    return process.env.NODE_ENV === "production";
+  }
+}

package/dist/BaseGame.d.ts

@@ -0,0 +1,34 @@
+import type { KinematicCharacterController, World } from '@dimforge/rapier3d-compat';
+import type winston from 'winston';
+import type Logger from './Utils/Logger';
+import type GameObjectInterface from './World/GameObjectInterface';
+import { Clock, Raycaster, Scene } from 'three';
+import EventEmitter from './Utils/EventEmitter';
+import BaseWorld from './World/BaseWorld';
+/**
+ * This is the headless representation of the game.
+ * This is what the game server uses to represent the game state.
+ *
+ * Do not add anything related to audio or rendering here
+ */
+export default class BaseGame extends EventEmitter implements GameObjectInterface {
+    readonly clock: Clock;
+    logger?: winston.Logger | Logger | null;
+    physicsWorld?: World;
+    characterController?: KinematicCharacterController;
+    scene: Scene;
+    rayCaster: Raycaster;
+    world: BaseWorld;
+    protected updateCallbacks: Set<(delta: number) => void>;
+    tickRate: number;
+    lastTickTime: number;
+    constructor(logger?: winston.Logger | Logger | null, physicsWorld?: World);
+    destroy(): void;
+    static instance(): BaseGame;
+    tick(): void;
+    onUpdate(callback: (delta: number) => void): void;
+    unregisterOnUpdate(callback: (delta: number) => void): void;
+    update(delta: number): void;
+    isDevMode(): boolean;
+    isProductionMode(): boolean;
+}

package/dist/BaseGame.js

@@ -0,0 +1,90 @@
+import { Clock, Raycaster, Scene } from 'three';
+import { version as ENGINE_VERSION } from '../package.json' with { type: 'json' };
+import EventEmitter from './Utils/EventEmitter';
+import BaseWorld from './World/BaseWorld';
+let instance;
+/**
+ * This is the headless representation of the game.
+ * This is what the game server uses to represent the game state.
+ *
+ * Do not add anything related to audio or rendering here
+ */
+export default class BaseGame extends EventEmitter {
+    constructor(logger, physicsWorld) {
+        super();
+        this.updateCallbacks = new Set();
+        this.tickRate = 30;
+        this.lastTickTime = 0;
+        // eslint-disable-next-line ts/no-this-alias
+        instance = this;
+        this.logger = logger;
+        this.logger?.info([
+            '',
+            '',
+            '┌─────────────────────────────────────────┐',
+            '│                                         │',
+            '│              MavonEngine                │',
+            '│                                         │',
+            `│  Version:  ${ENGINE_VERSION.padEnd(28)} │`,
+            // eslint-disable-next-line node/prefer-global/process
+            `│  Mode:     ${(process.env.NODE_ENV ?? 'development').padEnd(28)} │`,
+            '│                                         │',
+            '│  https://github.com/MavonEngine/core    │',
+            '│  https://mavonengine.com                │',
+            '│                                         │',
+            '└─────────────────────────────────────────┘',
+            '',
+        ].join('\n'));
+        this.physicsWorld = physicsWorld;
+        if (this.physicsWorld) {
+            this.characterController = this.physicsWorld.createCharacterController(0.01);
+            this.characterController.setApplyImpulsesToDynamicBodies(true);
+            this.characterController.enableSnapToGround(30);
+            // Don’t allow climbing slopes larger than 45 degrees.
+            this.characterController.setMaxSlopeClimbAngle(45 * Math.PI / 180);
+            // Automatically slide down on slopes bigger than 30 degrees.
+            this.characterController.setMinSlopeSlideAngle(30 * Math.PI / 180);
+        }
+        this.clock = new Clock();
+        this.clock.start();
+        this.scene = new Scene();
+        this.rayCaster = new Raycaster();
+        this.world = new BaseWorld();
+        setInterval(() => {
+            this.tick();
+        }, 1000 / this.tickRate);
+    }
+    destroy() {
+        this.logger?.emerg('Destroy called on server game instance');
+    }
+    static instance() {
+        return instance;
+    }
+    tick() {
+        const tickNow = performance.now();
+        this.update((tickNow - this.lastTickTime) / 1000);
+        this.lastTickTime = tickNow;
+    }
+    onUpdate(callback) {
+        this.updateCallbacks.add(callback);
+    }
+    unregisterOnUpdate(callback) {
+        this.updateCallbacks.delete(callback);
+    }
+    update(delta) {
+        if (this.physicsWorld) {
+            this.physicsWorld.timestep = delta;
+            this.physicsWorld.step();
+        }
+        this.world.update(delta);
+        this.updateCallbacks.forEach(callbackFn => callbackFn(delta));
+    }
+    isDevMode() {
+        // eslint-disable-next-line node/prefer-global/process
+        return process.env.NODE_ENV !== 'production';
+    }
+    isProductionMode() {
+        // eslint-disable-next-line node/prefer-global/process
+        return process.env.NODE_ENV === 'production';
+    }
+}

package/dist/Camera.cjs

@@ -0,0 +1,52 @@
+"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 Camera_exports = {};
+__export(Camera_exports, {
+  default: () => Camera
+});
+module.exports = __toCommonJS(Camera_exports);
+var import_three = require("three");
+var import_Game = __toESM(require("./Game"), 1);
+class Camera {
+  constructor(audioListener) {
+    this.instance = new import_three.PerspectiveCamera(
+      35,
+      import_Game.default.instance().sizes.width / import_Game.default.instance().sizes.height
+    );
+    this.instance.add(audioListener);
+    this.instance.position.set(6, 4, 8);
+    import_Game.default.instance().scene.add(this.instance);
+  }
+  resize() {
+    this.instance.aspect = import_Game.default.instance().sizes.width / import_Game.default.instance().sizes.height;
+    this.instance.updateProjectionMatrix();
+  }
+  update(_delta) {
+  }
+}

package/dist/Camera.d.ts

@@ -0,0 +1,8 @@
+import type { AudioListener } from 'three';
+import { PerspectiveCamera } from 'three';
+export default class Camera {
+    instance: PerspectiveCamera;
+    constructor(audioListener: AudioListener);
+    resize(): void;
+    update(_delta: number): void;
+}

package/dist/Camera.js

@@ -0,0 +1,16 @@
+import { PerspectiveCamera } from 'three';
+import Game from './Game';
+export default class Camera {
+    constructor(audioListener) {
+        this.instance = new PerspectiveCamera(35, Game.instance().sizes.width / Game.instance().sizes.height);
+        this.instance.add(audioListener);
+        this.instance.position.set(6, 4, 8);
+        Game.instance().scene.add(this.instance);
+    }
+    resize() {
+        this.instance.aspect = Game.instance().sizes.width / Game.instance().sizes.height;
+        this.instance.updateProjectionMatrix();
+    }
+    update(_delta) {
+    }
+}

package/dist/Components/MinimapComponent.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 MinimapComponent_exports = {};
+__export(MinimapComponent_exports, {
+  MINIMAP_LAYER: () => MINIMAP_LAYER,
+  default: () => MinimapComponent
+});
+module.exports = __toCommonJS(MinimapComponent_exports);
+var import_three = require("three");
+var import_Addons = require("three/examples/jsm/Addons.js");
+var import_Game = __toESM(require("../Game"), 1);
+const MINIMAP_LAYER = 31;
+class MinimapComponent {
+  constructor(minimapElement, camera, target) {
+    this.minimapElement = minimapElement;
+    this.camera = camera;
+    this.camera.position.set(0, 10, 0);
+    this.camera.lookAt(0, 0, 0);
+    this.camera.layers.set(MINIMAP_LAYER);
+    this.renderer = new import_three.WebGLRenderer({
+      canvas: this.minimapElement,
+      antialias: true,
+      alpha: true
+    });
+    this.renderer.setPixelRatio(import_Game.default.instance().sizes.pixelRatio);
+    this.renderer.setSize(250, 250);
+    this.camera.up.set(0, 0, 1);
+    const load = () => {
+      const geometry = new import_Addons.TextGeometry("N", {
+        font: import_Game.default.instance().resources.items.font,
+        size: 3,
+        depth: 0.1
+      });
+      const material = new import_three.MeshBasicMaterial({ color: "white" });
+      this.northIcon = new import_three.Mesh(geometry, material);
+      this.northIcon.rotateX(-90 * Math.PI / 180);
+      this.northIcon.layers.set(MINIMAP_LAYER);
+      import_Game.default.instance().scene.add(this.northIcon);
+    };
+    if (import_Game.default.instance().resources.loaded) {
+      load();
+    } else {
+      import_Game.default.instance().resources.on("loaded", load);
+    }
+    this.target = target;
+  }
+  update(_delta) {
+    if (this.target && this.northIcon) {
+      const targetPos = this.target.position;
+      this.camera.position.set(targetPos.x, 10, targetPos.z);
+      const northOffset = 19;
+      const northPos = new import_three.Vector3(targetPos.x, targetPos.y, targetPos.z + northOffset);
+      this.northIcon.position.copy(northPos);
+    }
+    this.renderer.render(import_Game.default.instance().scene, this.camera);
+  }
+  destroy() {
+    this.renderer.dispose();
+    import_Game.default.instance().scene.remove(this.northIcon);
+    this.northIcon?.geometry.dispose();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MINIMAP_LAYER
+});

package/dist/Components/MinimapComponent.d.ts

@@ -0,0 +1,15 @@
+import type { OrthographicCamera } from 'three';
+import type GameObject from '../World/GameObject';
+import type GameObjectInterface from '../World/GameObjectInterface';
+import { Mesh, WebGLRenderer } from 'three';
+export declare const MINIMAP_LAYER = 31;
+export default class MinimapComponent implements GameObjectInterface {
+    minimapElement: HTMLCanvasElement;
+    camera: OrthographicCamera;
+    renderer: WebGLRenderer;
+    target?: GameObject;
+    northIcon?: Mesh;
+    constructor(minimapElement: HTMLCanvasElement, camera: OrthographicCamera, target?: GameObject);
+    update(_delta: number): void;
+    destroy(): void;
+}

package/dist/Components/MinimapComponent.js

@@ -0,0 +1,57 @@
+import { Mesh, MeshBasicMaterial, Vector3, WebGLRenderer } from 'three';
+import { TextGeometry } from 'three/examples/jsm/Addons.js';
+import Game from '../Game';
+export const MINIMAP_LAYER = 31;
+export default class MinimapComponent {
+    constructor(minimapElement, camera, target) {
+        this.minimapElement = minimapElement;
+        this.camera = camera;
+        this.camera.position.set(0, 10, 0);
+        this.camera.lookAt(0, 0, 0);
+        this.camera.layers.set(MINIMAP_LAYER);
+        this.renderer = new WebGLRenderer({
+            canvas: this.minimapElement,
+            antialias: true,
+            alpha: true,
+        });
+        this.renderer.setPixelRatio(Game.instance().sizes.pixelRatio);
+        this.renderer.setSize(250, 250);
+        this.camera.up.set(0, 0, 1);
+        const load = () => {
+            const geometry = new TextGeometry('N', {
+                font: Game.instance().resources.items.font,
+                size: 3,
+                depth: 0.1,
+            });
+            const material = new MeshBasicMaterial({ color: 'white' });
+            this.northIcon = new Mesh(geometry, material);
+            this.northIcon.rotateX(-90 * Math.PI / 180);
+            this.northIcon.layers.set(MINIMAP_LAYER);
+            Game.instance().scene.add(this.northIcon);
+        };
+        if (Game.instance().resources.loaded) {
+            load();
+        }
+        else {
+            Game.instance().resources.on('loaded', load);
+        }
+        this.target = target;
+    }
+    update(_delta) {
+        if (this.target && this.northIcon) {
+            const targetPos = this.target.position;
+            // Position camera above target
+            this.camera.position.set(targetPos.x, 10, targetPos.z);
+            // Position "N" north of the target
+            const northOffset = 19;
+            const northPos = new Vector3(targetPos.x, targetPos.y, targetPos.z + northOffset);
+            this.northIcon.position.copy(northPos);
+        }
+        this.renderer.render(Game.instance().scene, this.camera);
+    }
+    destroy() {
+        this.renderer.dispose();
+        Game.instance().scene.remove(this.northIcon);
+        this.northIcon?.geometry.dispose();
+    }
+}

package/dist/Components/TrailComponent.cjs

@@ -0,0 +1,101 @@
+"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 TrailComponent_exports = {};
+__export(TrailComponent_exports, {
+  default: () => TrailComponent
+});
+module.exports = __toCommonJS(TrailComponent_exports);
+var import_three = require("three");
+var import_Game = __toESM(require("../Game"), 1);
+class TrailComponent {
+  constructor(entity, maxPoints = 50) {
+    this.points = [];
+    this.entity = entity;
+    this.maxPoints = maxPoints;
+    const startPos = entity.position.clone();
+    this.points.push({
+      position: startPos,
+      timestamp: import_Game.default.instance().clock.getElapsedTime() ?? 0
+    });
+    if (import_Game.default.instance().debug.active) {
+      this.geometry = new import_three.BufferGeometry();
+      this.geometry.setAttribute("position", new import_three.Float32BufferAttribute(startPos.toArray(), 3));
+      const pointsMaterial = new import_three.PointsMaterial({ size: 0.1, color: 16777215 });
+      this.pointsInstance = new import_three.Points(this.geometry, pointsMaterial);
+      this.pointsInstance.frustumCulled = false;
+      import_Game.default.instance().scene.add(this.pointsInstance);
+      this.lineGeometry = new import_three.BufferGeometry();
+      this.lineGeometry.setAttribute("position", new import_three.Float32BufferAttribute(startPos.toArray(), 3));
+      const lineMaterial = new import_three.LineBasicMaterial({ color: 16711680 });
+      this.lineInstance = new import_three.Line(this.lineGeometry, lineMaterial);
+      this.lineInstance.frustumCulled = false;
+      import_Game.default.instance().scene.add(this.lineInstance);
+    }
+  }
+  update(_delta) {
+    const lastPoint = this.points[this.points.length - 1];
+    const currentPosition = this.entity.position;
+    if (currentPosition.distanceTo(lastPoint.position) >= 1) {
+      const newPoint = currentPosition.clone();
+      this.points.push({
+        position: newPoint,
+        timestamp: import_Game.default.instance().clock.getElapsedTime() ?? 0
+      });
+      if (this.points.length > this.maxPoints) {
+        this.points.shift();
+      }
+      const positions = new Float32Array(this.points.length * 3);
+      for (let i = 0; i < this.points.length; i++) {
+        positions[i * 3] = this.points[i].position.x;
+        positions[i * 3 + 1] = this.points[i].position.y;
+        positions[i * 3 + 2] = this.points[i].position.z;
+      }
+      if (this.geometry) {
+        this.geometry.setAttribute("position", new import_three.Float32BufferAttribute(positions, 3));
+        this.geometry.attributes.position.needsUpdate = true;
+      }
+      if (this.lineGeometry) {
+        this.lineGeometry.setAttribute("position", new import_three.Float32BufferAttribute(positions, 3));
+        this.lineGeometry.attributes.position.needsUpdate = true;
+      }
+    }
+  }
+  destroy() {
+    if (this.pointsInstance) {
+      import_Game.default.instance().scene.remove(this.pointsInstance);
+      this.geometry?.dispose();
+      this.pointsInstance.material.dispose();
+    }
+    if (this.lineInstance) {
+      import_Game.default.instance().scene.remove(this.lineInstance);
+      this.lineGeometry?.dispose();
+      this.lineInstance.material.dispose();
+    }
+  }
+}

package/dist/Components/TrailComponent.d.ts

@@ -0,0 +1,24 @@
+import type { Vector3 } from 'three';
+import type GameObject from '../World/GameObject';
+import type GameObjectInterface from '../World/GameObjectInterface';
+import { BufferGeometry, Line, Points } from 'three';
+interface TimedPoint {
+    position: Vector3;
+    timestamp: number;
+}
+/**
+ * Creates a trail behind the entity
+ */
+export default class TrailComponent implements GameObjectInterface {
+    entity: GameObject;
+    points: TimedPoint[];
+    geometry?: BufferGeometry;
+    lineGeometry?: BufferGeometry;
+    pointsInstance?: Points;
+    lineInstance?: Line;
+    maxPoints: number;
+    constructor(entity: GameObject, maxPoints?: number);
+    update(_delta: number): void;
+    destroy(): void;
+}
+export {};