更新session信息存储

esengine · esengine · commit e7e7bb067a5c · 2023-06-29T15:30:20.000+08:00
diff --git a/README.md b/README.md
@@ -35,6 +35,7 @@ G-Framework 不仅提供了优秀的实体组件系统（ECS）核心，还结
 - [客户端插值](docs/interpolation.md) 提供插值算法，优化客户端帧同步下的状态表现，如平滑移动效果
 - [输入管理器](docs/input-manager.md) 管理游戏输入，如键盘、鼠标和触摸事件，并在合适的时机同步输入状态
 - [游戏同步策略](docs/sync-strategy.md) 针对游戏同步提供了多种策略，如状态插值、状态压缩等，按需选择使用。
+- [对象池](docs/object-pool.md) 提供了一种高效的对象管理方式，通过重用对象来避免频繁的对象创建和销毁，可以用于管理游戏中的实体，如子弹、角色等。
 
 G-Framework 通过提供这些实用模块，让您在游戏开发过程中专注于逻辑实现，更快速地满足项目需求。这些模块针对帧同步做了大量优化，确保您的项目在采用帧同步时获得较佳的性能表现。
 
diff --git a/client-test/dist/gs-client.js b/client-test/dist/gs-client.js
@@ -109,7 +109,7 @@ playerEntity.addComponent(VelocityComponent);
 var moveSystem = new MoveSystem(core.entityManager, 0);
 core.systemManager.registerSystem(moveSystem);
 // 使用你的服务器URL实例化网络适配器
-var networkAdapter = new gs.GNetworkAdapter('ws://localhost:8080', "admin", "admin1");
+var networkAdapter = new gs.GNetworkAdapter('wss://8080-esengine-gframework-i1149hh1fae.ws-us101.gitpod.io\n', "test", "test");
 // 添加网络适配器到EntityManager
 core.entityManager.getNetworkManager().setNetworkAdapter(networkAdapter);
 var lastTimestamp = performance.now();
diff --git a/client-test/lib/gs.js b/client-test/lib/gs.js
@@ -2022,6 +2022,7 @@ var gs;
                     _this.authentication.handleAuthenticationMessage(message);
                 }
                 else {
+                    console.warn("[g-client]: \u672A\u77E5\u7684\u6D88\u606F\u7C7B\u578B: " + message.type);
                 }
             });
         };
diff --git a/client-test/src/index.ts b/client-test/src/index.ts
@@ -13,7 +13,7 @@ const moveSystem = new MoveSystem(core.entityManager, 0);
 core.systemManager.registerSystem(moveSystem);
 
 // 使用你的服务器URL实例化网络适配器
-let networkAdapter = new gs.GNetworkAdapter('ws://localhost:8080', "admin", "admin1");
+let networkAdapter = new gs.GNetworkAdapter('wss://8080-esengine-gframework-i1149hh1fae.ws-us101.gitpod.io\n', "test", "test");
 // 添加网络适配器到EntityManager
 core.entityManager.getNetworkManager().setNetworkAdapter(networkAdapter);
 
diff --git a/docs/object-pool.md b/docs/object-pool.md
@@ -0,0 +1,85 @@
+# `ObjectPool`类的使用指南
+
+## 简介
+
+`ObjectPool`是一个通用的对象池实现，它可以帮助你管理和重复利用对象，从而避免频繁的对象创建和销毁带来的性能开销。在游戏开发、资源管理等需要高效利用内存的场景中，`ObjectPool`可以发挥很大的作用。
+
+## 使用方法
+
+以下是如何使用`ObjectPool`类的详细步骤：
+
+### 1. 创建对象池
+
+首先，你需要提供两个函数：一个用于创建新对象，一个用于重置对象。然后你就可以创建一个`ObjectPool`实例了。
+
+```ts
+const pool = new gs.ObjectPool(
+    () => new SomeClass(),  // createFn: 用于创建新的SomeClass对象
+    (obj) => obj.reset()   // resetFn: 用于重置SomeClass对象的状态
+);
+```
+
+在上面的例子中，SomeClass是你想要管理的对象的类。请确保该类有一个可以重置对象状态的方法（在这个例子中是reset方法）。
+
+### 2. 获取对象
+   当你需要一个对象时，可以使用acquire方法来获取。如果对象池中有可用的对象，acquire方法会取出一个，重置它的状态，然后返回。如果对象池中没有可用的对象，acquire方法会创建一个新的对象然后返回。
+
+```ts
+const obj = pool.acquire();
+```
+
+### 3. 归还对象
+   当你不再需要一个对象时，你可以使用release方法将其归还到对象池中，以便稍后重复使用。
+
+```ts
+pool.release(obj);
+```
+请注意，一旦你调用了release方法归还了一个对象，你就不应再使用该对象，除非你再次通过acquire方法获取到它。
+
+## 示例
+假设你有一个名为Bullet的类，它代表一颗子弹。子弹在游戏中经常被创建和销毁，所以你决定使用ObjectPool来管理它们。
+
+```ts
+class Bullet {
+    x: number;
+    y: number;
+    isAlive: boolean;
+
+    constructor() {
+        this.reset();
+    }
+
+    reset() {
+        this.x = 0;
+        this.y = 0;
+        this.isAlive = false;
+    }
+
+    fire(x: number, y: number) {
+        this.x = x;
+        this.y = y;
+        this.isAlive = true;
+    }
+}
+
+const bulletPool = new gs.ObjectPool(
+    () => new Bullet(), // 创建Bullet对象
+    (bullet) => bullet.reset() // 重置Bullet对象
+);
+
+// 当你需要发射一颗子弹时
+const bullet = bulletPool.acquire();
+bullet.fire(player.x, player.y);
+
+// 当子弹超出屏幕范围时
+if (bullet.x < 0 || bullet.x > screenWidth || bullet.y < 0 || bullet.y > screenHeight) {
+bulletPool.release(bullet);
+}
+```
+
+在这个例子中，Bullet类有一个reset方法，用于重置子弹的状态。你创建了一个用于管理Bullet对象的ObjectPool，并提供了创建和重置Bullet对象的函数。当你需要发射一颗子弹时，你从对象池中获取一个Bullet对象，并调用它的fire方法。当子弹超出屏幕范围时，你将其归还到对象池中。
+
+## 提示
+- 为了获取最佳性能，建议在可能的情况下尽量复用对象池中的对象，而不是频繁地创建和销毁对象。 
+- 当你的resetFn函数被调用时，你应确保该对象的状态被完全重置，以便它可以被安全地重复使用。 
+- 虽然ObjectPool类可以帮你管理对象的生命周期，但你仍需要自己负责管理和跟踪哪些对象正在使用，哪些对象可以归还到对象池中。
diff --git a/server/README.md b/server/README.md
@@ -44,6 +44,8 @@ services.init({
     port: 8080,
     heartbeatInterval: 10000,
     heartbeatTimeout: 30000,
+    connectDBStr: 'mongodb://127.0.0.1:27017/',
+    sessionExpireTime: 54000
 }).then(()=>{
     services.start();
 });
diff --git a/server/src/Communication/Connection.ts b/server/src/Communication/Connection.ts
@@ -85,4 +85,6 @@ export interface Connection {
      * 连接所在的房间 ID。
      */
     roomId?: string;
+
+    sessionId: string;
 }
diff --git a/server/src/Communication/SessionManager.ts b/server/src/Communication/SessionManager.ts
@@ -0,0 +1,24 @@
+import {Connection} from "./Connection";
+
+export class SessionManager {
+    private sessions: Map<string, Connection> = new Map();
+
+    public createSession(connection: Connection): string {
+        const sessionId = this.generateSessionId();
+        connection.sessionId = sessionId;
+        this.sessions.set(sessionId, connection);
+        return sessionId;
+    }
+
+    public getSession(sessionId: string): Connection | undefined {
+        return this.sessions.get(sessionId);
+    }
+
+    public deleteSession(sessionId: string): void {
+        this.sessions.delete(sessionId);
+    }
+
+    private generateSessionId(): string {
+        return Date.now().toString(36) + Math.random().toString(36).substr(2);
+    }
+}
diff --git a/server/src/Communication/WebSocketServerConfig.ts b/server/src/Communication/WebSocketServerConfig.ts
@@ -18,4 +18,6 @@ export interface WebSocketServerConfig {
      * 数据库连接字符串。
      */
     connectDBStr: string;
+
+    sessionExpireTime: number;
 }
diff --git a/server/src/Data/Database.ts b/server/src/Data/Database.ts
@@ -1,5 +1,5 @@
 import * as bcrypt from 'bcrypt';
-import {MongoClient} from 'mongodb';
+import {MongoClient, ServerApiVersion} from 'mongodb';
 import logger from "../ErrorAndLog/Logger";
 import {UserNotExistError, WrongPasswordError} from "../ErrorAndLog/GError";
 
@@ -18,7 +18,13 @@ export class Database {
      * @param collectionName - 集合名
      */
     constructor(connectionStr: string, dbName: string, collectionName: string) {
-        this.db = new MongoClient(connectionStr);
+        this.db = new MongoClient(connectionStr, {
+            serverApi: {
+                version: ServerApiVersion.v1,
+                strict: true,
+                deprecationErrors: true,
+            }
+        });
         this.dbName = dbName;
         this.collectionName = collectionName;
     }
diff --git a/server/src/Service/GServices.ts b/server/src/Service/GServices.ts
@@ -15,6 +15,7 @@ import {ErrorHandler} from "../ErrorAndLog/ErrorHandler";
 import {RoomManager} from "../GameLogic/RoomManager";
 import {UserNotExistError, WrongPasswordError} from "../ErrorAndLog/GError";
 import {Player} from "../GameLogic/Player"
+import {SessionManager} from "../Communication/SessionManager";
 
 /**
  * GServices 类，用于管理服务器的各种服务和功能。
@@ -29,6 +30,7 @@ export class GServices {
     private httpServer!: HTTPServer;
     private webSocketServer!: WebSocketServer;
     private authentication!: Authentication;
+    private sessionManager!: SessionManager;
 
     private static _services: GServices;
     public static I() {
@@ -71,6 +73,7 @@ export class GServices {
         process.on('SIGINT', this.shutdown.bind(this));
         process.on('SIGTERM', this.shutdown.bind(this));
 
+        this.sessionManager = new SessionManager();
         this.authentication = new Authentication(config);
         await this.authentication.DataBase.createConnection();
 
@@ -125,6 +128,9 @@ export class GServices {
      * @param connection - 连接对象。
      */
     public handleClientConnect(connection: Connection): void {
+        const sessionId = this.sessionManager.createSession(connection);
+        // 发送sessionId给客户端
+        WebSocketUtils.sendToConnection(connection, { type: 'sessionId', payload: sessionId });
         // 调用用户自定义的连接建立处理方法
         this.invokeExtensionMethod('onClientConnect', connection);
     }
@@ -134,6 +140,9 @@ export class GServices {
      * @param connection - 连接对象。
      */
     public handleClientDisconnect(connection: Connection): void {
+        // 当客户端断开连接时，我们不立即删除其session
+        // 可以设置一个定时器，在一段时间后删除session
+        setTimeout(() => this.sessionManager.deleteSession(connection.sessionId), this.config.sessionExpireTime);
         // 调用用户自定义的连接断开处理方法
         this.invokeExtensionMethod('onClientDisconnect', connection);
     }
@@ -176,6 +185,12 @@ export class GServices {
      */
     public async handleMessage(connection: Connection, message: Message) {
         try {
+            // 对重连请求进行特殊处理
+            if (message.type === 'reconnect') {
+                this.handleReconnect(connection, message.payload);
+                return;
+            }
+
             if (!connection.isAuthenticated) {
                 // 如果连接还没有经过身份验证，那么它只能发送身份验证消息
                 if (message.type !== 'authentication') {
@@ -199,6 +214,10 @@ export class GServices {
                 } else {
                     // 身份验证通过
                     connection.isAuthenticated = true;
+                    // 获取sessionId
+                    const sessionId = connection.sessionId;
+                    // 发送身份验证消息，带有sessionId
+                    WebSocketUtils.sendToConnection(connection, { type: 'authentication', payload: { sessionId: sessionId }});
                     return;
                 }
 
@@ -214,10 +233,6 @@ export class GServices {
                     // 处理数据消息
                     this.handleDataMessage(connection, message.payload);
                     break;
-                case 'authentication':
-                    // 处理身份验证消息
-                    this.authentication.handleAuthenticationMessage(connection, message);
-                    break;
                 case 'stateUpdate':
                     this.handleStateUpdate(connection, message);
                     break;
@@ -250,6 +265,24 @@ export class GServices {
         this.invokeExtensionMethod('onMessageReceived', connection, message);
     }
 
+    private handleReconnect(connection: Connection, payload: any): void {
+        const { sessionId } = payload;
+        const oldConnection = this.sessionManager.getSession(sessionId);
+        if (oldConnection) {
+            // 重新绑定sessionId到新连接
+            connection.sessionId = sessionId;
+            this.sessionManager.createSession(connection);
+            // 恢复状态
+            connection.state = oldConnection.state;
+            connection.roomId = oldConnection.roomId;
+            // 发送重连成功消息
+            WebSocketUtils.sendToConnection(connection, { type: 'reconnectSuccess', payload: null });
+        } else {
+            // sessionId无效，发送重连失败消息
+            WebSocketUtils.sendToConnection(connection, { type: 'reconnectFail', payload: null });
+        }
+    }
+
     /**
      * 处理状态更新消息。
      * @param connection - 连接对象。
diff --git a/server/test/index.ts b/server/test/index.ts
@@ -6,7 +6,8 @@ services.init({
     port: 8080,
     heartbeatInterval: 1000,
     heartbeatTimeout: 5000,
-    connectDBStr: 'mongodb://127.0.0.1:27017/'
+    connectDBStr: 'mongodb://127.0.0.1:27017/',
+    sessionExpireTime: 54000
 }).then(()=>{
     services.start();
 });
diff --git a/source/bin/gs.d.ts b/source/bin/gs.d.ts
@@ -747,6 +747,8 @@ declare module gs {
         private maxReconnectionAttempts;
         private connection;
         private authentication;
+        private sessionId;
+        private lastKnownState;
         constructor(serverUrl: string, username: string, password: string);
         private connect;
         sendInput(frameNumber: number, inputData: any): void;
diff --git a/source/bin/gs.js b/source/bin/gs.js
@@ -1991,6 +1991,8 @@ var gs;
             this.serverUrl = serverUrl;
             this.reconnectionAttempts = 0;
             this.maxReconnectionAttempts = 10;
+            this.sessionId = null;
+            this.lastKnownState = null;
             this.connection = new gs.Connection(serverUrl);
             this.authentication = new gs.Authentication(this.connection);
             this.connect(username, password);
@@ -2001,7 +2003,15 @@ var gs;
             this.socket.addEventListener('open', function () {
                 console.info('[g-client]: 连接到服务器');
                 _this.reconnectionAttempts = 0;
-                _this.authentication.startAuthentication(username, password);
+                if (_this.sessionId) {
+                    // 发送断线重连请求
+                    var reconnectMsg = { type: 'reconnect', sessionId: _this.sessionId, lastKnownState: _this.lastKnownState };
+                    _this.socket.send(JSON.stringify(reconnectMsg));
+                }
+                else {
+                    // 开始身份验证
+                    _this.authentication.startAuthentication(username, password);
+                }
             });
             this.socket.addEventListener('error', function (error) {
                 console.error('[g-client]: 发生错误:', error);
@@ -2019,9 +2029,17 @@ var gs;
             this.socket.addEventListener('message', function (event) {
                 var message = JSON.parse(event.data);
                 if (message.type === 'authentication') {
+                    _this.sessionId = message.payload.sessionId; // 存储sessionId
                     _this.authentication.handleAuthenticationMessage(message);
                 }
+                else if (message.type === 'sessionId') {
+                    _this.sessionId = message.payload;
+                }
+                else if (message.type === 'stateUpdate') {
+                    _this.lastKnownState = message.payload; // 更新lastKnownState
+                }
                 else {
+                    console.warn("[g-client]: \u672A\u77E5\u7684\u6D88\u606F\u7C7B\u578B: " + message.type);
                 }
             });
         };
diff --git a/source/bin/gs.min.js b/source/bin/gs.min.js
diff --git a/source/src/Network/GNetworkAdapter.ts b/source/src/Network/GNetworkAdapter.ts
@@ -5,6 +5,8 @@ module gs {
         private maxReconnectionAttempts: number = 10;
         private connection: Connection;
         private authentication: Authentication;
+        private sessionId: string | null = null;
+        private lastKnownState: any = null;
 
         constructor(private serverUrl: string, username: string, password: string) {
             this.connection = new Connection(serverUrl);
@@ -19,7 +21,14 @@ module gs {
                 console.info('[g-client]: 连接到服务器');
                 this.reconnectionAttempts = 0;
 
-                this.authentication.startAuthentication(username, password);
+                if (this.sessionId) {
+                    // 发送断线重连请求
+                    const reconnectMsg = { type: 'reconnect', sessionId: this.sessionId, lastKnownState: this.lastKnownState };
+                    this.socket.send(JSON.stringify(reconnectMsg));
+                } else {
+                    // 开始身份验证
+                    this.authentication.startAuthentication(username, password);
+                }
             });
 
             this.socket.addEventListener('error', (error: Event) => {
@@ -39,9 +48,14 @@ module gs {
             this.socket.addEventListener('message', (event) => {
                 const message: Message = JSON.parse(event.data);
                 if (message.type === 'authentication') {
+                    this.sessionId = message.payload.sessionId; // 存储sessionId
                     this.authentication.handleAuthenticationMessage(message);
+                } else if (message.type === 'sessionId') {
+                    this.sessionId = message.payload;
+                } else if (message.type === 'stateUpdate') {
+                    this.lastKnownState = message.payload; // 更新lastKnownState
                 } else {
-
+                    console.warn(`[g-client]: 未知的消息类型: ${message.type}`);
                 }
             });
         }

Original file line number	Diff line number	Diff line change
`@@ -2022,6 +2022,7 @@ var gs;`
`2022`	`2022`	`_this.authentication.handleAuthenticationMessage(message);`
`2023`	`2023`	`}`
`2024`	`2024`	`else {`
	`2025`	`+ console.warn("[g-client]: \u672A\u77E5\u7684\u6D88\u606F\u7C7B\u578B: " + message.type);`
`2025`	`2026`	`}`
`2026`	`2027`	`});`
`2027`	`2028`	`};`
Original file line number	Diff line number	Diff line change
`@@ -85,4 +85,6 @@ export interface Connection {`
`85`	`85`	`* 连接所在的房间 ID。`
`86`	`86`	`*/`
`87`	`87`	`roomId?: string;`
	`88`	`+`
	`89`	`+ sessionId: string;`
`88`	`90`	`}`
Original file line number	Diff line number	Diff line change
`@@ -18,4 +18,6 @@ export interface WebSocketServerConfig {`
`18`	`18`	`* 数据库连接字符串。`
`19`	`19`	`*/`
`20`	`20`	`connectDBStr: string;`
	`21`	`+`
	`22`	`+ sessionExpireTime: number;`
`21`	`23`	`}`