CREATE YOUR WORLD
Players & Characters : Advance...
Bot 플레이어 생성 가이드
16min
봇 플레이어는 멀티플레이어 월드를 시작할 충분한 사람이 없거나, 플레이어가 월드 중에 나갈 때 채우기 위해 사용됩니다.
봇 플레이어의 행동 방식은 각 콘텐츠에 맞게 구현되어야 합니다.
이 가이드는 봇 플레이어를 만드는 일반적인 방법을 설명합니다.
📘 봇 플레이어 생성 가이드는 멀티플레이어 가이드를 기반으로 합니다. [멀티플레이 제작하기]
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 함수를 작성하여 봇 플레이어에 태그와 동기화 구성 요소를 추가하고 이를 제어하는 스크립트를 생성합니다.
- 봇 플레이어 데이터를 관리하기 위해 Map 형식으로 _botMapData를 설정하여 저장합니다.
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()에 추가 스크립트나 설정을 추가하여 봇 플레이어의 행동을 제어할 수 있습니다.
시작하기 위해 특정 수의 플레이어가 필요한 월드의 경우, 때때로 플레이어가 충분하지 않아 월드가 시작되기까지 오랜 시간을 기다려야 합니다.
이 경우, Bot 플레이어를 추가하여 월드를 시작할 수 있습니다.
3-1. index.ts에서 서버가 클라이언트로부터 메시지를 받을 때 CreateBot()을 실행하도록 함수를 등록합니다.
TypeScript
1async OnCreate() {
2
3 // 주어진 userId로 봇 플레이어를 생성하는 "CreateBot" 메시지를 처리합니다.
4 this.onMessage("CreateBot", (client, message) => {
5 this.CreateBot(message);
6 });
7}
3-2. 클라이언트 스크립트 BotPlayerManager.ts에서 서버에 "CreateBot" 메시지를 보내는 함수를 작성합니다.
- 함수를 실행하는 방법은 버튼을 눌러 메시지를 보내는 것입니다.
- 생성할 Bot 플레이어의 사용자 ID를 문자열로 메시지를 통해 보냅니다.
BotPlayerManager.ts
1public buttonCreateBot: Button;
2public botPlayerId: string;
3
4Start() {
5
6 // "Create Bot" 버튼에 클릭 리스너를 추가하여 봇 플레이어를 생성하는 메시지를 보냅니다.
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("StartWorld!");
55 this.broadcast("StartWorld", this.playTime);
56}
- 서버에서 실제 플레이어가 방에 들어오면 OnJoin이 실행됩니다. 따라서 CreateBot을 통해 봇 플레이어가 생성되고 플레이어가 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(`Start World : ${playTime}`);
17}
4-3. 실행 중에 봇 플레이어를 포함하여 4명 이상의 플레이어가 있을 경우, 서버 콘솔과 클라이언트 콘솔에 '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 // 새로운 메시지 데이터를 JSON 문자열로 모든 클라이언트에 "MoveBotToPosition" 메시지를 브로드캐스트합니다.
23 this.broadcast("MoveBotToPosition", JSON.stringify(newMessage));
24}
5-2. 클라이언트 스크립트인 BotPlayerManager.ts에서 buttonCallBot이 눌릴 때 로컬 플레이어 위치를 서버로 전송하는 SendBotPosition()을 작성합니다.
- 그런 다음 서버에서 MoveBotToPosition 메시지를 수신할 때 모든 봇 플레이어를 메시지에 포함된 위치 정보로 이동시키는 코드를 작성하십시오.
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" 버튼에 클릭 리스너를 추가하여 봇 플레이어 위치를 전송하는 메시지를 보냅니다.
15 this.buttonCallBot.onClick.AddListener(() => {
16 this.SendBotPosition();
17 });
18}
19
20// 이 메서드는 로컬 플레이어의 캐릭터 위치를 서버에 전송하여 봇 이동 동기화를 수행합니다.
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` 맵의 각 봇 캐릭터를 지정된 위치로 이동시키고 x 및 z 축에 작은 무작위 오프셋을 추가합니다.
44 this._botMapData.forEach((character: ZepetoCharacter) => {
45 // `MoveToPosition()` 메서드를 사용하여 캐릭터를 지정된 위치로 이동시킵니다.
46 // 여기서, 봇의 자연스러운 움직임을 위해 목표 위치에 작은 무작위 오프셋을 추가합니다.
47 character.MoveToPosition(position + new Vector3(Random.Range(0.5, 1), 0, Random.Range(0.5, 1)));
48 });
49}
5-3. 이제 런타임에 봇 플레이어를 생성하고 buttonCallBot 버튼을 누르면 생성된 봇 플레이어가 로컬 플레이어 캐릭터 위치로 이동하는 것을 볼 수 있습니다.
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 // Public properties to reference necessary components and settings from the Inspector.
11 public zepetoWorldMultiplay: ZepetoWorldMultiplay;
12 public buttonCreateBot: Button;
13 public buttonCallBot: Button;
14 public botPlayerId: string;
15
16 // Private variables to store the current room and bot player data.
17 private _room: Room;
18 private _botMapData: Map<string, ZepetoCharacter> = new Map<string, ZepetoCharacter>();
19
20 Start() {
21
22 // Listen for the `RoomJoined` event from the `ZepetoWorldMultiplay` component.
23 this.zepetoWorldMultiplay.RoomJoined += (room: Room) => {
24 this._room = room;
25
26 // Add a message handler for the "StartWorld" message type.
27 this._room.AddMessageHandler("StartWorld", (playTime: number) => {
28 this.StartWorld(playTime);
29 });
30 }
31
32 // Listen for the `OnAddedPlayer` event from `ZepetoPlayers.instance` to handle newly added players.
33 ZepetoPlayers.instance.OnAddedPlayer.AddListener((userId: string) => {
34
35 // Get the current player data from the room state using the `userId`.
36 const currentPlayer = this._room.State.players.get_Item(userId);
37
38 // Check if the player is a bot, and if so, set them as a bot player.
39 if (currentPlayer.isBot) {
40 this.SetBotPlayer(currentPlayer.sessionId);
41 }
42 });
43
44 // Add a click listener to the "Create Bot" button to send a message to create a bot player.
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 // Add a click listener to the "Call Bot" button to send a message to send a bot player position.
58 this.buttonCallBot.onClick.AddListener(() => {
59 this.SendBotPosition();
60 });
61 }
62
63 // The `SetBotPlayer()` method is used to set a player as a bot.
64 SetBotPlayer(userId: string) {
65
66 // Get the ZEPETO character associated with the bot player using their `userId`.
67 const bot = ZepetoPlayers.instance.GetPlayer(userId).character;
68
69 // Set the name of the character to the `userId` for identification.
70 bot.gameObject.name = userId;
71
72 // Store the bot player's data in the `_botMapData` map using their `userId` as the key.
73 this._botMapData.set(userId, bot);
74 }
75
76 // The `StartWorld()` method is called when the world starts with the provided `playTime`.
77 StartWorld(playTime: number) {
78
79 // Print the world start message along with the `playTime`.
80 console.log(`Start World : ${playTime}`);
81 }
82
83 // This method sends the position of the local player's character to the server for bot movement synchronization.
84 SendBotPosition() {
85
86 // Get the position of the local player's character.
87 const localPlayerPosition = ZepetoPlayers.instance.LocalPlayer.zepetoPlayer.character.transform.position;
88
89 // Create a position object containing the x, y, and z coordinates of the local player's character.
90 const position = {
91 x: localPlayerPosition.x,
92 y: localPlayerPosition.y,
93 z: localPlayerPosition.z
94 }
95
96 // Convert the position object to a JSON string and send it to the server with the "MoveBot" message type.
97 this._room.Send("MoveBot", JSON.stringify(position));
98 }
99
100 // This method is called when the server receives the "MoveBot" message from a client and moves the bot characters to the specified position.
101 MoveBotToPosition(message) {
102
103 // Parse the JSON message received from the client to extract the position information.
104 const jsonMessage = JSON.parse(message);
105 const position = new Vector3(jsonMessage.positionX, jsonMessage.positionY, jsonMessage.positionZ);
106
107 // Move each bot character in the `_botMapData` map to the specified position with a small random offset on the x and z axes.
108 this._botMapData.forEach((character: ZepetoCharacter) => {
109 // The `MoveToPosition()` method is used to move the character to the specified position.
110 // Here, a small random offset is added to the target position to create a natural-looking movement for the bots.
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 // Room 객체가 생성될 때 호출됩니다.
20 // Room 객체의 상태 또는 데이터 초기화를 처리합니다.
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 // 주어진 userId로 봇 플레이어를 생성하는 "CreateBot" 메시지를 처리합니다.
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()` 메서드는 방의 플레이어 수를 확인하고, 최소 4명의 플레이어가 있을 경우 월드를 시작합니다.
91 CheckPlayerNumber() {
92
93 // 방의 현재 플레이어 수를 콘솔에 출력합니다.
94 console.log(`player Number, ${this.state.players.size}`);
95
96 // 방에 최소 4명의 플레이어가 있으면 월드를 시작합니다.
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("Start World!");
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 // 새로운 메시지 데이터를 JSON 문자열로 모든 클라이언트에 "MoveBotToPosition" 메시지를 방송합니다.
125 this.broadcast("MoveBotToPosition", JSON.stringify(newMessage));
126 }
127
128 async onJoin(client: SandboxPlayer) {
129
130 // schemas.json에 정의된 플레이어 객체를 생성하고 초기 값을 설정합니다.
131 console.log(`[OnJoin] sessionId : ${client.sessionId}, HashCode : ${client.hashCode}, userId : ${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] 들어온 플레이어의 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 // 클라이언트는 플레이어 객체에 추가된 정보를 확인할 수 있습니다.
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 // 클라이언트는 삭제된 플레이어 객체에 대한 정보를 확인할 수 있습니다.
172 this.state.players.delete(client.sessionId);
173 }
174}
