@rpgjs/server 4.1.2 → 4.2.0

package/browser/rpg.server.umd.cjs

@@ -2,135 +2,6 @@
   typeof exports === "object" && typeof module !== "undefined" ? factory(exports, require("@rpgjs/common"), require("@rpgjs/database")) : typeof define === "function" && define.amd ? define(["exports", "@rpgjs/common", "@rpgjs/database"], factory) : (global2 = typeof globalThis !== "undefined" ? globalThis : global2 || self, factory(global2.RpgServer = {}, global2.common, global2.database));
 })(this, function(exports2, common, database) {
   "use strict";
-  var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
-  function getAugmentedNamespace(n) {
-    if (n.__esModule)
-      return n;
-    var f = n.default;
-    if (typeof f == "function") {
-      var a = function a2() {
-        if (this instanceof a2) {
-          var args = [null];
-          args.push.apply(args, arguments);
-          var Ctor = Function.bind.apply(f, args);
-          return new Ctor();
-        }
-        return f.apply(this, arguments);
-      };
-      a.prototype = f.prototype;
-    } else
-      a = {};
-    Object.defineProperty(a, "__esModule", {
-      value: true
-    });
-    Object.keys(n).forEach(function(k) {
-      var d = Object.getOwnPropertyDescriptor(n, k);
-      Object.defineProperty(a, k, d.get ? d : {
-        enumerable: true,
-        get: function() {
-          return n[k];
-        }
-      });
-    });
-    return a;
-  }
-  /*!
-   * isobject <https://github.com/jonschlinkert/isobject>
-   *
-   * Copyright (c) 2014-2017, Jon Schlinkert.
-   * Released under the MIT License.
-   */
-  var isobject = function isObject2(val) {
-    return val != null && typeof val === "object" && Array.isArray(val) === false;
-  };
-  /*!
-   * get-value <https://github.com/jonschlinkert/get-value>
-   *
-   * Copyright (c) 2014-2018, Jon Schlinkert.
-   * Released under the MIT License.
-   */
-  const isObject$3 = isobject;
-  var getValue = function(target, path2, options2) {
-    if (!isObject$3(options2)) {
-      options2 = { default: options2 };
-    }
-    if (!isValidObject(target)) {
-      return typeof options2.default !== "undefined" ? options2.default : target;
-    }
-    if (typeof path2 === "number") {
-      path2 = String(path2);
-    }
-    const isArray2 = Array.isArray(path2);
-    const isString2 = typeof path2 === "string";
-    const splitChar = options2.separator || ".";
-    const joinChar = options2.joinChar || (typeof splitChar === "string" ? splitChar : ".");
-    if (!isString2 && !isArray2) {
-      return target;
-    }
-    if (isString2 && path2 in target) {
-      return isValid(path2, target, options2) ? target[path2] : options2.default;
-    }
-    let segs = isArray2 ? path2 : split(path2, splitChar, options2);
-    let len = segs.length;
-    let idx = 0;
-    do {
-      let prop = segs[idx];
-      if (typeof prop === "number") {
-        prop = String(prop);
-      }
-      while (prop && prop.slice(-1) === "\\") {
-        prop = join$2([prop.slice(0, -1), segs[++idx] || ""], joinChar, options2);
-      }
-      if (prop in target) {
-        if (!isValid(prop, target, options2)) {
-          return options2.default;
-        }
-        target = target[prop];
-      } else {
-        let hasProp = false;
-        let n = idx + 1;
-        while (n < len) {
-          prop = join$2([prop, segs[n++]], joinChar, options2);
-          if (hasProp = prop in target) {
-            if (!isValid(prop, target, options2)) {
-              return options2.default;
-            }
-            target = target[prop];
-            idx = n - 1;
-            break;
-          }
-        }
-        if (!hasProp) {
-          return options2.default;
-        }
-      }
-    } while (++idx < len && isValidObject(target));
-    if (idx === len) {
-      return target;
-    }
-    return options2.default;
-  };
-  function join$2(segs, joinChar, options2) {
-    if (typeof options2.join === "function") {
-      return options2.join(segs);
-    }
-    return segs[0] + joinChar + segs[1];
-  }
-  function split(path2, splitChar, options2) {
-    if (typeof options2.split === "function") {
-      return options2.split(path2);
-    }
-    return path2.split(splitChar);
-  }
-  function isValid(key, target, options2) {
-    if (typeof options2.isValid === "function") {
-      return options2.isValid(key, target);
-    }
-    return true;
-  }
-  function isValidObject(val) {
-    return isObject$3(val) || Array.isArray(val) || typeof val === "function";
-  }
   const GENERIC_KEY_SCHEMA = "@";
   class Utils {
     static isObject(val) {
@@ -161,25 +32,90 @@
       };
       return paths(obj);
     }
-    static generateId() {
-      return "$" + (Date.now().toString(36) + Math.random().toString(36).substr(2, 5));
+    static generateId(n = 5) {
+      return Math.random().toString(36).substring(n);
+    }
+    static async resolveValue(value) {
+      if (value instanceof Promise) {
+        return await value;
+      }
+      return value;
     }
-    // https://stackoverflow.com/questions/54733539/javascript-implementation-of-lodash-set-method
     static set(obj, path2, value, onlyPlainObject = false) {
       if (Object(obj) !== obj)
         return obj;
-      if (!Array.isArray(path2))
-        path2 = path2.toString().match(/[^.[\]]+/g) || [];
-      path2.slice(0, -1).reduce(
-        (a, c2, i2) => (
-          // Iterate all of them except the last one
-          Object(a[c2]) === a[c2] ? a[c2] : a[c2] = Math.abs(path2[i2 + 1]) >> 0 === +path2[i2 + 1] ? onlyPlainObject ? {} : [] : {}
-        ),
-        // No: assign a new plain object
-        obj
-      )[path2[path2.length - 1]] = value;
+      if (typeof path2 === "string") {
+        path2 = path2.split(".");
+      }
+      let len = path2.length;
+      if (!len)
+        return obj;
+      let current = obj;
+      for (let i2 = 0; i2 < len - 1; i2++) {
+        let segment = path2[i2];
+        let nextSegment = path2[i2 + 1];
+        let isNextNumeric = !isNaN(nextSegment) && isFinite(nextSegment);
+        if (!current[segment] || typeof current[segment] !== "object") {
+          current[segment] = isNextNumeric && !onlyPlainObject ? [] : {};
+        }
+        current = current[segment];
+      }
+      current[path2[len - 1]] = value;
       return obj;
     }
+    static get(obj, path2) {
+      const keys2 = path2.split(".");
+      let current = obj;
+      for (let key of keys2) {
+        if (current[key] === void 0) {
+          return void 0;
+        }
+        current = current[key];
+      }
+      return current;
+    }
+    static bufferFrom(input) {
+      if (typeof input === "string") {
+        let encoder2 = new TextEncoder();
+        return encoder2.encode(input);
+      } else if (input instanceof ArrayBuffer || ArrayBuffer.isView(input)) {
+        return new Uint8Array(input);
+      } else {
+        throw new Error("Input type not supported");
+      }
+    }
+  }
+  var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
+  function getAugmentedNamespace(n) {
+    if (n.__esModule)
+      return n;
+    var f = n.default;
+    if (typeof f == "function") {
+      var a = function a2() {
+        if (this instanceof a2) {
+          var args = [null];
+          args.push.apply(args, arguments);
+          var Ctor = Function.bind.apply(f, args);
+          return new Ctor();
+        }
+        return f.apply(this, arguments);
+      };
+      a.prototype = f.prototype;
+    } else
+      a = {};
+    Object.defineProperty(a, "__esModule", {
+      value: true
+    });
+    Object.keys(n).forEach(function(k) {
+      var d = Object.getOwnPropertyDescriptor(n, k);
+      Object.defineProperty(a, k, d.get ? d : {
+        enumerable: true,
+        get: function() {
+          return n[k];
+        }
+      });
+    });
+    return a;
   }
   var browser$2 = {};
   var encode$4 = {};
@@ -3755,16 +3691,17 @@
     get body() {
       return this.data;
     }
-    message(otherData = {}) {
-      return [this.roomId, Date.now(), { ...this.data, ...otherData }];
+    message(otherData) {
+      return [this.roomId, Date.now(), otherData ?? this.data];
     }
     clone(data) {
       return new Packet(data, this.roomId);
     }
-    encode(otherData = {}) {
+    encode(otherData) {
       return browser$2.encode(this.message(otherData));
     }
   }
+  const { get: get$1, set: set$1 } = Utils;
   class TransmitterClass {
     constructor() {
       this.encode = true;
@@ -3795,104 +3732,183 @@
         this.packets = {};
       }
     }
-    emit(user, packet, room) {
-      const send = (packet2) => {
-        const lastFramePositions = user["_lastFramePositions"];
-        let pos;
-        let lastFrame;
-        if (lastFramePositions) {
-          pos = lastFramePositions.position;
-          lastFrame = lastFramePositions.frame;
-        }
-        const data = { frame: lastFrame, pos };
-        user._socket.emit("w", this.encode ? packet2.encode(data) : packet2.message(data));
-      };
-      if (room.filterEmit) {
-        const objectPacket = room.filterEmit(user, packet);
-        const promiseObjectPacket = objectPacket;
-        if (promiseObjectPacket.then) {
-          promiseObjectPacket.then(send);
-        } else {
-          send(objectPacket);
+    error(user, error) {
+      const err = error instanceof Error ? error.toObject ? error.toObject() : error.message : error;
+      user._socket.emit("error", err);
+    }
+    async emit(user, packet, room) {
+      let data = packet.body;
+      if (room.$additionalEmitProperties) {
+        let additionalData = await Utils.resolveValue(room.$additionalEmitProperties(user, packet.body));
+        if (additionalData !== void 0) {
+          if (typeof additionalData === "string") {
+            additionalData = [additionalData];
+          }
+          if (Array.isArray(additionalData)) {
+            const newData = structuredClone(data);
+            for (let path2 of additionalData) {
+              set$1(newData, path2, get$1(room, path2));
+            }
+            data = newData;
+          } else {
+            data = { ...data, ...additionalData };
+          }
         }
-        return;
       }
-      send(packet);
+      user._socket.emit("w", this.encode ? packet.encode(data) : packet.message(data));
     }
   }
   const Transmitter = new TransmitterClass();
-  const { set } = Utils;
-  class Room {
+  var UserState;
+  (function(UserState2) {
+    UserState2["Connected"] = "C";
+    UserState2["Disconnected"] = "D";
+  })(UserState || (UserState = {}));
+  class User {
     constructor() {
-      this.memoryTotalObject = {};
-      this.memoryObject = {};
-      this.permanentObject = [];
+      this.$state = UserState.Connected;
+      this._secretSessionId = "";
+      this._rooms = [];
+    }
+  }
+  User.schema = {
+    $state: String
+  };
+  class CustomError extends Error {
+    constructor(customMessage) {
+      super(customMessage);
+      this.customMessage = customMessage;
+      this.status = 500;
+      this.code = "INTERNAL_SERVER_ERROR";
+      this.message = "Internal Server error";
+    }
+    toObject() {
+      return {
+        message: this.customMessage || this.message,
+        status: this.status,
+        code: this.code
+      };
+    }
+  }
+  class NotAuthorized extends CustomError {
+    constructor(customMessage) {
+      super(customMessage);
+      this.status = 401;
+      this.code = "NOT_AUTHORIZED";
+      this.message = "Not authorized";
     }
+  }
+  const { set, get } = Utils;
+  class Room {
     static hasExtraProp(obj) {
-      return obj.$default !== void 0 || obj.$syncWithClient !== void 0 || obj.$permanent !== void 0 || obj.$validate !== void 0 || obj.$effects !== void 0;
+      return obj.$default !== void 0 || obj.$syncWithClient !== void 0 || obj.$permanent !== void 0 || obj.$validate !== void 0 || obj.$effects !== void 0 || obj.$type !== void 0;
     }
-    static toDict(schema, room) {
+    static compileSchema(schema, room) {
       const dict = {};
+      const masks = {};
       const permanentObject = [];
-      function toDict(obj, path2 = "") {
-        for (let prop in obj) {
-          const val = obj[prop];
+      function specialObject(val, p) {
+        if (Room.hasExtraProp(val)) {
+          if (val.$permanent ?? true)
+            permanentObject.push(p);
+          if (room && val.$default !== void 0)
+            ;
+          if (val.$syncWithClient === false) {
+            return;
+          }
+          dict[p] = {
+            ...val
+          };
+        } else {
+          dict[p] = val;
+          masks[p] = Utils.propertiesToArray(val);
+          compile(val, p);
+        }
+      }
+      function compile(schema2, path2 = "") {
+        for (let prop in schema2) {
+          const val = schema2[prop];
           let p = (path2 ? path2 + "." : "") + prop;
           if (Array.isArray(val)) {
             dict[p] = GENERIC_KEY_SCHEMA;
             p += "." + GENERIC_KEY_SCHEMA;
-            dict[p] = val[0];
-            toDict(val[0], p);
-          } else if (Utils.isObject(val)) {
-            if (Room.hasExtraProp(val)) {
-              if (val.$permanent ?? true)
-                permanentObject.push(p);
-              if (room && val.$default !== void 0)
-                ;
-              if (val.$syncWithClient === false) {
-                continue;
-              }
-              dict[p] = {
-                ...val
-              };
+            if (val[0] === void 0)
+              val[0] = {};
+            if (Utils.isObject(val[0])) {
+              specialObject(val[0], p);
             } else {
-              dict[p] = val;
-              toDict(val, p);
+              dict[p] = val[0];
+              compile(val[0], p);
             }
+          } else if (Utils.isObject(val)) {
+            specialObject(val, p);
           } else {
             permanentObject.push(p);
             dict[p] = val;
           }
         }
       }
-      toDict(schema);
+      compile(schema);
       return {
+        masks,
         dict,
         permanentObject
       };
     }
-    join(user, room) {
-      if (!user._rooms)
-        user._rooms = [];
-      user._rooms.push(room.id);
-      if (!user.id)
-        user.id = Utils.generateId();
-      if (room["onJoin"])
-        room["onJoin"](user);
+    constructor(options2) {
+      this.options = options2;
+      this.memoryTotalObject = {};
+      this.memoryObject = {};
+      this.permanentObject = [];
+      this.propagateOldRoom = true;
+      if (options2.propagateOldRoom) {
+        this.propagateOldRoom = options2.propagateOldRoom;
+      }
+    }
+    async join(user, room) {
+      if (room["canJoin"]) {
+        const authBool = await Utils.resolveValue(room["canJoin"](user, user._socket));
+        if (authBool === false || typeof authBool == "string") {
+          Transmitter.error(user, new NotAuthorized(authBool));
+          return false;
+        }
+      }
+      if (World.agonesSDK) {
+        await World.agonesSDK.allocate();
+      }
+      let firstJoin = !room.users[user.id];
+      room.users[user.id] = user;
+      const userProxy = World.users[user.id]["proxy"];
+      userProxy.$state = UserState.Connected;
+      if (firstJoin) {
+        if (room["onJoin"])
+          await Utils.resolveValue(room["onJoin"](userProxy));
+      }
       if (this.getUsersLength(room) == 1) {
         this.memoryTotalObject = Room.extractObjectOfRoom(room, room.$schema);
       }
       const packet = new Packet({
         ...this.memoryTotalObject,
-        join: true
+        join: firstJoin
       }, room.id);
-      Transmitter.emit(user, packet, room);
+      await Transmitter.emit(userProxy, packet, room);
+      return true;
     }
-    leave(user, room) {
-      const index2 = user._rooms.findIndex((id) => room.id == id);
-      user._rooms.splice(index2, 1);
+    async leave(user, room) {
       if (room["onLeave"])
         room["onLeave"](user);
+      const index2 = user._rooms.findIndex((id) => room.id == id);
+      user._rooms.splice(index2, 1);
+      delete room.users[user.id];
+      delete World.users[user.id]["proxy"];
+      if (World.nbUsers == 0 && World.agonesSDK) {
+        const { onBeforeShutdown, shutdownIfNotPlayers } = World.agonesOptions;
+        if (shutdownIfNotPlayers) {
+          if (onBeforeShutdown)
+            await onBeforeShutdown();
+          await World.agonesSDK.shutdown();
+        }
+      }
     }
     getUsersLength(room) {
       return Object.keys(room.users).length;
@@ -3915,7 +3931,8 @@
     }
     setProxy(room) {
       const self2 = this;
-      const { dict, permanentObject } = Room.toDict(room.$schema, room);
+      const { dict, permanentObject, masks } = Room.compileSchema(room.$schema, room);
+      const proxifiedObjects = /* @__PURE__ */ new WeakSet();
       this.permanentObject = permanentObject;
       room.$dict = dict;
       const getInfoDict = (path2, key, dictPath) => {
@@ -3925,19 +3942,31 @@
         return {
           fullPath: p,
           genericPath,
-          infoDict: dict[genericPath]
+          infoDict: dict[genericPath],
+          mask: masks[genericPath]
         };
       };
       function deepProxy(object, path2 = "", dictPath = "") {
+        if (proxifiedObjects.has(object)) {
+          return object;
+        }
         return new Proxy(object, {
           set(target, key, val, receiver) {
-            const { fullPath: p, infoDict, genericPath } = getInfoDict(path2, key, dictPath);
+            const { fullPath: p, infoDict, genericPath, mask } = getInfoDict(path2, key, dictPath);
             if (typeof val == "object" && infoDict && val != null) {
               const valProxy = deepProxy(val, p, genericPath);
+              proxifiedObjects.add(valProxy);
               if (path2 == "users") {
+                if (!room.users[key]) {
+                  if (!valProxy._rooms)
+                    valProxy._rooms = [];
+                  valProxy._rooms.push(room.id);
+                  if (!valProxy.id)
+                    valProxy.id = Utils.generateId();
+                }
                 World.users[key]["proxy"] = valProxy;
               }
-              Reflect.set(target, key, valProxy, receiver);
+              Reflect.set(target, key, val, receiver);
               val = target[key];
             } else {
               if (infoDict == null ? void 0 : infoDict.$validate) {
@@ -3971,7 +4000,7 @@
               }
               let newObj;
               if (Utils.isObject(infoDict) && val != null && !Room.hasExtraProp(infoDict)) {
-                newObj = Room.extractObjectOfRoom(val, infoDict);
+                newObj = Room.extractObjectOfRoom(val, mask);
               } else if (infoDict == GENERIC_KEY_SCHEMA) {
                 newObj = {};
                 if (Object.keys(val).length == 0) {
@@ -4003,6 +4032,7 @@
               const { fullPath: p, infoDict, genericPath } = getInfoDict(path3, key, dictPath);
               if (typeof val2 == "object" && infoDict) {
                 val2 = deepProxy(val2, p, genericPath);
+                proxifiedObjects.add(val2);
               }
               return val2;
             };
@@ -4027,7 +4057,7 @@
       if (!room.$schema)
         room.$schema = {};
       if (!room.$schema.users)
-        room.$schema.users = [{ id: String }];
+        room.$schema.users = [User.schema];
       if (!room.$inputs)
         room.$inputs = {};
       if (!room.users)
@@ -4053,16 +4083,20 @@
       room.$snapshotUser = (userId) => {
         return this.snapshotUser(room, userId);
       };
-      room.$join = (user) => {
+      room.$join = async (user) => {
+        if (typeof user == "string") {
+          user = World.users[user];
+        }
         if (user) {
-          room.users[user.id] = user;
-          this.join(room.users[user.id], room);
+          return this.join(user, room);
         }
+        return false;
       };
-      room.$leave = (user) => {
-        this.leave(user, room);
-        delete room.users[user.id];
-        delete World.users[user.id]["proxy"];
+      room.$leave = async (user) => {
+        if (typeof user == "string") {
+          user = World.users[user]["proxy"];
+        }
+        await this.leave(user, room);
       };
       room.$currentState = () => this.memoryObject;
       room.$setCurrentState = (path2, value) => {
@@ -4071,6 +4105,7 @@
       room.$clearCurrentState = () => {
         this.memoryObject = {};
       };
+      room.$parent = this;
       this.proxyRoom = room = this.setProxy(room);
       if (this.proxyRoom["onInit"])
         this.proxyRoom["onInit"]();
@@ -4078,52 +4113,59 @@
     }
     static extractObjectOfRoom(room, schema) {
       const newObj = {};
-      const schemas = [];
       const _schema = Array.isArray(schema) ? schema : Utils.propertiesToArray(schema);
-      function extract(path2) {
-        const match = new RegExp("^(.*?)\\.\\" + GENERIC_KEY_SCHEMA).exec(path2);
+      const regex = new RegExp("^(.*?)\\.\\" + GENERIC_KEY_SCHEMA);
+      function extractAndSet(obj, path2) {
+        if (path2.endsWith("@")) {
+          return;
+        }
+        const match = regex.exec(path2);
         if (match) {
-          const generic = getValue(room, match[1]);
-          if (generic) {
-            const keys2 = Object.keys(generic);
-            for (let key of keys2) {
-              extract(path2.replace(GENERIC_KEY_SCHEMA, key));
+          const generic = get(room, match[1]);
+          if (generic && typeof generic === "object") {
+            for (let key in generic) {
+              if (generic.hasOwnProperty(key)) {
+                extractAndSet(obj, path2.replace(GENERIC_KEY_SCHEMA, key));
+              }
             }
           }
         } else {
-          schemas.push(path2);
+          set(obj, path2, get(room, path2));
         }
       }
       for (let path2 of _schema) {
-        extract(path2);
-      }
-      for (let sheme of schemas) {
-        set(newObj, sheme, getValue(room, sheme));
+        extractAndSet(newObj, path2);
       }
       return newObj;
     }
     detectChanges(room, obj, path2) {
+      const change = (room2) => {
+        const roomInstance = room2.$parent;
+        roomInstance.editMemoryObject(path2, obj);
+        set(roomInstance.memoryTotalObject, path2, obj);
+        if (roomInstance.proxyRoom["onChanges"])
+          roomInstance.proxyRoom["onChanges"](roomInstance.memoryObject);
+        const id = room2.id;
+        World.changes.next({
+          ...World.changes.value,
+          [id]: room2
+        });
+      };
       if (obj != null) {
         const [prop, userId] = path2.split(".");
         if (prop == "users") {
-          if (!room.users[userId]) {
+          if (!this.propagateOldRoom && !room.users[userId]) {
             return;
           }
+          World.forEachUserRooms(userId, change);
+          return;
         }
       }
-      this.editMemoryObject(path2, obj);
-      set(this.memoryTotalObject, path2, obj);
-      if (this.proxyRoom["onChanges"])
-        this.proxyRoom["onChanges"](this.memoryObject);
-      const id = room.id;
-      World.changes.next({
-        ...World.changes.value,
-        [id]: room
-      });
+      change(room);
     }
     editMemoryObject(path2, roomOrValue) {
       if (roomOrValue && typeof roomOrValue == "object" && "$currentState" in roomOrValue) {
-        set(this.memoryObject, path2, getValue(roomOrValue, path2), true);
+        set(this.memoryObject, path2, get(roomOrValue, path2), true);
       } else {
         set(this.memoryObject, path2, roomOrValue, true);
       }
@@ -4147,28 +4189,6 @@
       this.onDisconnectedCb = cb;
     }
   }
-  class Transport extends TransportCommon {
-    constructor(io) {
-      super();
-      this.io = io;
-      io.on("connection", (socket) => {
-        const id = socket.client.id;
-        this.onConnectedCb(socket, id);
-        socket.on(":input", ({ prop, value }) => this.onInputCb(id, prop, value));
-        socket.on(":action", ({ name, value }) => this.onActionCb(id, name, value));
-        socket.on(":join", (roomId) => this.onJoinCb(roomId, id));
-        socket.on("disconnect", () => this.onDisconnectedCb(id));
-      });
-    }
-  }
-  class User {
-    constructor() {
-      this._rooms = [];
-    }
-  }
-  User.schema = {
-    id: String
-  };
   var extendStatics = function(d, b) {
     extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
       d2.__proto__ = b2;
@@ -5057,12 +5077,132 @@
     };
     return BehaviorSubject2;
   }(Subject);
+  class Transport extends TransportCommon {
+    constructor(io, options2 = {}) {
+      super();
+      this.io = io;
+      this.options = options2;
+      this.bandwidthData = {};
+      this.WINDOW_SECONDS = 10;
+      io.on("connection", (socket) => {
+        const id = socket.playerId;
+        this.bandwidthData[id] = new BehaviorSubject({
+          incoming: [],
+          outgoing: []
+        });
+        this.handleConnection(socket, id);
+        socket.on(":input", ({ prop, value }) => this.onInputCb(id, prop, value));
+        socket.on(":action", ({ name, value }) => this.onActionCb(id, name, value));
+        if (options2.clientCanJoinRoom)
+          socket.on(":join", (roomId) => this.onJoinCb(roomId, id));
+        socket.on("disconnect", () => {
+          var _a;
+          (_a = this.bandwidthData[id]) == null ? void 0 : _a.unsubscribe();
+          delete this.bandwidthData[id];
+          this.onDisconnectedCb(id);
+        });
+      });
+      this.use();
+    }
+    handleConnection(socket, id) {
+      this.onConnectedCb(socket, id);
+    }
+    use() {
+      var _a, _b;
+      const { maxKbpsIncoming, maxKbpsOutgoing, auth } = this.options;
+      (_b = (_a = this.io).use) == null ? void 0 : _b.call(_a, async (socket, next) => {
+        let playerId;
+        if (auth) {
+          try {
+            playerId = await Utils.resolveValue(auth(socket));
+          } catch (err) {
+            socket.disconnect();
+            next(new NotAuthorized(err).toObject());
+            return;
+          }
+        }
+        if (!playerId)
+          playerId = Utils.generateId(5);
+        socket.playerId = playerId;
+        socket.use((packet, nextMiddleware) => {
+          var _a2, _b2;
+          if (packet && packet[1]) {
+            const packetSize = Utils.bufferFrom(JSON.stringify(packet)).length - 2;
+            const data = { size: packetSize, timestamp: Date.now() };
+            this.updateBandwidthData(playerId, { incoming: data });
+            const kbps = this.calculateKbps(((_a2 = this.bandwidthData[playerId]) == null ? void 0 : _a2.value.incoming) || []);
+            if (maxKbpsIncoming && kbps > maxKbpsIncoming) {
+              socket.disconnect();
+              return;
+            }
+            this.cleanOldData(((_b2 = this.bandwidthData[playerId]) == null ? void 0 : _b2.value.incoming) || []);
+          }
+          nextMiddleware();
+        });
+        const originalEmit = socket.emit;
+        socket.emit = (...args) => {
+          var _a2, _b2;
+          const packetSize = Utils.bufferFrom(JSON.stringify(args)).length - 2;
+          const data = { size: packetSize, timestamp: Date.now() };
+          this.updateBandwidthData(playerId, { outgoing: data });
+          const kbps = this.calculateKbps(((_a2 = this.bandwidthData[playerId]) == null ? void 0 : _a2.value.outgoing) || []);
+          if (maxKbpsOutgoing && kbps > maxKbpsOutgoing) {
+            socket.disconnect();
+            return;
+          }
+          this.cleanOldData(((_b2 = this.bandwidthData[playerId]) == null ? void 0 : _b2.value.outgoing) || []);
+          originalEmit.apply(socket, args);
+        };
+        next();
+      });
+    }
+    updateBandwidthData(socketId, data) {
+      var _a, _b;
+      const currentData = ((_a = this.bandwidthData[socketId]) == null ? void 0 : _a.value) || { incoming: [], outgoing: [] };
+      if (data.incoming) {
+        currentData.incoming.push(data.incoming);
+      }
+      if (data.outgoing) {
+        currentData.outgoing.push(data.outgoing);
+      }
+      (_b = this.bandwidthData[socketId]) == null ? void 0 : _b.next(currentData);
+    }
+    cleanOldData(dataArray) {
+      const cutOff = Date.now() - this.WINDOW_SECONDS * 1e3;
+      while (dataArray.length > 0 && dataArray[0].timestamp < cutOff) {
+        dataArray.shift();
+      }
+    }
+    calculateKbps(dataArray) {
+      const totalBytes = dataArray.reduce((acc, entry) => acc + entry.size, 0);
+      return totalBytes * 8 / (this.WINDOW_SECONDS * 1e3);
+    }
+    getTelemetry() {
+      const socketsData = {};
+      let totalKbps = 0;
+      for (const [socketId, bandwidth] of Object.entries(this.bandwidthData)) {
+        const socketData = bandwidth.value;
+        const incomingKbps = this.calculateKbps(socketData.incoming);
+        const outgoingKbps = this.calculateKbps(socketData.outgoing);
+        socketsData[socketId] = { incomingKbps, outgoingKbps };
+        totalKbps += incomingKbps + outgoingKbps;
+      }
+      return {
+        sockets: socketsData,
+        totalKbps
+      };
+    }
+  }
   class WorldClass {
     constructor() {
       this.rooms = /* @__PURE__ */ new Map();
       this.users = {};
       this.userClass = User;
+      this.timeoutDisconnect = 0;
       this.changes = new BehaviorSubject({});
+      this._transport = null;
+      this.agonesSDK = null;
+      this.agonesOptions = {};
     }
     /**
      * Define user class
@@ -5073,32 +5213,48 @@
     setUserClass(userClass) {
       this.userClass = userClass;
     }
+    setAgones(agones, options2 = {}) {
+      this.agonesSDK = agones;
+      this.agonesOptions = options2;
+    }
     /**
      * Define transportation. You can set socket.io as default
      *
      * @method transport()
      * @param {object} io
-     * @returns {void}
+     * @returns {Transport}
      */
-    transport(io) {
-      const transport = new Transport(io);
+    transport(io, options2 = {}) {
+      if (options2.timeoutDisconnect) {
+        this.timeoutDisconnect = options2.timeoutDisconnect;
+      }
+      const transport = new Transport(io, options2);
       transport.onConnected(this.connectUser.bind(this));
       transport.onDisconnected(this.disconnectUser.bind(this));
       transport.onJoin(this.joinRoom.bind(this));
       transport.onInput((id, prop, value) => {
         this.forEachUserRooms(id, (room, user) => {
-          if (room.$inputs && room.$inputs[prop]) {
-            room[prop] = value;
+          try {
+            if (room.$inputs && room.$inputs[prop]) {
+              room[prop] = value;
+            }
+          } catch (err) {
+            Transmitter.error(user, err);
           }
         });
       });
       transport.onAction((id, name, value) => {
         this.forEachUserRooms(id, async (room, user) => {
           if (room.$actions && room.$actions[name]) {
-            room[name](user, value);
+            try {
+              room[name](user, value);
+            } catch (err) {
+              Transmitter.error(user, err);
+            }
           }
         });
       });
+      return this._transport = transport;
     }
     /**
      * Loop over all rooms of a user
@@ -5117,7 +5273,7 @@
      * @returns {void}
      */
     forEachUserRooms(userId, cb) {
-      const user = this.getUser(userId);
+      const user = this.getUser(userId, true);
       if (!user)
         return;
       for (let roomId of user._rooms) {
@@ -5156,29 +5312,32 @@
       this.users[user.id] = user;
       return this.users[user.id];
     }
+    get nbUsers() {
+      return Object.keys(this.users).length;
+    }
     /**
      * Send the packages to the rooms.
      *
      * @method send()
      */
-    send() {
-      this.rooms.forEach((room, id) => {
+    async send() {
+      for (let [_, room] of this.rooms) {
         const obj = room.$currentState();
         if (Object.keys(obj).length == 0) {
           return;
         }
         Transmitter.addPacket(room, obj);
-        for (let id2 in room.users) {
-          const user = room.users[id2];
+        for (let id in room.users) {
+          const user = room.users[id];
           const packets = Transmitter.getPackets(room);
           if (packets) {
             for (let packet of packets) {
-              Transmitter.emit(user, packet, room);
+              await Transmitter.emit(user, packet, room);
             }
           }
         }
         room.$clearCurrentState();
-      });
+      }
       Transmitter.clear();
     }
     /**
@@ -5187,10 +5346,23 @@
      * @method connectUser()
      * @param {object} socket
      * @param {id} userId
+     * @param {object} options
+     *  - getUserInstance: function that returns a new instance of the user
      * @returns {User}
      */
-    connectUser(socket, id) {
-      const user = new this.userClass();
+    connectUser(socket, id, options2 = {}) {
+      var _a;
+      const existingUser = this.getUser(id, false);
+      if (existingUser) {
+        if (existingUser._timeoutDisconnect) {
+          clearTimeout(existingUser._timeoutDisconnect);
+          delete existingUser._timeoutDisconnect;
+        }
+        existingUser._socket = socket;
+        existingUser.$state = UserState.Connected;
+        return existingUser;
+      }
+      const user = ((_a = options2.getUserInstance) == null ? void 0 : _a.call(options2, socket)) ?? new this.userClass();
       user.id = id;
       socket.emit("uid", id);
       this.setUser(user, socket);
@@ -5204,18 +5376,52 @@
      * @returns {void}
      */
     disconnectUser(userId) {
-      this.forEachUserRooms(userId, (room, user) => {
-        if (room.$leave)
-          room.$leave(user);
+      return new Promise((resolve2, reject) => {
+        const user = this.getUser(userId);
+        if (!user)
+          return resolve2();
+        user.$state = UserState.Disconnected;
+        const leave = () => {
+          const leaveAllPromises = [];
+          this.forEachUserRooms(userId, async (room, user2) => {
+            if (room.$leave)
+              leaveAllPromises.push(room.$leave(user2));
+          });
+          delete this.users[userId];
+          Promise.all(leaveAllPromises).then(resolve2).catch((err) => {
+            Transmitter.error(user, err);
+            reject(err);
+          });
+        };
+        if (!this.timeoutDisconnect) {
+          leave();
+          return;
+        }
+        user._timeoutDisconnect = setTimeout(leave, this.timeoutDisconnect);
+      });
+    }
+    httpUpgrade(httpServer, io) {
+      httpServer.removeAllListeners("upgrade");
+      httpServer.on("upgrade", (req, socket, head) => {
+        if (req.url.startsWith("/socket.io/")) {
+          io.engine.handleUpgrade(req, socket, head);
+        } else {
+          socket.destroy();
+        }
       });
-      delete this.users[userId];
     }
-    joinOrLeaveRoom(type, roomId, userId) {
+    async joinOrLeaveRoom(type, roomId, userId) {
       const room = this.getRoom(roomId);
       if (!room)
         return;
-      if (room[type])
-        room[type](this.getUser(userId, false));
+      if (room[type]) {
+        try {
+          await room[type](this.getUser(userId, false));
+        } catch (err) {
+          Transmitter.error(this.getUser(userId, false), err);
+          throw err;
+        }
+      }
       return room;
     }
     /**
@@ -5225,7 +5431,7 @@
      * @param {string} userId
      * @returns {RoomClass | undefined}
      */
-    leaveRoom(roomId, userId) {
+    async leaveRoom(roomId, userId) {
       return this.joinOrLeaveRoom("$leave", roomId, userId);
     }
     /**
@@ -5235,7 +5441,7 @@
      * @param {string} userId
      * @returns {RoomClass | undefined}
      */
-    joinRoom(roomId, userId) {
+    async joinRoom(roomId, userId) {
       return this.joinOrLeaveRoom("$join", roomId, userId);
     }
     /**
@@ -5265,12 +5471,15 @@
      * @param {Class or instance of Class} roomClass
      * @returns instance of Class
      */
-    addRoom(id, roomClass) {
+    addRoom(id, roomClass, options2 = {}) {
       if (roomClass.constructor.name == "Function") {
         roomClass = new roomClass();
       }
-      const room = new Room().add(id, roomClass);
+      const room = new Room(options2).add(id, roomClass);
       this.rooms.set(id, room);
+      if (this.agonesSDK) {
+        this.agonesSDK.setLabel("room.id", id);
+      }
       return room;
     }
     /**
@@ -5304,11 +5513,132 @@
      * Remove all rooms and users
      */
     clear() {
+      var _a, _b;
       this.rooms.clear();
+      this.changes.next({});
       this.users = {};
+      if (this._transport) {
+        (_b = (_a = this._transport.io) == null ? void 0 : _a.clear) == null ? void 0 : _b.call(_a);
+      }
     }
   }
   const World = new WorldClass();
+  class MiddlewareHandler {
+    constructor() {
+      this.middlewares = [];
+    }
+    use(middleware) {
+      this.middlewares.push(middleware);
+    }
+    run(socket, finalCallback = (err) => {
+    }) {
+      let index2 = 0;
+      const next = (err) => {
+        if (err) {
+          finalCallback(err);
+          return;
+        }
+        if (index2 >= this.middlewares.length) {
+          finalCallback();
+          return;
+        }
+        const middleware = this.middlewares[index2];
+        index2 += 1;
+        middleware(socket, next);
+      };
+      next();
+    }
+    clear() {
+      this.middlewares = [];
+    }
+  }
+  class MockIo {
+    constructor() {
+      this.events = /* @__PURE__ */ new Map();
+      this.eventsOnce = /* @__PURE__ */ new Map();
+    }
+    on(name, value) {
+      this.events.set(name, [...this.events.get(name) || [], value]);
+    }
+    off(name) {
+      if (this.eventsOnce.has(name)) {
+        this.eventsOnce.delete(name);
+        return;
+      }
+      this.events.delete(name);
+    }
+    once(name, value) {
+      this.eventsOnce.set(name, value);
+    }
+    _trigger(name, data, client) {
+      const events = this.events.get(name) || [];
+      for (const event of events) {
+        event(data, client);
+      }
+      const eventOnce = this.eventsOnce.get(name);
+      if (eventOnce) {
+        eventOnce(data, client);
+        this.eventsOnce.delete(name);
+      }
+    }
+  }
+  class MockSocket extends MockIo {
+    constructor(handshake, client) {
+      super();
+      this.handshake = handshake;
+      this.client = client;
+      this.middlewares = new MiddlewareHandler();
+      this.id = client.fakeId ?? "" + Math.random();
+      this.client.id = this.id;
+    }
+    emit(name, data) {
+      this.client._trigger(name, data);
+    }
+    removeAllListeners(name) {
+      return this.off(name);
+    }
+    use(cb) {
+      this.middlewares.use(cb);
+    }
+    disconnect() {
+    }
+  }
+  class MockServerIo extends MockIo {
+    constructor() {
+      super(...arguments);
+      this.clients = /* @__PURE__ */ new Map();
+      this.middlewares = new MiddlewareHandler();
+    }
+    connection(client, handshake) {
+      return new Promise((resolve2, reject) => {
+        const socket = new MockSocket(handshake, client);
+        this.clients.set(socket.id, socket);
+        client.id = socket.id;
+        this.middlewares.run(socket, (err) => {
+          if (err) {
+            client._trigger("error", err);
+            return;
+          }
+          this._trigger("connection", socket);
+          resolve2(socket);
+        });
+      });
+    }
+    emit(name, data, id) {
+      var _a;
+      (_a = this.clients.get(id)) == null ? void 0 : _a._trigger(name, data);
+    }
+    use(cb) {
+      this.middlewares.use(cb);
+    }
+    clear() {
+      this.events.clear();
+      this.eventsOnce.clear();
+      this.clients.clear();
+      this.middlewares.clear();
+    }
+  }
+  new MockServerIo();
   var TiledLayerType;
   (function(TiledLayerType2) {
     TiledLayerType2["Tile"] = "tilelayer";
@@ -12447,7 +12777,7 @@
         return func(value);
       };
     }
-    function getValue2(object, key) {
+    function getValue(object, key) {
       return object == null ? void 0 : object[key];
     }
     function overArg(func, transform) {
@@ -12886,7 +13216,7 @@
       return isKeyable(key) ? data[typeof key == "string" ? "string" : "hash"] : data.map;
     }
     function getNative(object, key) {
-      var value = getValue2(object, key);
+      var value = getValue(object, key);
       return baseIsNative(value) ? value : void 0;
     }
     function getRawTag(value) {
@@ -17594,7 +17924,6 @@
     }
     // @internal
     removeObject(object, mode = "shared") {
-      var _a;
       const map = this.getCurrentMap();
       if (!map)
         return;
@@ -17613,7 +17942,7 @@
         if (object.id == playerId)
           continue;
         const otherPlayer = map.players[playerId];
-        if (((_a = otherPlayer.following) == null ? void 0 : _a.id) == object.id) {
+        if (otherPlayer.followingId == object.id) {
           otherPlayer.cameraFollow(otherPlayer);
         }
       }
@@ -17622,6 +17951,13 @@
       }
     }
   }
+  let instanceContext = null;
+  function inject(service, args = []) {
+    return instanceContext.inject(service, args);
+  }
+  function setInject(context) {
+    instanceContext = context;
+  }
   const {
     isPromise,
     applyMixins,
@@ -17681,7 +18017,7 @@
     sp: Number,
     gold: Number,
     level: {
-      $effects: ["$this.expForNextlevel"]
+      $effects: ["$this.expForNextlevel", "$this.param"]
     },
     expForNextlevel: {
       $permanent: false
@@ -17743,8 +18079,9 @@
     lines: []
   };
   const _RpgPlayer = class extends common.RpgCommonPlayer {
-    constructor(gameEngine, playerId) {
-      super(gameEngine, playerId);
+    constructor(playerId) {
+      super(inject(common.RpgCommonGame), playerId);
+      this.playerId = playerId;
       this.type = "player";
       this.layout = {
         top: layoutObject,
@@ -17760,8 +18097,9 @@
       this.touchSide = false;
       this.tmpPositions = null;
       this.otherPossessedPlayer = null;
-      this.following = null;
+      this.followingId = null;
       this._dataLoading = false;
+      this.gameEngine = inject(common.RpgCommonGame);
       this.teleported = 0;
       this.deleted = false;
       this.initialize();
@@ -17776,6 +18114,7 @@
     }
     /** @internal */
     initialize() {
+      this.server = inject(RpgServerEngine);
       this.expCurve = {
         basis: 30,
         extra: 20,
@@ -18128,7 +18467,7 @@
     toJSON() {
       const {
         permanentObject
-      } = Room.toDict(this.schema);
+      } = Room.compileSchema(this.schema);
       const snapshot = Room.extractObjectOfRoom(this, permanentObject);
       snapshot.variables = [...this.variables];
       return snapshot;
@@ -18293,9 +18632,9 @@
      */
     cameraFollow(otherPlayer, options2 = {}) {
       if (otherPlayer.id == this.id) {
-        this.following = null;
+        this.followingId = null;
       } else {
-        this.following = otherPlayer;
+        this.followingId = otherPlayer.id;
       }
       this.emit(SocketEvents.CallMethod, {
         objectId: this.playerId,
@@ -18479,8 +18818,8 @@
   };
   applyMixins(RpgPlayer, [EventManager, ItemManager, GoldManager, StateManager, SkillManager, ParameterManager, EffectManager, ClassManager, ElementManager, GuiManager, VariableManager, MoveManager, BattleManager, ComponentManager]);
   class RpgEvent extends RpgPlayer {
-    constructor(gameEngine, playerId) {
-      super(gameEngine, playerId);
+    constructor(playerId) {
+      super(playerId);
       this.type = "event";
       this.properties = {};
       this.playerRelated = null;
@@ -18633,6 +18972,20 @@
     get nbPlayers() {
       return Object.keys(this.players).length;
     }
+    $additionalEmitProperties(player) {
+      const lastFramePositions = player["_lastFramePositions"];
+      let pos;
+      let lastFrame;
+      if (lastFramePositions) {
+        pos = lastFramePositions.position;
+        lastFrame = lastFramePositions.frame;
+      }
+      const data = {
+        frame: lastFrame,
+        pos
+      };
+      return data;
+    }
     async load() {
       var _a;
       if (common.RpgCommonMap.buffer.has(this.id)) {
@@ -18917,7 +19270,6 @@
       const ev = this.game.addEvent(event);
       const _shape = shape || this.getEventShape(ev.name);
       ev.map = this.id;
-      ev.server = this._server;
       ev.width = event.width || this.tileWidth;
       ev.height = event.height || this.tileHeight;
       if (_shape && _shape.properties)
@@ -19019,11 +19371,11 @@
     return result;
   };
   class SceneMap {
-    constructor(sceneMapObject, server) {
-      this.server = server;
+    constructor(sceneMapObject) {
       this.maps = [];
       this.mapsById = {};
       this.worldMaps = /* @__PURE__ */ new Map();
+      this.server = inject(RpgServerEngine);
       const {
         maps,
         worldMaps,
@@ -19230,7 +19582,9 @@
         await player.teleport(positions || "start");
         return null;
       }
-      player.emit("preLoadScene", mapId);
+      player.emit("preLoadScene", {
+        id: mapId
+      });
       player.prevMap = player.map;
       if (player.prevMap) {
         await player.execMethod("onLeaveMap", [player.getCurrentMap()]);
@@ -19441,16 +19795,7 @@
     return result;
   };
   class RpgServerEngine {
-    /**
-     * Combat formulas
-     * 
-     * @prop {Socket Io Server} [io]
-     * @memberof RpgServerEngine
-     */
-    constructor(io, gameEngine, inputOptions) {
-      this.io = io;
-      this.gameEngine = gameEngine;
-      this.inputOptions = inputOptions;
+    constructor() {
       this.database = {};
       this.globalConfig = {};
       this.damageFormulas = {};
@@ -19458,8 +19803,20 @@
       this.scenes = /* @__PURE__ */ new Map();
       this.totalConnected = 0;
       this.scheduler = new common.Scheduler();
+      this.gameEngine = inject(common.RpgCommonGame);
       this.world = World;
       this.envs = {};
+      this.inputOptions = {};
+    }
+    /**
+     * Combat formulas
+     * 
+     * @prop {Socket Io Server} [io]
+     * @memberof RpgServerEngine
+     */
+    initialize(io, inputOptions) {
+      this.io = io;
+      this.inputOptions = inputOptions;
       this.envs = inputOptions.envs || {};
       if (this.inputOptions.workers) {
         console.log("workers enabled");
@@ -19493,15 +19850,16 @@
       if (!this.inputOptions.database)
         this.inputOptions.database = {};
       const datas = await common.RpgPlugin.emit(common.HookServer.AddDatabase, this.inputOptions.database) || [];
-      for (let plug of datas) {
-        this.inputOptions.database = {
-          ...plug,
-          ...this.inputOptions.database
-        };
-      }
-      for (let key in this.inputOptions.database) {
-        const data = this.inputOptions.database[key];
-        this.addInDatabase(data.id, data);
+      for (let element of datas) {
+        if (Array.isArray(element)) {
+          for (let data of element) {
+            this.addInDatabase(data.id, data);
+          }
+        } else {
+          for (let id in element) {
+            this.addInDatabase(element[id].id ?? id, element[id]);
+          }
+        }
       }
       this.loadScenes();
     }
@@ -19632,9 +19990,27 @@
           return Query._getShapesOfMap(map);
         }
       });
-      this.io.on("connection", this.onPlayerConnected.bind(this));
+      this.transport(this.io);
       await common.RpgPlugin.emit(common.HookServer.Start, this);
     }
+    transport(io) {
+      const timeoutDisconnect = this.globalConfig.timeoutDisconnect ?? 0;
+      const auth = this.globalConfig.disableAuth ? () => common.Utils.generateUID() : async (socket) => {
+        const val = await common.RpgPlugin.emit(common.HookServer.Auth, [this, socket], true);
+        if (val.length == 0) {
+          return common.Utils.generateUID();
+        }
+        return val[val.length - 1];
+      };
+      const transport = new Transport(io, {
+        timeoutDisconnect,
+        auth
+      });
+      this.world.timeoutDisconnect = timeoutDisconnect;
+      transport.onConnected(this.onPlayerConnected.bind(this));
+      transport.onDisconnected(this.onPlayerDisconnected.bind(this));
+      return transport;
+    }
     get tick() {
       return this.scheduler.tick;
     }
@@ -19647,7 +20023,7 @@
      * @memberof RpgServerEngine
      */
     send() {
-      this.world.send();
+      return this.world.send();
     }
     async updatePlayersMove(deltaTimeInt) {
       const players = this.world.getUsers();
@@ -19711,7 +20087,7 @@
         maps: this.inputOptions.maps,
         events: this.inputOptions.events,
         worldMaps: this.inputOptions.worldMaps
-      }, this));
+      }));
     }
     getScene(name) {
       return this.scenes.get(name);
@@ -19735,13 +20111,52 @@
     sendToPlayer(currentPlayer, eventName, data) {
       currentPlayer._socket.emit(eventName, data);
     }
-    onPlayerConnected(socket) {
-      const {
-        token
-      } = socket.handshake.auth;
-      const playerId = common.Utils.generateUID();
-      const player = new RpgPlayer(this.gameEngine, playerId);
-      player.session = token;
+    getPlayerBySession(session) {
+      const users = this.world.getUsers();
+      for (let userId in users) {
+        const user = users[userId];
+        if (user.session === session) {
+          return user;
+        }
+      }
+      return null;
+    }
+    onPlayerConnected(socket, playerId) {
+      const existingUser = this.world.getUser(playerId, false);
+      this.world.connectUser(socket, playerId);
+      let player;
+      if (!existingUser) {
+        const {
+          token
+        } = socket.handshake.auth;
+        player = new RpgPlayer(playerId);
+        player.session = token;
+        this.world.setUser(player, socket);
+        player._init();
+        if (!token) {
+          const newToken = common.Utils.generateUID() + "-" + common.Utils.generateUID() + "-" + common.Utils.generateUID();
+          player.session = newToken;
+        }
+        if (!token) {
+          player.execMethod("onConnected");
+        } else {
+          common.RpgPlugin.emit(common.HookServer.ScalabilityPlayerConnected, player);
+        }
+      } else {
+        player = existingUser;
+        if (player.map) {
+          player.emit("preLoadScene", {
+            reconnect: true,
+            id: player.map
+          });
+          player.emitSceneMap();
+          this.world.joinRoom(player.map, playerId);
+        }
+      }
+      socket.emit("playerJoined", {
+        playerId,
+        session: player.session
+      });
       socket.on("move", (data) => {
         if (!(data == null ? void 0 : data.input))
           return;
@@ -19758,25 +20173,6 @@
           });
         }
       });
-      socket.on("disconnect", () => {
-        this.onPlayerDisconnected(playerId);
-      });
-      this.world.setUser(player, socket);
-      player.server = this;
-      player._init();
-      if (!token) {
-        const newToken = common.Utils.generateUID() + "-" + common.Utils.generateUID() + "-" + common.Utils.generateUID();
-        player.session = newToken;
-      }
-      socket.emit("playerJoined", {
-        playerId,
-        session: player.session
-      });
-      if (!token) {
-        player.execMethod("onConnected");
-      } else {
-        common.RpgPlugin.emit(common.HookServer.ScalabilityPlayerConnected, player);
-      }
     }
     onPlayerDisconnected(playerId) {
       const player = World.getUser(playerId);
@@ -21787,7 +22183,7 @@
       this.callback = options2.callback;
     }
     async getServer(player) {
-      const currentServerId = player.server.serverId;
+      const currentServerId = inject(RpgServerEngine).serverId;
       const payload = {
         playerId: player.id,
         mapName: player.map
@@ -21816,7 +22212,9 @@
     }
   }
   async function entryPoint(modules, options2) {
-    const gameEngine = new common.RpgCommonGame(common.GameSide.Server);
+    const context = new common.InjectContext();
+    setInject(context);
+    inject(common.RpgCommonGame, [common.GameSide.Server]);
     if (!options2.globalConfig)
       options2.globalConfig = {};
     const relations = {
@@ -21834,7 +22232,8 @@
     };
     const relationsEngine = {
       onStart: common.HookServer.Start,
-      onStep: common.HookServer.Step
+      onStep: common.HookServer.Step,
+      auth: common.HookServer.Auth
     };
     const {
       playerProps
@@ -21872,7 +22271,7 @@
       }
       return mod;
     });
-    const serverEngine = new RpgServerEngine(options2.io, gameEngine, {
+    const serverEngine = inject(RpgServerEngine, [options2.io, {
       debug: {},
       updateRate: 10,
       stepRate: 60,
@@ -21880,7 +22279,7 @@
       countConnections: false,
       playerProps,
       ...options2
-    });
+    }]);
     return serverEngine;
   }
   function EventData(options2) {
@@ -21996,5 +22395,6 @@
   exports2.RpgWorldMaps = RpgWorldMaps;
   exports2.Speed = Speed;
   exports2.entryPoint = entryPoint;
+  exports2.inject = inject;
   Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
 });