update

apps/client/assets/Scripts/UI/PlayerManager.ts

@@ -1,19 +1,20 @@
-import { _decorator, Component, Node, Label } from "cc";
+import { _decorator, Component, Node, Label } from "cc"
-import DataManager from "../Global/DataManager";
+import { IPlayer } from "../Common"
-const { ccclass, property } = _decorator;
+import DataManager from "../Global/DataManager"
+const { ccclass, property } = _decorator
 
 @ccclass("PlayerManager")
 export class PlayerManager extends Component {
-  init({ id, nickname, rid }: { id: number; nickname: string; rid: number }) {
+  init({ id, nickname, rid }: IPlayer) {
-    const label = this.getComponent(Label);
+    const label = this.getComponent(Label)
-    let str = nickname;
+    let str = nickname
     if (DataManager.Instance.myPlayerId === id) {
-      str += `(我)`;
+      str += `(我)`
     }
-    if (rid !== -1) {
+    if (rid) {
-      str += `(房间${rid})`;
+      str += `(房间${rid})`
     }
-    label.string = str;
+    label.string = str
-    this.node.active = true;
+    this.node.active = true
   }
 }

apps/client/assets/Scripts/UI/RoomManager.ts

@@ -1,19 +1,20 @@
-import { _decorator, Component, Node, Label } from "cc";
+import { _decorator, Component, Node, Label } from "cc"
-import { EventEnum } from "../Enum";
+import { IRoom } from "../Common"
-import EventManager from "../Global/EventManager";
+import { EventEnum } from "../Enum"
-const { ccclass, property } = _decorator;
+import EventManager from "../Global/EventManager"
+const { ccclass, property } = _decorator
 
 @ccclass("RoomManager")
 export class RoomManager extends Component {
-  id: number;
+  id: number
-  init({ id, players }: { id: number; players: Array<{ id: number; nickname: string }> }) {
+  init({ id, players }: IRoom) {
-    this.id = id;
+    this.id = id
-    const label = this.getComponent(Label);
+    const label = this.getComponent(Label)
-    label.string = `房间id:${id},当前人数:${players.length}`;
+    label.string = `房间id:${id},当前人数:${players.length}`
-    this.node.active = true;
+    this.node.active = true
   }
 
   handleClick() {
-    EventManager.Instance.emit(EventEnum.RoomJoin, this.id);
+    EventManager.Instance.emit(EventEnum.RoomJoin, this.id)
   }
 }

apps/server/src/Core/MyServer.ts

@@ -1,10 +1,10 @@
-import { EventEmitter } from "stream";
+import { EventEmitter } from "stream"
-import WebSocket, { WebSocketServer } from "ws";
+import WebSocket, { WebSocketServer } from "ws"
-import { ApiMsgEnum } from "../Common";
+import { ApiMsgEnum, IModel } from "../Common"
-import { Connection, ConnectionEventEnum } from "./Connection";
+import { Connection, ConnectionEventEnum } from "./Connection"
 
 export interface IMyServerOptions {
-  port: number;
+  port: number
 }
 
 export enum MyServerEventEnum {
@@ -13,51 +13,51 @@ export enum MyServerEventEnum {
 }
 
 export class MyServer extends EventEmitter {
-  wss?: WebSocketServer;
+  wss?: WebSocketServer
-  port: number;
+  port: number
-  connections: Set<Connection> = new Set();
+  connections: Set<Connection> = new Set()
-  apiMap: Map<ApiMsgEnum, Function> = new Map();
+  apiMap: Map<ApiMsgEnum, Function> = new Map()
 
   constructor({ port = 8080 }: Partial<IMyServerOptions>) {
-    super();
+    super()
-    this.port = port;
+    this.port = port
   }
 
   start() {
     return new Promise((resolve, reject) => {
-      this.wss = new WebSocketServer({ port: this.port });
+      this.wss = new WebSocketServer({ port: this.port })
-      this.wss.on("connection", this.handleConnect.bind(this));
+      this.wss.on("connection", this.handleConnect.bind(this))
 
       this.wss.on("error", (e) => {
-        reject(e);
+        reject(e)
-      });
+      })
 
       this.wss.on("close", () => {
-        console.log("MyServer 服务关闭");
+        console.log("MyServer 服务关闭")
-      });
+      })
 
       this.wss.on("listening", () => {
-        resolve(true);
+        resolve(true)
-      });
+      })
-    });
+    })
   }
 
   handleConnect(ws: WebSocket) {
     //初始化
-    const connection = new Connection(this, ws);
+    const connection = new Connection(this, ws)
 
     //向外告知有人来了
-    this.connections.add(connection);
+    this.connections.add(connection)
-    this.emit(MyServerEventEnum.Connect, connection);
+    this.emit(MyServerEventEnum.Connect, connection)
 
     //向外告知有人走了
     connection.on(ConnectionEventEnum.Close, (code: number, reason: string) => {
-      this.connections.delete(connection);
+      this.connections.delete(connection)
-      this.emit(MyServerEventEnum.DisConnect, connection, code, reason);
+      this.emit(MyServerEventEnum.DisConnect, connection, code, reason)
-    });
+    })
   }
 
-  setApi(apiName: ApiMsgEnum, cb: Function) {
+  setApi<T extends keyof IModel["api"]>(name: T, cb: (connection: Connection, args: IModel["api"][T]["req"]) => IModel["api"][T]["res"]) {
-    this.apiMap.set(apiName, cb);
+    this.apiMap.set(name, cb)
   }
 }

apps/server/src/biz/Player.ts

@@ -1,16 +1,14 @@
-import { Connection } from "../Core";
+import { Connection } from "../Core"
 
 export default class Player {
-  id: number;
+  id: number
-  nickname: string;
+  nickname: string
-  connection: Connection;
+  connection: Connection
-  rid: number;
+  rid: number
 
   constructor({ id, nickname, connection }: Pick<Player, "id" | "nickname" | "connection">) {
-    this.id = id;
+    this.id = id
-    this.nickname = nickname;
+    this.nickname = nickname
-    this.connection = connection;
+    this.connection = connection
-    this.connection.playerId = this.id;
-    this.rid = -1;
   }
 }

apps/server/src/biz/PlayerManager.ts

@@ -1,55 +1,54 @@
-import Singleton from "../Base/Singleton";
+import Singleton from "../Base/Singleton"
-import { ApiMsgEnum, IApiPlayerJoinReq } from "../Common";
+import { ApiMsgEnum, IApiPlayerJoinReq } from "../Common"
-import { Connection } from "../Core";
+import { Connection } from "../Core"
-import Player from "./Player";
+import Player from "./Player"
-import RoomManager from "./RoomManager";
+import RoomManager from "./RoomManager"
 export default class PlayerManager extends Singleton {
   static get Instance() {
-    return super.GetInstance<PlayerManager>();
+    return super.GetInstance<PlayerManager>()
   }
 
-  players: Set<Player> = new Set();
+  players: Set<Player> = new Set()
 
-  private nextPlayerId = 1;
+  private nextPlayerId = 1
-  private idMapPlayer: Map<number, Player> = new Map();
+  private idMapPlayer: Map<number, Player> = new Map()
 
   createPlayer({ connection, nickname }: IApiPlayerJoinReq & { connection: Connection }) {
-    const player = new Player({ id: this.nextPlayerId++, connection, nickname });
+    const player = new Player({ id: this.nextPlayerId++, connection, nickname })
-    this.players.add(player);
+    this.players.add(player)
-    this.idMapPlayer.set(player.id, player);
+    this.idMapPlayer.set(player.id, player)
-    return player;
+    return player
   }
 
   removePlayer(uid: number) {
-    const player = this.idMapPlayer.get(uid);
+    const player = this.idMapPlayer.get(uid)
     if (player) {
-      const rid = player.rid;
+      const rid = player.rid
       if (rid !== undefined) {
-        RoomManager.Instance.leaveRoom(rid, uid);
+        RoomManager.Instance.leaveRoom(rid, uid)
-        RoomManager.Instance.syncRooms();
+        RoomManager.Instance.syncRooms()
-        RoomManager.Instance.syncRoom(rid);
+        RoomManager.Instance.syncRoom(rid)
       }
-      this.players.delete(player);
+      this.players.delete(player)
-      this.idMapPlayer.delete(uid);
+      this.idMapPlayer.delete(uid)
-      this.syncPlayers();
     }
   }
 
   getPlayerById(uid: number) {
-    return this.idMapPlayer.get(uid);
+    return this.idMapPlayer.get(uid)
   }
 
   syncPlayers() {
     for (const player of this.players) {
-      player.connection.sendMsg(ApiMsgEnum.MsgPlayerList, { list: this.getPlayersView() });
+      player.connection.sendMsg(ApiMsgEnum.MsgPlayerList, { list: this.getPlayersView() })
     }
   }
 
   getPlayersView(players: Set<Player> = this.players) {
-    return [...players].map((player) => this.getPlayerView(player));
+    return [...players].map((player) => this.getPlayerView(player))
   }
 
   getPlayerView({ id, nickname, rid }: Player) {
-    return { id, nickname, rid };
+    return { id, nickname, rid }
   }
 }

apps/server/src/biz/Room.ts

@@ -1,57 +1,57 @@
-import { ApiMsgEnum, EntityTypeEnum, IClientInput, IMsgClientSync, InputTypeEnum, IState, toFixed } from "../Common";
+import { ApiMsgEnum, EntityTypeEnum, IClientInput, IMsgClientSync, InputTypeEnum, IState, toFixed } from "../Common"
-import { Connection } from "../Core";
+import { Connection } from "../Core"
-import type Player from "./Player";
+import type Player from "./Player"
-import PlayerManager from "./PlayerManager";
+import PlayerManager from "./PlayerManager"
-import RoomManager from "./RoomManager";
+import RoomManager from "./RoomManager"
 
 export default class Room {
-  id: number;
+  id: number
-  players: Set<Player> = new Set();
+  players: Set<Player> = new Set()
 
-  private lastTime?: number;
+  private lastTime?: number
-  private timers: NodeJS.Timer[] = [];
+  private timers: NodeJS.Timer[] = []
-  private pendingInput: Array<IClientInput> = [];
+  private pendingInput: Array<IClientInput> = []
-  private lastPlayerFrameIdMap: Map<number, number> = new Map();
+  private lastPlayerFrameIdMap: Map<number, number> = new Map()
 
   constructor(rid: number) {
-    this.id = rid;
+    this.id = rid
   }
 
   join(uid: number) {
-    const player = PlayerManager.Instance.getPlayerById(uid);
+    const player = PlayerManager.Instance.getPlayerById(uid)
     if (player) {
-      player.rid = this.id;
+      player.rid = this.id
-      this.players.add(player);
+      this.players.add(player)
     }
   }
 
   leave(uid: number) {
-    const player = PlayerManager.Instance.getPlayerById(uid);
+    const player = PlayerManager.Instance.getPlayerById(uid)
     if (player) {
-      player.rid = -1;
+      player.rid = undefined
-      player.connection.unlistenMsg(ApiMsgEnum.MsgClientSync, this.getClientMsg, this);
+      player.connection.unlistenMsg(ApiMsgEnum.MsgClientSync, this.getClientMsg, this)
-      this.players.delete(player);
+      this.players.delete(player)
       if (!this.players.size) {
-        RoomManager.Instance.closeRoom(this.id);
+        RoomManager.Instance.closeRoom(this.id)
       }
     }
   }
 
   close() {
-    this.timers.forEach((t) => clearInterval(t));
+    this.timers.forEach((t) => clearInterval(t))
     for (const player of this.players) {
-      player.rid = -1;
+      player.rid = undefined
-      player.connection.sendMsg(ApiMsgEnum.MsgGameEnd, {});
+      player.connection.sendMsg(ApiMsgEnum.MsgGameEnd, {})
-      player.connection.unlistenMsg(ApiMsgEnum.MsgClientSync, this.getClientMsg, this);
+      player.connection.unlistenMsg(ApiMsgEnum.MsgClientSync, this.getClientMsg, this)
     }
-    this.players.clear();
+    this.players.clear()
   }
 
   sync() {
     for (const player of this.players) {
       player.connection.sendMsg(ApiMsgEnum.MsgRoom, {
         room: RoomManager.Instance.getRoomView(this),
-      });
+      })
     }
   }
 
@@ -75,47 +75,47 @@ export default class Room {
       })),
       bullets: [],
       nextBulletId: 1,
-    };
+    }
 
     for (const player of this.players) {
       player.connection.sendMsg(ApiMsgEnum.MsgGameStart, {
         state,
-      });
+      })
-      player.connection.listenMsg(ApiMsgEnum.MsgClientSync, this.getClientMsg, this);
+      player.connection.listenMsg(ApiMsgEnum.MsgClientSync, this.getClientMsg, this)
     }
     let t1 = setInterval(() => {
-      this.sendServerMsg();
+      this.sendServerMsg()
-    }, 100);
+    }, 100)
     let t2 = setInterval(() => {
-      this.timePast();
+      this.timePast()
-    }, 16);
+    }, 16)
-    this.timers = [t1, t2];
+    this.timers = [t1, t2]
   }
 
   getClientMsg(connection: Connection, { frameId, input }: IMsgClientSync) {
-    this.lastPlayerFrameIdMap.set(connection.playerId, frameId);
+    this.lastPlayerFrameIdMap.set(connection.playerId, frameId)
-    this.pendingInput.push(input);
+    this.pendingInput.push(input)
   }
 
   sendServerMsg() {
-    const pendingInput = this.pendingInput;
+    const pendingInput = this.pendingInput
-    this.pendingInput = [];
+    this.pendingInput = []
 
     for (const player of this.players) {
       player.connection.sendMsg(ApiMsgEnum.MsgServerSync, {
         lastFrameId: this.lastPlayerFrameIdMap.get(player.id) ?? 0,
         inputs: pendingInput,
-      });
+      })
     }
   }
 
   timePast() {
-    let now = process.uptime();
+    let now = process.uptime()
-    const dt = now - (this.lastTime ?? now);
+    const dt = now - (this.lastTime ?? now)
     this.pendingInput.push({
       type: InputTypeEnum.TimePast,
       dt: toFixed(dt),
-    });
+    })
-    this.lastTime = now;
+    this.lastTime = now
   }
 }

apps/server/src/index.ts

@@ -40,6 +40,7 @@ server.on(MyServerEventEnum.DisConnect, (connection: Connection) => {
   console.log(`${getTime()}走人|人数|${server.connections.size}`)
   if (connection.playerId) {
     PlayerManager.Instance.removePlayer(connection.playerId)
+    PlayerManager.Instance.syncPlayers()
   }
 })
 
@@ -50,6 +51,7 @@ server.setApi(ApiMsgEnum.ApiPlayerList, (connection: Connection, data: IApiPlaye
 
 server.setApi(ApiMsgEnum.ApiPlayerJoin, (connection: Connection, { nickname }: IApiPlayerJoinReq): IApiPlayerJoinRes => {
   const player = PlayerManager.Instance.createPlayer({ connection, nickname })
+  connection.playerId = player.id
   PlayerManager.Instance.syncPlayers()
   return {
     player: PlayerManager.Instance.getPlayerView(player),