创造你的世界
玩家及角色：进阶
机器人玩家创建指南
15min
机器人玩家用于在没有足够的人开始多人世界时填补空缺，或者当玩家在游戏中离开时。
机器人玩家的行为需要为每个内容实现。
本指南描述了创建机器人玩家的一般方法。
📘 机器人玩家创建指南基于多人游戏指南。 [创建多人游戏]
1-1. 添加一个名为 IsBot 的布尔值到多人游戏架构中。
1-2. 在服务器脚本 index.ts 中定义以下函数以创建一个机器人玩家，并在所需位置调用它。
index.ts
1// `CreateBot()` 方法用于创建一个具有给定 `userId` 的机器人玩家。
2CreateBot(userId: string) {
3
4 // 使用提供的 `userId` 为机器人玩家生成一个会话 ID。
5 const sessionId = "Bot_" + userId;
6
7 // 检查是否已经存在具有相同会话 ID 的机器人玩家。如果是，则返回而不创建重复项。
8 if (this.state.players.has(sessionId)) {
9 return;
10 }
11
12 // 为机器人玩家创建一个新的 `Player` 对象。
13 const player: Player = new Player();
14 player.sessionId = sessionId;
15 if (userId) {
16 player.zepetoUserId = userId;
17 }
18 player.isBot = true;
19
20 // 使用会话 ID 作为键将机器人玩家添加到状态的玩家映射中。
21 this.state.players.set(player.sessionId, player);
22 this._botMap.set(sessionId, player);
23}
👍 提示
- 特定用户的 userId 被提前存储，以便创建机器人角色。
- 您可以通过检查连接到服务器的 OnJoin 的客户端的 userId 来检查特定用户的 UserId。在服务器脚本中编写以下脚本后，从相关世界连接。
index.ts
1onJoin(client: SandboxPlayer) {
2 console.log(client.userId);
3}
2-1. 如果服务器在某个时刻创建了一个机器人玩家，客户端将在 OnJoinPlayer() 中将其识别为新玩家。
- 创建项目 > 创建 > ZEPETO > TypeScript，并将其重命名为 BotPlayerManager。
- 在 OnAddedPlayer() 中添加逻辑以创建每个玩家，并添加逻辑以区分机器人玩家并创建他们的 ZEPETO 角色。
BotPlayerManager.ts
1import { ZepetoCharacter, ZepetoPlayers } from 'ZEPETO.Character.Controller';
2import { Room } from 'ZEPETO.Multiplay';
3import { ZepetoScriptBehaviour } from 'ZEPETO.Script'
4import { ZepetoWorldMultiplay } from 'ZEPETO.World';
5
6export default class BotPlayerManager extends ZepetoScriptBehaviour {
7
8 public zepetoWorldMultiplay: ZepetoWorldMultiplay;
9
10 // 私有变量用于存储当前房间和机器人玩家数据。
11 private _room: Room;
12 private _botMapData: Map<string, ZepetoCharacter> = new Map<string, ZepetoCharacter>();
13
14 Start() {
15
16 // 监听来自 `ZepetoWorldMultiplay` 组件的 `RoomJoined` 事件。
17 this.zepetoWorldMultiplay.RoomJoined += (room: Room) => {
18 this._room = room;
19 }
20
21 // 监听来自 `ZepetoPlayers.instance` 的 `OnAddedPlayer` 事件以处理新添加的玩家。
22 ZepetoPlayers.instance.OnAddedPlayer.AddListener((userId: string) => {
23
24 // 使用 `userId` 从房间状态获取当前玩家数据。
25 const currentPlayer = this._room.State.players.get_Item(userId);
26
27 // 检查玩家是否为机器人，如果是，则将其设置为机器人玩家。
28 if (currentPlayer.isBot) {
29 this.SetBotPlayer(currentPlayer.sessionId);
30 }
31 });
32 }
33}
2-2. 编写 SetBotPlayer 函数，以将标签和同步组件添加到机器人玩家，并创建控制它们的脚本。
- 将 _botMapData 设置为以 Map 格式保存机器人玩家数据，以管理机器人玩家。
BotPlayerManager.ts
1// `SetBotPlayer()` 方法用于将玩家设置为机器人。
2SetBotPlayer(userId: string) {
3
4 // 使用他们的 `userId` 获取与机器人玩家关联的 ZEPETO 角色。
5 const bot = ZepetoPlayers.instance.GetPlayer(userId).character;
6
7 // 将角色的名称设置为 `userId` 以便识别。
8 bot.gameObject.name = userId;
9
10 // 使用他们的 `userId` 作为键，将机器人玩家的数据存储在 `_botMapData` 映射中。
11 this._botMapData.set(userId, bot);
12}
👍 提示 您可以向 SetBotPlayer() 添加额外的脚本或设置，以控制机器人玩家的行为。
对于需要一定数量玩家才能开始的世界，有时玩家数量不足，您必须等待很长时间才能开始游戏。
在这种情况下，您可以通过添加一个机器人玩家来启动世界。
3-1. 在 index.ts 中注册一个函数，当服务器接收到来自客户端的消息时执行 CreateBot()。
TypeScript
1async OnCreate() {
2
3 // 处理 "CreateBot" 消息，该消息使用给定的 userId 创建一个机器人玩家。
4 this.onMessage("CreateBot", (client, message) => {
5 this.CreateBot(message);
6 });
7}
3-2. 在客户端脚本 BotPlayerManager.ts 中，编写一个函数将 "CreateBot" 消息发送到服务器。
- 执行函数的方法是通过按下按钮发送消息。
- 通过消息将要创建的机器人玩家的用户 ID 作为字符串发送。
BotPlayerManager.ts
1public buttonCreateBot: Button;
2public botPlayerId: string;
3
4Start() {
5
6 // 为 "创建机器人" 按钮添加点击监听器，以发送消息以创建一个机器人玩家。
7 this.buttonCreateBot.onClick.AddListener(() => {
8 this._room.Send("CreateBot", this.botPlayerId);
9 });
10}
3-3. 现在，当你运行服务器和运行时，你可以看到当你按下按钮时会创建机器人玩家。
当没有足够的玩家来启动世界时，你可以添加机器人玩家来启动世界。
4-1. 在服务器脚本中，在 OnJoin 期间添加以下代码，以检查玩家数量，并在至少有四名玩家时启动世界。
- 在 CreateBot() 中添加一个函数以检查玩家数量。
- 在 StartWorld() 函数中添加一个计数器以记录游戏次数。
index.ts
1 async onJoin(client: SandboxPlayer) {
2
3 // 在玩家加入后检查房间中的玩家数量。
4 this.CheckPlayerNumber();
5}
6
7// `CheckPlayerNumber()` 方法检查房间中的玩家数量，并在至少有四名玩家时启动世界。
8CheckPlayerNumber() {
9
10 // 将当前房间中的玩家数量打印到控制台。
11 console.log(`玩家数量, ${this.state.players.size}`);
12
13 // 如果房间中至少有四名玩家，则启动世界。
14 if (this.state.players.size >= 4) {
15 this.StartWorld();
16 }
17}
18
19// `CreateBot()` 方法用于创建具有给定 `userId` 的机器人玩家。
20CreateBot(userId: string) {
21
22 // 使用提供的 `userId` 为机器人玩家生成会话 ID。
23 const sessionId = "Bot_" + userId;
24
25 // 检查是否已经存在具有相同会话 ID 的机器人玩家。如果存在，则返回而不创建重复项。
26 if (this.state.players.has(sessionId)) {
27 return;
28 }
29
30 // 为机器人玩家创建一个新的 `Player` 对象。
31 const player: Player = new Player();
32 player.sessionId = sessionId;
33 if (userId) {
34 player.zepetoUserId = userId;
35 }
36 player.isBot = true;
37
38 // 使用会话 ID 作为键将机器人玩家添加到状态的玩家映射中。
39 this.state.players.set(player.sessionId, player);
40 this._botMap.set(sessionId, player);
41
42 // 在添加机器人玩家后检查房间中的玩家数量。
43 this.CheckPlayerNumber();
44}
45
46
47private playTime: number = 0;
48
49// `StartWorld()` 方法增加游戏时间并向所有客户端广播 "StartWorld" 消息。
50StartWorld() {
51 this.playTime += 1;
52
53 // 打印一条消息，指示世界的开始和当前的游戏时间。
54 console.log("开始世界！");
55 this.broadcast("StartWorld", this.playTime);
56}
- 在服务器上，当真实玩家加入房间时，会执行 OnJoin。因此，当通过 CreateBot 创建一个 Bot 玩家时，以及当玩家通过 OnJoin 进入时，checkPlayerNumber() 会增加人数。
4-2. 在客户端脚本 BotPlayerManager.ts 中，编写 StartWorld()，当从服务器接收到 StartWorld 消息时执行。
BotPlayerManager.ts
1Start() {
2
3 // 监听来自 `ZepetoWorldMultiplay` 组件的 `RoomJoined` 事件。
4 this.zepetoWorldMultiplay.RoomJoined += (room: Room) => {
5
6 // 为 "StartWorld" 消息类型添加消息处理程序。
7 this._room.AddMessageHandler("StartWorld", (playTime: number) => {
8 this.StartWorld(playTime);
9 });
10}
11
12// 当世界以提供的 `playTime` 启动时调用 `StartWorld()` 方法。
13StartWorld(playTime: number) {
14
15 // 打印世界启动消息以及 `playTime`。
16 console.log(`开始世界 : ${playTime}`);
17}
4-3. 在运行时，当玩家数量超过 4 个（包括 Bot 玩家）时，您可以在服务器控制台和客户端控制台上看到名为 World Start 的日志。
以下是示例代码，它将添加的机器人玩家移动到本地玩家的位置并同步移动位置。
5-1. 首先，编写代码以在服务器的 index.ts 中接收到来自客户端的消息时移动机器人玩家，MoveBot。
TypeScript
1async OnCreate() {
2
3 // 处理 "MoveBot" 消息，该消息将机器人玩家移动到指定位置。
4 this.onMessage("MoveBot", (client, message) => {
5 this.MoveBot(client, message);
6 });
7}
8
9// `MoveBot()` 方法根据接收到的消息将机器人玩家移动到指定位置。
10MoveBot(client: SandboxPlayer, message: string) {
11 // 解析从客户端接收到的 JSON 消息以提取位置信息。
12 const position = JSON.parse(message);
13
14 // 创建一个新的消息对象，包含用户的会话 ID 和解析后的位置信息。
15 const newMessage = {
16 user: client.sessionId,
17 positionX: position.x,
18 positionY: position.y,
19 positionZ: position.z
20 }
21
22 // 将 "MoveBotToPosition" 消息广播给所有客户端，消息数据作为 JSON 字符串。
23 this.broadcast("MoveBotToPosition", JSON.stringify(newMessage));
24}
5-2. 在客户端脚本 BotPlayerManager.ts 中，编写 SendBotPosition()，当按下 buttonCallBot 时将本地玩家位置发送到服务器。
- 然后编写代码，当从服务器接收到消息 MoveBotToPosition 时，将所有 Bot 玩家移动到消息中包含的位置。
BotPlayerManager.ts
1public buttonCallBot: Button;
2
3Start(){
4
5 // 监听来自 `ZepetoWorldMultiplay` 组件的 `RoomJoined` 事件。
6 this.zepetoWorldMultiplay.RoomJoined += (room: Room) => {
7 this._room = room;
8
9 // 为 "StartWorld" 消息类型添加消息处理程序。
10 this._room.AddMessageHandler("StartWorld", (playTime: number) => {
11 this.StartWorld(playTime);
12 });
13
14 // 为 "Call Bot" 按钮添加点击监听器，以发送消息以发送 Bot 玩家位置。
15 this.buttonCallBot.onClick.AddListener(() => {
16 this.SendBotPosition();
17 });
18}
19
20// 此方法将本地玩家角色的位置发送到服务器以进行 Bot 移动同步。
21SendBotPosition() {
22
23 // 获取本地玩家角色的位置。
24 const localPlayerPosition = ZepetoPlayers.instance.LocalPlayer.zepetoPlayer.character.transform.position;
25
26 // 创建一个包含本地玩家角色的 x、y 和 z 坐标的位置对象。
27 const position = {
28 x: localPlayerPosition.x,
29 y: localPlayerPosition.y,
30 z: localPlayerPosition.z
31 }
32
33 // 将位置对象转换为 JSON 字符串，并使用 "MoveBot" 消息类型将其发送到服务器。
34 this._room.Send("MoveBot", JSON.stringify(position));
35 }
36
37MoveBotToPosition(message) {
38
39 // 解析从客户端接收到的 JSON 消息以提取位置信息。
40 const jsonMessage = JSON.parse(message);
41 const position = new Vector3(jsonMessage.positionX, jsonMessage.positionY, jsonMessage.positionZ);
42
43 // 将 `_botMapData` 映射中的每个 Bot 角色移动到指定位置，并在 x 和 z 轴上添加一个小的随机偏移。
44 this._botMapData.forEach((character: ZepetoCharacter) => {
45 // 使用 `MoveToPosition()` 方法将角色移动到指定位置。
46 // 在这里，向目标位置添加一个小的随机偏移，以为 Bot 创建自然的移动效果。
47 character.MoveToPosition(position + new Vector3(Random.Range(0.5, 1), 0, Random.Range(0.5, 1)));
48 });
49}
5-3. 现在，如果您在运行时创建一个 Bot 玩家并按下 buttonCallBot 按钮，您应该会看到创建的 Bot 玩家移动到本地玩家角色的位置。
BotPlayerManager.ts
1import { Random, Vector3 } from 'UnityEngine';
2import { Button } from 'UnityEngine.UI';
3import { ZepetoCharacter, ZepetoPlayers } from 'ZEPETO.Character.Controller';
4import { Room } from 'ZEPETO.Multiplay';
5import { ZepetoScriptBehaviour } from 'ZEPETO.Script'
6import { ZepetoWorldMultiplay } from 'ZEPETO.World';
7
8export default class BotPlayerManager extends ZepetoScriptBehaviour {
9
10 // 公共属性，用于引用 Inspector 中所需的组件和设置。
11 public zepetoWorldMultiplay: ZepetoWorldMultiplay;
12 public buttonCreateBot: Button;
13 public buttonCallBot: Button;
14 public botPlayerId: string;
15
16 // 私有变量，用于存储当前房间和机器人玩家数据。
17 private _room: Room;
18 private _botMapData: Map<string, ZepetoCharacter> = new Map<string, ZepetoCharacter>();
19
20 Start() {
21
22 // 监听来自 `ZepetoWorldMultiplay` 组件的 `RoomJoined` 事件。
23 this.zepetoWorldMultiplay.RoomJoined += (room: Room) => {
24 this._room = room;
25
26 // 为 "StartWorld" 消息类型添加消息处理程序。
27 this._room.AddMessageHandler("StartWorld", (playTime: number) => {
28 this.StartWorld(playTime);
29 });
30 }
31
32 // 监听来自 `ZepetoPlayers.instance` 的 `OnAddedPlayer` 事件，以处理新添加的玩家。
33 ZepetoPlayers.instance.OnAddedPlayer.AddListener((userId: string) => {
34
35 // 使用 `userId` 从房间状态中获取当前玩家数据。
36 const currentPlayer = this._room.State.players.get_Item(userId);
37
38 // 检查玩家是否为机器人，如果是，则将其设置为机器人玩家。
39 if (currentPlayer.isBot) {
40 this.SetBotPlayer(currentPlayer.sessionId);
41 }
42 });
43
44 // 为 "Create Bot" 按钮添加点击监听器，以发送消息创建机器人玩家。
45 this.buttonCreateBot.onClick.AddListener(() => {
46 this._room.Send("CreateBot", this.botPlayerId);
47 });
48
49 this.zepetoWorldMultiplay.RoomJoined += (room: Room) => {
50 this._room = room;
51
52 this._room.AddMessageHandler("MoveBotToPosition", (message: string) => {
53 this.MoveBotToPosition(message);
54 });
55 }
56
57 // 为 "Call Bot" 按钮添加点击监听器，以发送消息发送机器人玩家位置。
58 this.buttonCallBot.onClick.AddListener(() => {
59 this.SendBotPosition();
60 });
61 }
62
63 // `SetBotPlayer()` 方法用于将玩家设置为机器人。
64 SetBotPlayer(userId: string) {
65
66 // 使用其 `userId` 获取与机器人玩家相关联的 ZEPETO 角色。
67 const bot = ZepetoPlayers.instance.GetPlayer(userId).character;
68
69 // 将角色的名称设置为 `userId` 以便识别。
70 bot.gameObject.name = userId;
71
72 // 使用其 `userId` 作为键将机器人玩家的数据存储在 `_botMapData` 映射中。
73 this._botMapData.set(userId, bot);
74 }
75
76 // `StartWorld()` 方法在世界开始时调用，提供的 `playTime`。
77 StartWorld(playTime: number) {
78
79 // 打印世界开始消息以及 `playTime`。
80 console.log(`Start World : ${playTime}`);
81 }
82
83 // 此方法将本地玩家角色的位置发送到服务器以进行机器人移动同步。
84 SendBotPosition() {
85
86 // 获取本地玩家角色的位置。
87 const localPlayerPosition = ZepetoPlayers.instance.LocalPlayer.zepetoPlayer.character.transform.position;
88
89 // 创建一个位置对象，包含本地玩家角色的 x、y 和 z 坐标。
90 const position = {
91 x: localPlayerPosition.x,
92 y: localPlayerPosition.y,
93 z: localPlayerPosition.z
94 }
95
96 // 将位置对象转换为 JSON 字符串，并使用 "MoveBot" 消息类型将其发送到服务器。
97 this._room.Send("MoveBot", JSON.stringify(position));
98 }
99
100 // 当服务器从客户端接收到 "MoveBot" 消息时调用此方法，并将机器人角色移动到指定位置。
101 MoveBotToPosition(message) {
102
103 // 解析从客户端接收到的 JSON 消息以提取位置信息。
104 const jsonMessage = JSON.parse(message);
105 const position = new Vector3(jsonMessage.positionX, jsonMessage.positionY, jsonMessage.positionZ);
106
107 // 将 `_botMapData` 映射中的每个机器人角色移动到指定位置，并在 x 和 z 轴上添加一个小的随机偏移。
108 this._botMapData.forEach((character: ZepetoCharacter) => {
109 // `MoveToPosition()` 方法用于将角色移动到指定位置。
110 // 在这里，向目标位置添加一个小的随机偏移，以创建自然的机器人移动效果。
111 character.MoveToPosition(position + new Vector3(Random.Range(0.5, 1), 0, Random.Range(0.5, 1)));
112 });
113 }
114}
Text
1import { Sandbox, SandboxOptions, SandboxPlayer } from "ZEPETO.Multiplay";
2import { DataStorage } from "ZEPETO.Multiplay.DataStorage";
3import { Player, Transform, Vector3 } from "ZEPETO.Multiplay.Schema";
4
5export default class extends Sandbox {
6
7 storageMap: Map<string, DataStorage> = new Map<string, DataStorage>();
8
9 // 保存机器人玩家的地图数据为 _botMap
10 private _botMap: Map<string, Player> = new Map<string, Player>();
11 private playTime: number = 0;
12
13 constructor() {
14 super();
15 }
16
17 onCreate(options: SandboxOptions) {
18
19 // 当房间对象被创建时调用。
20 // 处理房间对象的状态或数据初始化。
21
22 this.onMessage("onChangedTransform", (client, message) => {
23
24 this.state.players.get(client.sessionId);
25
26 const player = this.state.players.get(client.sessionId);
27
28 const transform = new Transform();
29 transform.position = new Vector3();
30 transform.position.x = message.position.x;
31 transform.position.y = message.position.y;
32 transform.position.z = message.position.z;
33
34 transform.rotation = new Vector3();
35 transform.rotation.x = message.rotation.x;
36 transform.rotation.y = message.rotation.y;
37 transform.rotation.z = message.rotation.z;
38
39 if (player) {
40 player.transform = transform;
41 }
42 });
43
44 this.onMessage("onChangedState", (client, message) => {
45 const player = this.state.players.get(client.sessionId);
46 if (player) {
47 player.state = message.state;
48 player.subState = message.subState;
49 }
50 });
51
52 // 处理 "CreateBot" 消息，该消息使用给定的 userId 创建一个机器人玩家。
53 this.onMessage("CreateBot", (client, message) => {
54 this.CreateBot(message);
55 });
56
57 // 处理 "MoveBot" 消息，该消息将机器人玩家移动到指定位置。
58 this.onMessage("MoveBot", (client, message) => {
59 this.MoveBot(client, message);
60 });
61 }
62
63 // `CreateBot()` 方法用于使用给定的 `userId` 创建一个机器人玩家。
64 CreateBot(userId: string) {
65
66 // 使用提供的 `userId` 为机器人玩家生成一个会话 ID。
67 const sessionId = "Bot_" + userId;
68
69 // 检查是否已经存在具有相同会话 ID 的机器人玩家。如果存在，则返回而不创建重复。
70 if (this.state.players.has(sessionId)) {
71 return;
72 }
73
74 // 为机器人玩家创建一个新的 `Player` 对象。
75 const player: Player = new Player();
76 player.sessionId = sessionId;
77 if (userId) {
78 player.zepetoUserId = userId;
79 }
80 player.isBot = true;
81
82 // 使用会话 ID 作为键将机器人玩家添加到状态的玩家映射中。
83 this.state.players.set(player.sessionId, player);
84 this._botMap.set(sessionId, player);
85
86 // 在添加机器人玩家后检查房间中的玩家数量。
87 this.CheckPlayerNumber();
88 }
89
90 // `CheckPlayerNumber()` 方法检查房间中的玩家数量，并在至少有四名玩家时启动世界。
91 CheckPlayerNumber() {
92
93 // 将房间中当前的玩家数量打印到控制台。
94 console.log(`玩家数量, ${this.state.players.size}`);
95
96 // 如果房间中至少有四名玩家，则启动世界。
97 if (this.state.players.size >= 4) {
98 this.StartWorld();
99 }
100 }
101
102 // `StartWorld()` 方法增加游戏时间并向所有客户端广播 "StartWorld" 消息。
103 StartWorld() {
104 this.playTime += 1;
105
106 // 打印一条消息，指示世界的开始和当前的游戏时间。
107 console.log("开始世界！");
108 this.broadcast("StartWorld", this.playTime);
109 }
110
111 // `MoveBot()` 方法根据接收到的消息将机器人玩家移动到指定位置。
112 MoveBot(client: SandboxPlayer, message: string) {
113 // 解析从客户端接收到的 JSON 消息以提取位置信息。
114 const position = JSON.parse(message);
115
116 // 创建一个新的消息对象，包含用户的会话 ID 和解析后的位置信息。
117 const newMessage = {
118 user: client.sessionId,
119 positionX: position.x,
120 positionY: position.y,
121 positionZ: position.z
122 }
123
124 // 将 "MoveBotToPosition" 消息广播给所有客户端，消息数据作为 JSON 字符串。
125 this.broadcast("MoveBotToPosition", JSON.stringify(newMessage));
126 }
127
128 async onJoin(client: SandboxPlayer) {
129
130 // 创建在 schemas.json 中定义的玩家对象并设置初始值。
131 console.log(`[OnJoin] 会话 ID : ${client.sessionId}, 哈希码 : ${client.hashCode}, 用户 ID : ${client.userId}`)
132
133 const player = new Player();
134 player.sessionId = client.sessionId;
135
136 if (client.hashCode) {
137 player.zepetoHash = client.hashCode;
138 }
139 if (client.userId) {
140 player.zepetoUserId = client.userId;
141 }
142
143 // [DataStorage] 加载进入玩家的数据存储
144 const storage: DataStorage = client.loadDataStorage();
145
146 this.storageMap.set(client.sessionId, storage);
147
148 let visit_cnt = await storage.get("VisitCount") as number;
149 if (visit_cnt == null) visit_cnt = 0;
150
151 console.log(`[OnJoin] ${client.sessionId} 的访问计数 : ${visit_cnt}`)
152
153 // [DataStorage] 更新玩家的访问计数，然后保存存储
154 await storage.set("VisitCount", ++visit_cnt);
155
156 // 使用会话 ID 管理玩家对象，这是客户端对象的唯一键值。
157 // 客户端可以通过将 add_OnAdd 事件添加到玩家对象来检查通过 set 添加的玩家对象的信息。
158 this.state.players.set(client.sessionId, player);
159
160 // 在玩家加入后检查房间中的玩家数量。
161 this.CheckPlayerNumber();
162 }
163
164 onTick(deltaTime: number): void {
165 // 它在服务器中每次设置时间时重复调用，并且可以使用 deltaTime 管理某个间隔事件。
166 }
167
168 async onLeave(client: SandboxPlayer, consented?: boolean) {
169
170 // 通过设置 allowReconnection，可以保持电路的连接，但在基本指南中立即清理。
171 // 客户端可以通过将 add_OnRemove 事件添加到玩家对象来检查已删除的玩家对象的信息。
172 this.state.players.delete(client.sessionId);
173 }
174}
