@rpgjs/server 4.1.2 → 4.2.0

package/browser/rpg.server.js

@@ -1,135 +1,6 @@
-import { Utils as Utils$1, EventEmitter as EventEmitter$1, Direction as Direction$1, LiteralDirection, PrebuiltGui, RpgCommonPlayer, RpgCommonMap, RpgPlugin, RpgCommonWorldMaps, HookServer, Scheduler, DefaultInput, RpgCommonGame, GameSide, loadModules } from "@rpgjs/common";
+import { Utils as Utils$1, EventEmitter as EventEmitter$1, Direction as Direction$1, LiteralDirection, PrebuiltGui, RpgCommonPlayer, RpgCommonGame, RpgCommonMap, RpgPlugin, RpgCommonWorldMaps, HookServer, Scheduler, DefaultInput, InjectContext, GameSide, loadModules } from "@rpgjs/common";
 import { AbstractObject, Control, Direction, HookClient, HookServer as HookServer2, Input, RpgModule, RpgPlugin as RpgPlugin2, RpgShape, ShapePositioning } from "@rpgjs/common";
 import { Effect, ClassHooks, Actor, State, Class, Skill, Armor, Weapon, Item as Item$1 } from "@rpgjs/database";
-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 isObject(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) {
@@ -160,25 +31,90 @@ class Utils {
     };
     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, i) => (
-        // Iterate all of them except the last one
-        Object(a[c2]) === a[c2] ? a[c2] : a[c2] = Math.abs(path2[i + 1]) >> 0 === +path2[i + 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 i = 0; i < len - 1; i++) {
+      let segment = path2[i];
+      let nextSegment = path2[i + 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 = {};
@@ -3754,16 +3690,17 @@ class Packet {
   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;
@@ -3794,104 +3731,183 @@ class TransmitterClass {
       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;
@@ -3914,7 +3930,8 @@ class Room {
   }
   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) => {
@@ -3924,19 +3941,31 @@ class Room {
       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) {
@@ -3970,7 +3999,7 @@ class Room {
             }
             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) {
@@ -4002,6 +4031,7 @@ class Room {
             const { fullPath: p, infoDict, genericPath } = getInfoDict(path3, key, dictPath);
             if (typeof val2 == "object" && infoDict) {
               val2 = deepProxy(val2, p, genericPath);
+              proxifiedObjects.add(val2);
             }
             return val2;
           };
@@ -4026,7 +4056,7 @@ class Room {
     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)
@@ -4052,16 +4082,20 @@ class Room {
     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) => {
@@ -4070,6 +4104,7 @@ class Room {
     room.$clearCurrentState = () => {
       this.memoryObject = {};
     };
+    room.$parent = this;
     this.proxyRoom = room = this.setProxy(room);
     if (this.proxyRoom["onInit"])
       this.proxyRoom["onInit"]();
@@ -4077,52 +4112,59 @@ class Room {
   }
   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);
     }
@@ -4146,28 +4188,6 @@ class TransportCommon {
     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;
@@ -5056,12 +5076,132 @@ var BehaviorSubject = function(_super) {
   };
   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
@@ -5072,32 +5212,48 @@ class WorldClass {
   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
@@ -5116,7 +5272,7 @@ class WorldClass {
    * @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) {
@@ -5155,29 +5311,32 @@ class WorldClass {
     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();
   }
   /**
@@ -5186,10 +5345,23 @@ class WorldClass {
    * @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);
@@ -5203,18 +5375,52 @@ class WorldClass {
    * @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;
   }
   /**
@@ -5224,7 +5430,7 @@ class WorldClass {
    * @param {string} userId
    * @returns {RoomClass | undefined}
    */
-  leaveRoom(roomId, userId) {
+  async leaveRoom(roomId, userId) {
     return this.joinOrLeaveRoom("$leave", roomId, userId);
   }
   /**
@@ -5234,7 +5440,7 @@ class WorldClass {
    * @param {string} userId
    * @returns {RoomClass | undefined}
    */
-  joinRoom(roomId, userId) {
+  async joinRoom(roomId, userId) {
     return this.joinOrLeaveRoom("$join", roomId, userId);
   }
   /**
@@ -5264,12 +5470,15 @@ class WorldClass {
    * @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;
   }
   /**
@@ -5303,11 +5512,132 @@ class WorldClass {
    * 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";
@@ -12446,7 +12776,7 @@ var lodash_merge = {
       return func(value);
     };
   }
-  function getValue2(object, key) {
+  function getValue(object, key) {
     return object == null ? void 0 : object[key];
   }
   function overArg(func, transform) {
@@ -12482,7 +12812,7 @@ var lodash_merge = {
     function object() {
     }
     return function(proto) {
-      if (!isObject3(proto)) {
+      if (!isObject2(proto)) {
         return {};
       }
       if (objectCreate) {
@@ -12715,7 +13045,7 @@ var lodash_merge = {
     return isObjectLike(value) && baseGetTag(value) == argsTag;
   }
   function baseIsNative(value) {
-    if (!isObject3(value) || isMasked(value)) {
+    if (!isObject2(value) || isMasked(value)) {
       return false;
     }
     var pattern = isFunction2(value) ? reIsNative : reIsHostCtor;
@@ -12725,7 +13055,7 @@ var lodash_merge = {
     return isObjectLike(value) && isLength(value.length) && !!typedArrayTags[baseGetTag(value)];
   }
   function baseKeysIn(object) {
-    if (!isObject3(object)) {
+    if (!isObject2(object)) {
       return nativeKeysIn(object);
     }
     var isProto = isPrototype(object), result = [];
@@ -12742,7 +13072,7 @@ var lodash_merge = {
     }
     baseFor(source, function(srcValue, key) {
       stack || (stack = new Stack());
-      if (isObject3(srcValue)) {
+      if (isObject2(srcValue)) {
         baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack);
       } else {
         var newValue = customizer ? customizer(safeGet(object, key), srcValue, key + "", object, source, stack) : void 0;
@@ -12782,7 +13112,7 @@ var lodash_merge = {
         newValue = objValue;
         if (isArguments(objValue)) {
           newValue = toPlainObject(objValue);
-        } else if (!isObject3(objValue) || isFunction2(objValue)) {
+        } else if (!isObject2(objValue) || isFunction2(objValue)) {
           newValue = initCloneObject(srcValue);
         }
       } else {
@@ -12885,7 +13215,7 @@ var lodash_merge = {
     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) {
@@ -12914,7 +13244,7 @@ var lodash_merge = {
     return !!length && (type == "number" || type != "symbol" && reIsUint.test(value)) && (value > -1 && value % 1 == 0 && value < length);
   }
   function isIterateeCall(value, index2, object) {
-    if (!isObject3(object)) {
+    if (!isObject2(object)) {
       return false;
     }
     var type = typeof index2;
@@ -13017,7 +13347,7 @@ var lodash_merge = {
   }
   var isBuffer2 = nativeIsBuffer || stubFalse;
   function isFunction2(value) {
-    if (!isObject3(value)) {
+    if (!isObject2(value)) {
       return false;
     }
     var tag = baseGetTag(value);
@@ -13026,7 +13356,7 @@ var lodash_merge = {
   function isLength(value) {
     return typeof value == "number" && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
   }
-  function isObject3(value) {
+  function isObject2(value) {
     var type = typeof value;
     return value != null && (type == "object" || type == "function");
   }
@@ -17593,7 +17923,6 @@ class EventManager {
   }
   // @internal
   removeObject(object, mode = "shared") {
-    var _a;
     const map = this.getCurrentMap();
     if (!map)
       return;
@@ -17612,7 +17941,7 @@ class EventManager {
       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);
       }
     }
@@ -17621,6 +17950,13 @@ class EventManager {
     }
   }
 }
+let instanceContext = null;
+function inject(service, args = []) {
+  return instanceContext.inject(service, args);
+}
+function setInject(context) {
+  instanceContext = context;
+}
 const {
   isPromise,
   applyMixins,
@@ -17680,7 +18016,7 @@ const playerSchemas = {
   sp: Number,
   gold: Number,
   level: {
-    $effects: ["$this.expForNextlevel"]
+    $effects: ["$this.expForNextlevel", "$this.param"]
   },
   expForNextlevel: {
     $permanent: false
@@ -17742,8 +18078,9 @@ const layoutObject = {
   lines: []
 };
 const _RpgPlayer = class extends RpgCommonPlayer {
-  constructor(gameEngine, playerId) {
-    super(gameEngine, playerId);
+  constructor(playerId) {
+    super(inject(RpgCommonGame), playerId);
+    this.playerId = playerId;
     this.type = "player";
     this.layout = {
       top: layoutObject,
@@ -17759,8 +18096,9 @@ const _RpgPlayer = class extends RpgCommonPlayer {
     this.touchSide = false;
     this.tmpPositions = null;
     this.otherPossessedPlayer = null;
-    this.following = null;
+    this.followingId = null;
     this._dataLoading = false;
+    this.gameEngine = inject(RpgCommonGame);
     this.teleported = 0;
     this.deleted = false;
     this.initialize();
@@ -17775,6 +18113,7 @@ const _RpgPlayer = class extends RpgCommonPlayer {
   }
   /** @internal */
   initialize() {
+    this.server = inject(RpgServerEngine);
     this.expCurve = {
       basis: 30,
       extra: 20,
@@ -18127,7 +18466,7 @@ const _RpgPlayer = class extends RpgCommonPlayer {
   toJSON() {
     const {
       permanentObject
-    } = Room.toDict(this.schema);
+    } = Room.compileSchema(this.schema);
     const snapshot = Room.extractObjectOfRoom(this, permanentObject);
     snapshot.variables = [...this.variables];
     return snapshot;
@@ -18292,9 +18631,9 @@ const _RpgPlayer = class extends RpgCommonPlayer {
    */
   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,
@@ -18478,8 +18817,8 @@ RpgPlayer.schemas = {
 };
 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;
@@ -18632,6 +18971,20 @@ class RpgMap extends RpgCommonMap {
   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 (RpgCommonMap.buffer.has(this.id)) {
@@ -18916,7 +19269,6 @@ class RpgMap extends RpgCommonMap {
     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)
@@ -19018,11 +19370,11 @@ var __decorateClass$1 = (decorators, target, key, kind) => {
   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,
@@ -19229,7 +19581,9 @@ class SceneMap {
       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()]);
@@ -19440,16 +19794,7 @@ var __decorateClass = (decorators, target, key, kind) => {
   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 = {};
@@ -19457,8 +19802,20 @@ class RpgServerEngine {
     this.scenes = /* @__PURE__ */ new Map();
     this.totalConnected = 0;
     this.scheduler = new Scheduler();
+    this.gameEngine = inject(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");
@@ -19492,15 +19849,16 @@ class RpgServerEngine {
     if (!this.inputOptions.database)
       this.inputOptions.database = {};
     const datas = await RpgPlugin.emit(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();
   }
@@ -19631,9 +19989,27 @@ class RpgServerEngine {
         return Query._getShapesOfMap(map);
       }
     });
-    this.io.on("connection", this.onPlayerConnected.bind(this));
+    this.transport(this.io);
     await RpgPlugin.emit(HookServer.Start, this);
   }
+  transport(io) {
+    const timeoutDisconnect = this.globalConfig.timeoutDisconnect ?? 0;
+    const auth = this.globalConfig.disableAuth ? () => Utils$1.generateUID() : async (socket) => {
+      const val = await RpgPlugin.emit(HookServer.Auth, [this, socket], true);
+      if (val.length == 0) {
+        return Utils$1.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;
   }
@@ -19646,7 +20022,7 @@ class RpgServerEngine {
    * @memberof RpgServerEngine
    */
   send() {
-    this.world.send();
+    return this.world.send();
   }
   async updatePlayersMove(deltaTimeInt) {
     const players = this.world.getUsers();
@@ -19710,7 +20086,7 @@ class RpgServerEngine {
       maps: this.inputOptions.maps,
       events: this.inputOptions.events,
       worldMaps: this.inputOptions.worldMaps
-    }, this));
+    }));
   }
   getScene(name) {
     return this.scenes.get(name);
@@ -19734,13 +20110,52 @@ class RpgServerEngine {
   sendToPlayer(currentPlayer, eventName, data) {
     currentPlayer._socket.emit(eventName, data);
   }
-  onPlayerConnected(socket) {
-    const {
-      token
-    } = socket.handshake.auth;
-    const playerId = Utils$1.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 = Utils$1.generateUID() + "-" + Utils$1.generateUID() + "-" + Utils$1.generateUID();
+        player.session = newToken;
+      }
+      if (!token) {
+        player.execMethod("onConnected");
+      } else {
+        RpgPlugin.emit(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;
@@ -19757,25 +20172,6 @@ class RpgServerEngine {
         });
       }
     });
-    socket.on("disconnect", () => {
-      this.onPlayerDisconnected(playerId);
-    });
-    this.world.setUser(player, socket);
-    player.server = this;
-    player._init();
-    if (!token) {
-      const newToken = Utils$1.generateUID() + "-" + Utils$1.generateUID() + "-" + Utils$1.generateUID();
-      player.session = newToken;
-    }
-    socket.emit("playerJoined", {
-      playerId,
-      session: player.session
-    });
-    if (!token) {
-      player.execMethod("onConnected");
-    } else {
-      RpgPlugin.emit(HookServer.ScalabilityPlayerConnected, player);
-    }
   }
   onPlayerDisconnected(playerId) {
     const player = World.getUser(playerId);
@@ -19821,7 +20217,7 @@ function isArrayBufferView(val) {
 const isString = typeOfTest("string");
 const isFunction = typeOfTest("function");
 const isNumber = typeOfTest("number");
-const isObject2 = (thing) => thing !== null && typeof thing === "object";
+const isObject = (thing) => thing !== null && typeof thing === "object";
 const isBoolean = (thing) => thing === true || thing === false;
 const isPlainObject = (val) => {
   if (kindOf(val) !== "object") {
@@ -19834,7 +20230,7 @@ const isDate = kindOfTest("Date");
 const isFile = kindOfTest("File");
 const isBlob = kindOfTest("Blob");
 const isFileList = kindOfTest("FileList");
-const isStream = (val) => isObject2(val) && isFunction(val.pipe);
+const isStream = (val) => isObject(val) && isFunction(val.pipe);
 const isFormData = (thing) => {
   let kind;
   return thing && (typeof FormData === "function" && thing instanceof FormData || isFunction(thing.append) && ((kind = kindOf(thing)) === "formdata" || // detect form-data instance
@@ -20073,7 +20469,7 @@ function isSpecCompliantForm(thing) {
 const toJSONObject = (obj) => {
   const stack = new Array(10);
   const visit = (source, i) => {
-    if (isObject2(source)) {
+    if (isObject(source)) {
       if (stack.indexOf(source) >= 0) {
         return;
       }
@@ -20101,7 +20497,7 @@ const utils = {
   isString,
   isNumber,
   isBoolean,
-  isObject: isObject2,
+  isObject,
   isPlainObject,
   isUndefined,
   isDate,
@@ -21786,7 +22182,7 @@ class RpgMatchMaker {
     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
@@ -21815,7 +22211,9 @@ class RpgMatchMaker {
   }
 }
 async function entryPoint(modules, options2) {
-  const gameEngine = new RpgCommonGame(GameSide.Server);
+  const context = new InjectContext();
+  setInject(context);
+  inject(RpgCommonGame, [GameSide.Server]);
   if (!options2.globalConfig)
     options2.globalConfig = {};
   const relations = {
@@ -21833,7 +22231,8 @@ async function entryPoint(modules, options2) {
   };
   const relationsEngine = {
     onStart: HookServer.Start,
-    onStep: HookServer.Step
+    onStep: HookServer.Step,
+    auth: HookServer.Auth
   };
   const {
     playerProps
@@ -21871,7 +22270,7 @@ async function entryPoint(modules, options2) {
     }
     return mod;
   });
-  const serverEngine = new RpgServerEngine(options2.io, gameEngine, {
+  const serverEngine = inject(RpgServerEngine, [options2.io, {
     debug: {},
     updateRate: 10,
     stepRate: 60,
@@ -21879,7 +22278,7 @@ async function entryPoint(modules, options2) {
     countConnections: false,
     playerProps,
     ...options2
-  });
+  }]);
   return serverEngine;
 }
 function EventData(options2) {
@@ -21965,5 +22364,6 @@ export {
   RpgWorldMaps,
   ShapePositioning,
   Speed,
-  entryPoint
+  entryPoint,
+  inject
 };