@rpgjs/server 4.1.3 → 4.2.1

package/src/entry-point.ts

@@ -1,7 +1,8 @@
-import { RpgCommonGame, HookServer, loadModules, ModuleType, GameSide, RpgPlugin } from '@rpgjs/common'
+import { RpgCommonGame, HookServer, loadModules, ModuleType, GameSide, RpgPlugin, InjectContext } from '@rpgjs/common'
 import { RpgServerEngine } from './server'
 import { RpgPlayer } from './Player/Player'
 import { RpgMatchMaker } from './MatchMaker'
+import { inject, setInject } from './inject'
 
 interface RpgServerEntryPointOptions {
     /** 
@@ -39,7 +40,10 @@ interface RpgServerEntryPointOptions {
 }
 
 export default async function (modules: ModuleType[], options: RpgServerEntryPointOptions): Promise<RpgServerEngine> {
-    const gameEngine = new RpgCommonGame(GameSide.Server)
+    const context = new InjectContext()
+    setInject(context)
+
+    inject(RpgCommonGame, [GameSide.Server])
 
     if (!options.globalConfig) options.globalConfig = {}
 
@@ -59,7 +63,8 @@ export default async function (modules: ModuleType[], options: RpgServerEntryPoi
 
     const relationsEngine = {
         onStart: HookServer.Start,
-        onStep: HookServer.Step
+        onStep: HookServer.Step,
+        auth: HookServer.Auth
     }
 
     const { playerProps } = await loadModules(modules, {
@@ -91,14 +96,16 @@ export default async function (modules: ModuleType[], options: RpgServerEntryPoi
         return mod
     })
 
-    const serverEngine = new RpgServerEngine(options.io, gameEngine, {
-        debug: {},
-        updateRate: 10,
-        stepRate: 60,
-        timeoutInterval: 0,
-        countConnections: false,
-        playerProps,
-        ...options
-    })
+    const serverEngine = inject(RpgServerEngine, [
+        options.io, {
+            debug: {},
+            updateRate: 10,
+            stepRate: 60,
+            timeoutInterval: 0,
+            countConnections: false,
+            playerProps,
+            ...options
+        }
+    ])
     return serverEngine
 }

package/src/express/server.ts

@@ -83,15 +83,5 @@ export function expressServer(modules: ModuleType[], options: ExpressServerOptio
         process.on('unhandledRejection', function (reason: any) {
             console.log(pe.render(reason))
         })
-
-        if (import.meta['hot']) {
-            import.meta['hot'].on("vite:beforeFullReload", () => {
-                server.close()
-                Query.getPlayers().forEach(player => {
-                    player.gameReload()
-                })
-                rpgGame.stop()
-            });
-        }
     })
 }

package/src/index.ts

@@ -28,3 +28,4 @@ export { RpgMatchMaker } from './MatchMaker'
 export type { IStoreState } from './Interfaces/StateStore'
 export { Components } from './Player/ComponentManager'
 export { Gui } from './Gui/Gui'
+export { inject } from './inject'

package/src/inject.ts

@@ -0,0 +1,33 @@
+import { InjectContext } from "@rpgjs/common";
+
+let instanceContext: InjectContext | null = null
+
+/**
+ * Dependency injection function for RPGJS server side.
+ * 
+ * The server-side `inject` function is designed for retrieving instances of server-related classes in the RPGJS framework. 
+ * This function is crucial for accessing singleton instances of classes like `RpgServerEngine` on the server. It facilitates 
+ * a clean and efficient approach to handling dependencies within server modules, contributing to a more organized codebase.
+ *
+ * @template T The class type that you want to retrieve an instance of, specific to server-side modules.
+ * @returns {T} Returns the singleton instance of the specified class, ensuring consistent server-side behavior and state management.
+ * @since 4.2.0
+ *
+ * @example
+ * ```ts
+ * // Example of injecting the RpgServerEngine
+ * import { inject, RpgServerEngine } from '@rpgjs/server'
+ * const server = inject(RpgServerEngine)
+ * ```
+ */
+export function inject<T>(service: new (...args: any[]) => T, args: any[] = []): T {
+    return instanceContext!.inject(service, args);
+}
+
+export function setInject(context: InjectContext) {
+    instanceContext = context;
+}
+
+export function clearInject() {
+    instanceContext = null
+}

package/src/server.ts

@@ -2,11 +2,12 @@ import { SceneMap } from './Scenes/Map';
 import { RpgPlayer } from './Player/Player'
 import { Query } from './Query'
 import { DAMAGE_SKILL, DAMAGE_PHYSIC, DAMAGE_CRITICAL, COEFFICIENT_ELEMENTS } from './presets'
-import { World, WorldClass } from 'simple-room'
+import { World, WorldClass, Transport } from 'simple-room'
 import { Utils, RpgPlugin, Scheduler, HookServer, RpgCommonGame, DefaultInput } from '@rpgjs/common'
 import { Observable } from 'rxjs';
 import { Tick } from '@rpgjs/types';
 import { Actor, Armor, Class, DatabaseTypes, Item, Skill, State, Weapon } from '@rpgjs/database';
+import { inject } from './inject';
 
 export class RpgServerEngine {
 
@@ -49,10 +50,13 @@ export class RpgServerEngine {
     protected totalConnected: number = 0
     private scheduler: Scheduler = new Scheduler()
     private playerProps: any
+    public gameEngine: RpgCommonGame = inject(RpgCommonGame)
 
     world: WorldClass = World
     workers: any
     envs: any = {}
+    io: any
+    inputOptions: any = {}
 
     /**
      * Combat formulas
@@ -60,7 +64,9 @@ export class RpgServerEngine {
      * @prop {Socket Io Server} [io]
      * @memberof RpgServerEngine
      */
-    constructor(public io, public gameEngine: RpgCommonGame, public inputOptions) {
+    initialize(io, inputOptions) {
+        this.io = io
+        this.inputOptions = inputOptions
         this.envs = inputOptions.envs || {}
         if (this.inputOptions.workers) {
             console.log('workers enabled')
@@ -237,10 +243,31 @@ export class RpgServerEngine {
                 return Query._getShapesOfMap(map)
             }
         })
-        this.io.on('connection', this.onPlayerConnected.bind(this))
+        //this.io.on('connection', this.onPlayerConnected.bind(this))
+        this.transport(this.io)
         await RpgPlugin.emit(HookServer.Start, this)
     }
 
+    private transport(io): Transport {
+        const timeoutDisconnect = this.globalConfig.timeoutDisconnect ?? 0
+        const auth = this.globalConfig.disableAuth ? () => Utils.generateUID() :
+            async (socket) => {
+                const val = await RpgPlugin.emit(HookServer.Auth, [this, socket], true)
+                if (val.length == 0) {
+                    return 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(): Observable<Tick> {
         return this.scheduler.tick as any
     }
@@ -253,8 +280,8 @@ export class RpgServerEngine {
      * @returns {void}
      * @memberof RpgServerEngine
      */
-    send() {
-        this.world.send()
+    send(): Promise<void> {
+        return this.world.send()
     }
 
     private async updatePlayersMove(deltaTimeInt: number) {
@@ -266,7 +293,7 @@ export class RpgServerEngine {
             if (!playerInstance) continue
             const player = playerInstance.otherPossessedPlayer ?? playerInstance
             if (player.pendingMove.length > 0) {
-                player.moving = true
+                
                 const lastFrame = player.pendingMove[player.pendingMove.length - 1]
                 if (this.inputOptions.workers) obj.push(player.toObject())
                 else {
@@ -320,8 +347,7 @@ export class RpgServerEngine {
                 maps: this.inputOptions.maps,
                 events: this.inputOptions.events,
                 worldMaps: this.inputOptions.worldMaps
-            },
-            this
+            }
         ))
     }
 
@@ -351,11 +377,58 @@ export class RpgServerEngine {
         currentPlayer._socket.emit(eventName, data)
     }
 
-    private onPlayerConnected(socket) {
-        const { token } = socket.handshake.auth
-        const playerId = Utils.generateUID()
-        const player: RpgPlayer = new RpgPlayer(this.gameEngine, playerId)
-        player.session = token
+    private getPlayerBySession(session: string): RpgPlayer | null {
+        const users = this.world.getUsers<RpgPlayer>()
+        for (let userId in users) {
+            const user = users[userId]
+            if (user.session === session) {
+                return user
+            }
+        }
+        return null
+    }
+
+    private onPlayerConnected(socket, playerId: string) {
+        const existingUser = this.world.getUser<RpgPlayer>(playerId, false)
+
+        this.world.connectUser(socket, playerId)
+
+        let player: RpgPlayer
+
+        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.generateUID() + '-' + Utils.generateUID() + '-' + Utils.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: { input: string[], frame: number }) => {
             if (!data?.input) return
@@ -372,28 +445,6 @@ export class RpgServerEngine {
             }
         })
 
-        socket.on('disconnect', () => {
-            this.onPlayerDisconnected(playerId)
-        })
-
-        this.world.setUser(player, socket)
-
-        player.server = this
-        player._init()
-
-        if (!token) {
-            const newToken = Utils.generateUID() + '-' + Utils.generateUID() + '-' + Utils.generateUID()
-            player.session = newToken
-        }
-
-        socket.emit('playerJoined', { playerId, session: player.session })
-
-        if (!token) {
-            player.execMethod('onConnected')
-        }
-        else {
-            RpgPlugin.emit(HookServer.ScalabilityPlayerConnected, player)
-        }
     }
 
     private onPlayerDisconnected(playerId: string) {