@mavonengine/core 0.0.2

package/dist/Networking/NetworkedGameObject.d.ts

@@ -0,0 +1,35 @@
+import type { Vector3 } from 'three';
+import type NetworkedEntity from './NetworkedEntity';
+import GameObject from '../World/GameObject';
+export default abstract class NetworkedGameObject extends GameObject implements NetworkedEntity {
+    abstract $typeName: string;
+    previousStateHash: string;
+    needsSync: boolean;
+    constructor(id?: string, position?: Vector3, rotation?: Vector3, scale?: Vector3);
+    updateFromNetwork(_data: object): void;
+    markSyncd(): void;
+    /**
+     * We need this so we can use instanceof on these instances
+     */
+    static [Symbol.hasInstance](instance: unknown): boolean;
+}
+type AbstractCtor<T = object> = abstract new (...args: any[]) => T;
+export declare function NetworkedGameObjectMixin<TBase extends AbstractCtor<GameObject>>(Base: TBase): (abstract new (...args: any[]) => {
+    $typeName: string;
+    updateFromNetwork(data: object): void;
+    previousStateHash: string;
+    needsSync: boolean;
+    markSyncd(): void;
+    garbageCollect: boolean;
+    position: Vector3;
+    rotation: Vector3;
+    scale: Vector3;
+    colliderMesh?: import("three").Mesh;
+    get message(): string;
+    update(delta: number): void;
+    serialize(): object;
+    destroy(): void;
+    id: string;
+    makeid(length?: number): string;
+}) & TBase;
+export {};

package/dist/Networking/NetworkedGameObject.js

@@ -0,0 +1,41 @@
+import GameObject from '../World/GameObject';
+export default class NetworkedGameObject extends GameObject {
+    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 GameObject
+            && typeof candidate.$typeName === 'string'
+            && typeof candidate.updateFromNetwork === 'function'
+            && typeof candidate.markSyncd === 'function'
+            && typeof candidate.needsSync === 'boolean'
+            && typeof candidate.previousStateHash === 'string';
+    }
+}
+export function NetworkedGameObjectMixin(Base) {
+    class NetworkedGameObjectBase extends Base {
+        constructor() {
+            super(...arguments);
+            this.previousStateHash = '';
+            this.needsSync = true;
+        }
+        markSyncd() {
+            this.needsSync = false;
+        }
+    }
+    return NetworkedGameObjectBase;
+}

package/dist/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/Networking/NetworkedLivingActor.d.ts

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

package/dist/Networking/NetworkedLivingActor.js

@@ -0,0 +1,32 @@
+import LivingActor from '../World/LivingActor';
+import { NetworkedGameObjectMixin } from './NetworkedGameObject';
+export default class NetworkedLivingActor extends NetworkedGameObjectMixin(LivingActor) {
+    /**
+     * This is for winston logger meta info
+     */
+    get message() {
+        return `${super.message} - ${this.$typeName}`;
+    }
+    update(delta) {
+        super.update(delta);
+        /**
+         * Update the state hash if it is changed
+         */
+        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/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/Networking/Server/Client.d.ts

@@ -0,0 +1,5 @@
+export default class Entity {
+    id: string;
+    constructor(id?: string);
+    makeid(length?: number): string;
+}

package/dist/Networking/Server/Client.js

@@ -0,0 +1,14 @@
+export default 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/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
+});

package/dist/Networking/Server/Commands.d.ts

@@ -0,0 +1,11 @@
+export declare enum ServerCommand {
+    SV_STATE = "sv_state",
+    SV_REMOVE_ENTITY = "sv_remove_entity"
+}
+export type CommandPacket<T extends ServerCommand> = {
+    cmd: T;
+    data: unknown;
+};
+export type SV_TEST = CommandPacket<ServerCommand.SV_STATE> & {
+    boo: string;
+};

package/dist/Networking/Server/Commands.js

@@ -0,0 +1,5 @@
+export var ServerCommand;
+(function (ServerCommand) {
+    ServerCommand["SV_STATE"] = "sv_state";
+    ServerCommand["SV_REMOVE_ENTITY"] = "sv_remove_entity";
+})(ServerCommand || (ServerCommand = {}));

package/dist/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/Networking/Server/Server.d.ts

@@ -0,0 +1,40 @@
+import type RAPIER from '@dimforge/rapier3d-compat';
+import type { GeckosServer, ServerChannel } from '@geckos.io/server';
+import type GameObject from '../../World/GameObject';
+import type { Express } from 'express';
+import type winston from 'winston';
+import BaseGame from '../../BaseGame';
+import BandwidthTracker from './Stats/BandwidthTracker';
+export default abstract class Server<TClient extends GameObject> {
+    game: BaseGame;
+    private commandBuffer;
+    gameSocket: GeckosServer;
+    httpServer: Express;
+    protected logger: winston.Logger;
+    private onHttpCallback?;
+    lastTime: number;
+    bandwidthTracker: BandwidthTracker;
+    private cpuTracker;
+    protected abstract onConnection(channel: ServerChannel): TClient;
+    protected abstract onCommand(command: any, delta: number): void;
+    constructor(logger: winston.Logger, phyicsWorld?: RAPIER.World);
+    private bufferIncomingCommand;
+    private tick;
+    static instance(): Server<GameObject>;
+    /**
+     * Send full state update to all clients.
+     */
+    private stateSync;
+    /**
+     * The distance the player should have to an object so it
+     * is sent in the state update.
+     */
+    abstract getStateSyncDistance(): number;
+    private runThroughBuffer;
+    private calculateDelta;
+    protected onTick(_delta: number): void;
+    onHttp(callback: (express: Express) => void): void;
+    start(): void;
+    private startHttpServer;
+    private registerHealthEndpoint;
+}