@mavonengine/core 0.0.2

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

@@ -0,0 +1,202 @@
+"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 Server_exports = {};
+__export(Server_exports, {
+  default: () => Server
+});
+module.exports = __toCommonJS(Server_exports);
+var import_node_buffer = require("node:buffer");
+var import_server = __toESM(require("@geckos.io/server"), 1);
+var import_express = __toESM(require("express"), 1);
+var import_Commands = require("./Commands");
+var import_BaseGame = __toESM(require("../../BaseGame"), 1);
+var import_BandwidthTracker = __toESM(require("./Stats/BandwidthTracker"), 1);
+var import_CpuTracker = __toESM(require("./Stats/CpuTracker"), 1);
+var import_World = __toESM(require("./World"), 1);
+let instance;
+class Server {
+  constructor(logger, phyicsWorld) {
+    this.commandBuffer = [];
+    this.httpServer = (0, import_express.default)();
+    this.lastTime = performance.now();
+    this.bandwidthTracker = new import_BandwidthTracker.default();
+    instance = this;
+    this.game = new import_BaseGame.default(logger, phyicsWorld);
+    this.game.world = new import_World.default();
+    this.gameSocket = (0, import_server.default)();
+    this.logger = logger;
+    this.cpuTracker = new import_CpuTracker.default(this.logger);
+    this.gameSocket.onConnection((channel) => {
+      this.logger.info(`Connected: ${channel.id}`);
+      const client = this.onConnection(channel);
+      this.game.world.entities.items.set(client.id.toString(), client);
+      this.logger.info(`${this.game.world.players.length} total players connected`);
+      channel.on("ping", () => {
+        channel.emit("pong");
+      });
+      channel.onDisconnect(() => {
+        const playerId = channel.id;
+        const disconnectedPlayer = import_BaseGame.default.instance().world.entities.items.get(playerId);
+        if (!disconnectedPlayer)
+          return;
+        disconnectedPlayer.destroy();
+        this.gameSocket.connectionsManager.connections.forEach((conn, connId) => {
+          if (connId === playerId)
+            return;
+          const otherPlayer = this.game.world.entities.items.get(connId);
+          if (!otherPlayer)
+            return;
+          const dist = otherPlayer.position.distanceTo(disconnectedPlayer.position);
+          if (dist <= this.getStateSyncDistance()) {
+            conn.channel.emit(import_Commands.ServerCommand.SV_REMOVE_ENTITY, {
+              id: playerId
+            });
+          }
+        });
+        this.logger.info("Disconnected", playerId);
+        this.logger.info(`${this.game.world.players.length - 1} total players connected`);
+      });
+      channel.on("command", (data) => {
+        const bytes = import_node_buffer.Buffer.byteLength(data.toString());
+        this.bandwidthTracker.recordReceived("server", bytes);
+        this.bufferIncomingCommand(channel, data);
+      });
+    });
+    this.game.onUpdate((delta) => this.tick(delta));
+    setInterval(() => {
+      const { sent, received } = this.bandwidthTracker.getBandwidthUsage("server");
+      this.logger.debug(`Client - Sent: ${sent} B, Received: ${received} B`);
+      this.cpuTracker.log();
+      this.bandwidthTracker.reset();
+    }, 5e3);
+  }
+  bufferIncomingCommand(channel, command) {
+    this.commandBuffer.push({
+      playerId: channel.id,
+      ...command
+    });
+  }
+  tick(delta) {
+    this.runThroughBuffer();
+    this.onTick(delta);
+    this.stateSync();
+  }
+  static instance() {
+    return instance;
+  }
+  /**
+   * Send full state update to all clients.
+   */
+  stateSync() {
+    const trackedEntitiesForMarkingSyncd = /* @__PURE__ */ new Map();
+    this.gameSocket.connectionsManager.connections.forEach((con, id) => {
+      const player = this.game.world.entities.items.get(id);
+      if (!player)
+        return;
+      const entitiesToSend = [];
+      const currentTickTrackedEntities = /* @__PURE__ */ new Set();
+      this.game.world.entities.items.forEach((entity) => {
+        const isWithinDistance = player.position.distanceTo(entity.position) < this.getStateSyncDistance();
+        if (isWithinDistance) {
+          entitiesToSend.push(entity);
+          currentTickTrackedEntities.add(entity.id);
+          if (entity.needsSync || !player.trackedEntities.has(entity.id)) {
+            if (!trackedEntitiesForMarkingSyncd.has(entity.id)) {
+              trackedEntitiesForMarkingSyncd.set(entity.id, entity);
+            }
+          }
+        } else {
+          player.trackedEntities.delete(entity.id);
+        }
+      });
+      player.trackedEntities = currentTickTrackedEntities;
+      const state = {
+        entities: entitiesToSend,
+        // Use the new array
+        sequenceId: 0,
+        type: import_Commands.ServerCommand.SV_STATE
+      };
+      this.bandwidthTracker.recordSent("server", import_node_buffer.Buffer.byteLength(state.toString()));
+      con.channel.emit(import_Commands.ServerCommand.SV_STATE, state);
+    });
+    trackedEntitiesForMarkingSyncd.forEach((entity) => entity.markSyncd());
+  }
+  runThroughBuffer() {
+    while (this.commandBuffer.length > 0) {
+      const currentCommand = this.commandBuffer[0];
+      this.onCommand(currentCommand, this.calculateDelta());
+      this.commandBuffer.shift();
+    }
+  }
+  calculateDelta() {
+    const currentTime = performance.now();
+    const deltaTime = currentTime - this.lastTime;
+    return deltaTime;
+  }
+  onTick(_delta) {
+  }
+  onHttp(callback) {
+    this.onHttpCallback = callback;
+  }
+  start() {
+    this.logger.info("Starting @mavon/engine - Socket Server");
+    this.gameSocket.listen(8081);
+    this.startHttpServer();
+    if (this.onHttpCallback) {
+      this.onHttpCallback(this.httpServer);
+    }
+  }
+  startHttpServer() {
+    this.logger.info("Starting @mavon/engine - HTTP Server");
+    this.httpServer.listen(8050);
+    this.registerHealthEndpoint();
+    this.logger.info("Visit game server status: http://localhost:8050/api/game/health");
+  }
+  registerHealthEndpoint() {
+    this.httpServer.get("/api/game/health", (_req, res) => {
+      const server = this;
+      res.format({
+        json() {
+          res.json({
+            serverTime: /* @__PURE__ */ new Date(),
+            uptime: Math.round(performance.now() / 1e3),
+            players: server.game.world.players.length,
+            world: {
+              entities: server.game.world.entities.length
+            },
+            physics: {
+              bodies: server.game.physicsWorld?.bodies.len(),
+              colliders: server.game.physicsWorld?.colliders.len()
+            }
+          });
+        }
+      });
+    });
+  }
+}

package/dist/cjs/Networking/Server/Stats/BandwidthTracker.cjs

@@ -0,0 +1,45 @@
+"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 BandwidthTracker_exports = {};
+__export(BandwidthTracker_exports, {
+  default: () => BandwidthTracker
+});
+module.exports = __toCommonJS(BandwidthTracker_exports);
+class BandwidthTracker {
+  constructor() {
+    this.sent = /* @__PURE__ */ new Map();
+    this.received = /* @__PURE__ */ new Map();
+  }
+  recordSent(id, bytes) {
+    this.sent.set(id, (this.sent.get(id) || 0) + bytes);
+  }
+  recordReceived(id, bytes) {
+    this.received.set(id, (this.received.get(id) || 0) + bytes);
+  }
+  getBandwidthUsage(id) {
+    return {
+      sent: this.sent.get(id) || 0,
+      received: this.received.get(id) || 0
+    };
+  }
+  reset() {
+    this.sent.clear();
+    this.received.clear();
+  }
+}

package/dist/cjs/Networking/Server/Stats/CpuTracker.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 CpuTracker_exports = {};
+__export(CpuTracker_exports, {
+  default: () => CpuTracker
+});
+module.exports = __toCommonJS(CpuTracker_exports);
+var import_node_os = __toESM(require("node:os"), 1);
+var import_node_process = __toESM(require("node:process"), 1);
+class CpuTracker {
+  constructor(logger) {
+    this.lastCpuUsage = import_node_process.default.cpuUsage();
+    this.lastSystemCpuInfo = this.getSystemCpuInfo();
+    this.history = [];
+    this.logger = logger;
+  }
+  log() {
+    const cpuStats = this.getCpuStats();
+    this.logger.info(`CPU Usage - User: ${cpuStats.userCPU.toFixed(2)} ms, System: ${cpuStats.systemCPU.toFixed(2)} ms, Total 1s: ${cpuStats.avg1s}%, Total 10s: ${cpuStats.avg10s}%, Total 1m: ${cpuStats.avg60s}%`);
+  }
+  getCpuStats() {
+    const now = Date.now();
+    const currentCpuUsage = import_node_process.default.cpuUsage(this.lastCpuUsage);
+    this.lastCpuUsage = import_node_process.default.cpuUsage();
+    const userCPU = currentCpuUsage.user / 1e3;
+    const systemCPU = currentCpuUsage.system / 1e3;
+    const totalUsedCPU = userCPU + systemCPU;
+    const currentSystemCpu = this.getSystemCpuInfo();
+    const totalSystemDelta = currentSystemCpu.total - this.lastSystemCpuInfo.total;
+    this.lastSystemCpuInfo = currentSystemCpu;
+    const cpuCount = import_node_os.default.cpus().length;
+    const maxPossibleCpuTime = totalSystemDelta / cpuCount;
+    const cpuPercentage = totalUsedCPU / maxPossibleCpuTime * 100;
+    const roundedCpuPercentage = Number.parseFloat(cpuPercentage.toFixed(2));
+    this.history.push({ timestamp: now, cpuPercentage: roundedCpuPercentage });
+    this.cleanupHistory(now);
+    return {
+      userCPU,
+      systemCPU,
+      totalUsedCPU,
+      cpuPercentage: roundedCpuPercentage,
+      avg1s: this.getAverage(now, 1e3),
+      avg10s: this.getAverage(now, 1e4),
+      avg60s: this.getAverage(now, 6e4)
+    };
+  }
+  getSystemCpuInfo() {
+    const cpus = import_node_os.default.cpus();
+    let user = 0;
+    let nice = 0;
+    let sys = 0;
+    let idle = 0;
+    let irq = 0;
+    for (const cpu of cpus) {
+      user += cpu.times.user;
+      nice += cpu.times.nice;
+      sys += cpu.times.sys;
+      idle += cpu.times.idle;
+      irq += cpu.times.irq;
+    }
+    return { user, nice, sys, idle, irq, total: user + nice + sys + idle + irq };
+  }
+  cleanupHistory(now) {
+    const oneMinuteAgo = now - 6e4;
+    this.history = this.history.filter((stat) => stat.timestamp >= oneMinuteAgo);
+  }
+  getAverage(now, duration) {
+    const fromTime = now - duration;
+    const relevantStats = this.history.filter((stat) => stat.timestamp >= fromTime);
+    if (relevantStats.length === 0)
+      return 0;
+    const sum = relevantStats.reduce((acc, stat) => acc + stat.cpuPercentage, 0);
+    return Number.parseFloat((sum / relevantStats.length).toFixed(2));
+  }
+}

package/dist/cjs/Networking/Server/World.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 World_exports = {};
+__export(World_exports, {
+  default: () => ServerWorld
+});
+module.exports = __toCommonJS(World_exports);
+var import_BaseWorld = __toESM(require("../../World/BaseWorld"), 1);
+var import_Player = __toESM(require("../Entities/Player"), 1);
+class ServerWorld extends import_BaseWorld.default {
+  get players() {
+    return Array.from(this.entities.items.values()).filter(
+      (e) => e instanceof import_Player.default
+    );
+  }
+}

package/dist/cjs/Networking/syncState.cjs

@@ -0,0 +1,51 @@
+"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 syncState_exports = {};
+__export(syncState_exports, {
+  syncStateStack: () => syncStateStack
+});
+module.exports = __toCommonJS(syncState_exports);
+function syncStateStack(entity, networkStates, factories) {
+  let i = 0;
+  while (i < networkStates.length) {
+    const desired = networkStates[i].stateName;
+    const current = entity.state[i];
+    if (!current || current.stateName !== desired) {
+      const stateBeingReplaced = entity.state[i];
+      while (entity.state.length > i) {
+        entity.state[entity.state.length - 1].leave();
+      }
+      const prevState = entity.state[entity.state.length - 1];
+      prevState?.suspend();
+      const factory = factories[desired];
+      if (factory) {
+        const newState = factory(entity, stateBeingReplaced);
+        entity.state.push(newState);
+      }
+    }
+    i++;
+  }
+  while (entity.state.length > networkStates.length) {
+    entity.state[entity.state.length - 1].leave();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  syncStateStack
+});

package/dist/cjs/Particles/Effects/Rain.cjs

@@ -0,0 +1,90 @@
+"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 Rain_exports = {};
+__export(Rain_exports, {
+  RainEmitter: () => RainEmitter,
+  default: () => Rain
+});
+module.exports = __toCommonJS(Rain_exports);
+var import_three = require("three");
+var import_Game = __toESM(require("../../Game"), 1);
+var import_Fragment = __toESM(require("../Shaders/Rain/Fragment.glsl"), 1);
+var import_Vertex = __toESM(require("../Shaders/Rain/Vertex.glsl"), 1);
+var import_Emitter = __toESM(require("../System/Emitter"), 1);
+var import_ParticleEffect = __toESM(require("../System/ParticleEffect"), 1);
+var import_ParticlePreviewRegistry = require("../System/ParticlePreviewRegistry");
+const _RainEmitter = class _RainEmitter extends import_Emitter.default {
+  constructor() {
+    super(import_Game.default.instance().camera.instance.position, new import_three.ShaderMaterial({
+      transparent: true,
+      vertexShader: import_Vertex.default,
+      fragmentShader: import_Fragment.default,
+      uniforms: {
+        uTime: { value: 0 },
+        uCameraPosition: { value: import_Game.default.instance().camera.instance.position }
+      }
+    }), 1e3, 20);
+    this.geometry = new import_three.BufferGeometry();
+    this.mesh = new import_three.Points(this.geometry, this.material);
+    const positions = new Float32Array(this.maxParticles * 3);
+    for (let i = 0; i < this.maxParticles; i++) {
+      const i3 = i * 3;
+      positions[i3] = (Math.random() - 0.5) * 20;
+      positions[i3 + 1] = (Math.random() - 0.5) * 20;
+      positions[i3 + 2] = (Math.random() - 0.5) * 20;
+    }
+    this.geometry.setAttribute("position", new import_three.BufferAttribute(positions, 3));
+    import_Game.default.instance().scene.add(this.mesh);
+  }
+  update(delta) {
+    this.material.uniforms.uTime.value += delta;
+    this.material.uniforms.uCameraPosition.value = import_Game.default.instance().camera.instance.position;
+  }
+};
+_RainEmitter.preview = {
+  cameraPosition: [0, 5, 10],
+  cameraTarget: [0, 0, 0],
+  create: () => new _RainEmitter()
+};
+let RainEmitter = _RainEmitter;
+(0, import_ParticlePreviewRegistry.registerParticle)("Rain", {
+  preview: RainEmitter.preview,
+  spawn: () => new Rain()
+});
+class Rain extends import_ParticleEffect.default {
+  constructor() {
+    super();
+    this.rainEmitter = new RainEmitter();
+    this.emitters.push(this.rainEmitter);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RainEmitter
+});

package/dist/cjs/Particles/Effects/Smoke.cjs

@@ -0,0 +1,144 @@
+"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 Smoke_exports = {};
+__export(Smoke_exports, {
+  SmokeEmitter: () => SmokeEmitter,
+  SmokeParticle: () => SmokeParticle,
+  default: () => Smoke
+});
+module.exports = __toCommonJS(Smoke_exports);
+var import_three = require("three");
+var import_Game = __toESM(require("../../Game"), 1);
+var import_Fragment = __toESM(require("../Shaders/Smoke/Fragment.glsl"), 1);
+var import_Vertex = __toESM(require("../Shaders/Smoke/Vertex.glsl"), 1);
+var import_Emitter = __toESM(require("../System/Emitter"), 1);
+var import_Particle = __toESM(require("../System/Particle"), 1);
+var import_ParticleEffect = __toESM(require("../System/ParticleEffect"), 1);
+var import_ParticlePreviewRegistry = require("../System/ParticlePreviewRegistry");
+class SmokeParticle extends import_Particle.default {
+  constructor(lifetime, position) {
+    super(lifetime, position.clone());
+    this.startAlpha = 0.5;
+    this.reset();
+  }
+  reset() {
+    this.age = 0;
+    this.velocity = new import_three.Vector3(
+      (Math.random() - 0.5) * 0.4,
+      Math.random() * 0.3 + 0.4,
+      (Math.random() - 0.5) * 0.2
+    );
+    this.position.set(0, 0, 0);
+  }
+  update(delta) {
+    this.position.y += delta * 0.1;
+    this.scale = new import_three.Vector3(2 + this.age);
+    this.position.x += this.velocity.x * delta;
+    this.position.y += this.velocity.y * delta;
+    this.position.z += this.velocity.z * delta;
+    super.update(delta);
+  }
+}
+const _SmokeEmitter = class _SmokeEmitter extends import_Emitter.default {
+  constructor(smokeTexture, position) {
+    super(position, new import_three.ShaderMaterial({
+      vertexShader: import_Vertex.default,
+      fragmentShader: import_Fragment.default,
+      transparent: true,
+      blending: import_three.NormalBlending,
+      depthWrite: false,
+      uniforms: {
+        uTime: { value: 0 },
+        uCameraPosition: { value: import_Game.default.instance().camera.instance.position },
+        uTexture: { value: smokeTexture },
+        uAlpha: { value: 0.5 }
+      }
+    }), 20, 10);
+    for (let i = 0; i < this.maxParticles; i++) {
+      const particle = new SmokeParticle(Math.random() * this.maxLifeTimeParticle + 1, position);
+      this.particles.push(particle);
+      this.scales[i] = particle.scale.x;
+      this.alphas[i] = particle.alpha;
+    }
+  }
+  update(delta) {
+    this.material.uniforms.uTime.value += delta;
+    for (let i = 0; i < this.maxParticles; i++) {
+      const particle = this.particles[i];
+      if (particle.age >= particle.decay) {
+        particle.reset();
+      } else {
+        particle.update(delta);
+        this.positions[i * 3] = particle.position.x;
+        this.positions[i * 3 + 1] = particle.position.y;
+        this.positions[i * 3 + 2] = particle.position.z;
+        this.scales[i] = particle.scale.x;
+        this.alphas[i] = particle.alpha;
+      }
+    }
+    this.geometry.getAttribute("aAlpha").needsUpdate = true;
+    this.geometry.getAttribute("position").needsUpdate = true;
+  }
+};
+_SmokeEmitter.preview = {
+  cameraPosition: [0, 4, 10],
+  cameraTarget: [0, 3, 0],
+  create: () => {
+    const tex = import_Game.default.instance().resources.items.smokeTexture;
+    return tex ? new _SmokeEmitter(tex, new import_three.Vector3(0, 0, 0)) : null;
+  }
+};
+let SmokeEmitter = _SmokeEmitter;
+(0, import_ParticlePreviewRegistry.registerParticle)("Smoke", {
+  preview: SmokeEmitter.preview,
+  spawn: (position) => new Smoke(position)
+});
+class Smoke extends import_ParticleEffect.default {
+  constructor(position) {
+    super();
+    const create = () => {
+      const tex2 = import_Game.default.instance().resources.items.smokeTexture;
+      if (tex2) {
+        this.smokeEmitter = new SmokeEmitter(tex2, position);
+        this.emitters.push(this.smokeEmitter);
+      }
+    };
+    const tex = import_Game.default.instance().resources.items.smokeTexture;
+    if (tex) {
+      create();
+    } else {
+      import_Game.default.instance().resources.on("loaded", create);
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SmokeEmitter,
+  SmokeParticle
+});