---
title: 创建多人游戏
slug: world-sdk-guide-ch/789IqkSjBPVS9vhlwwJJt
docTags: 
createdAt: 2024-09-02T08:34:13.138Z
---

## 示例项目

:::hint{type="info"}
**📘 多人游戏示例**
[https://github.com/naverz/zepeto-multiplay-example](https://github.com/naverz/zepeto-multiplay-example)
:::



## 总结ㅁ

| 总结   | 从创建一个多人游戏服务器到客户端，设置开发多人游戏世界所需的环境。 |
| ---- | --------------------------------- |
| 难度   | 中级                                |
| 所需时间 | 1小时                               |



## 第1部分. 安装多人游戏

- 从创建一个多人游戏服务器到客户端，设置开发多人游戏世界所需的环境。

::embed[[https://www.youtube.com/watch?v=S68B1TMa-A8](https://www.youtube.com/watch?v=S68B1TMa-A8)]{url="https://www.youtube.com/watch?v=S68B1TMa-A8"}



## 第二部分：编写世界逻辑

- 了解服务器与客户端之间通信所需的架构，并定义架构类型和房间状态。

::embed[[https://www.youtube.com/watch?v=tfkY_raboV0](https://www.youtube.com/watch?v=tfkY_raboV0)]{url="https://www.youtube.com/watch?v=tfkY_raboV0"}

:::hint{type="danger"}
- 请注意，视频中使用的服务器脚本，包括与 hashCode 相关的内容，已不再支持。
- 因此，在编写时请排除以下代码。

```typescript
if (client.hashCode) {  
	player.zepetoHash = client.hashCode;  
}
```
:::



## 第三部分：编写世界逻辑 2

- 编写需要从玩家的位置同步到玩家出口的世界逻辑。

::embed[[https://www.youtube.com/watch?v=H92Gd2G9DhM](https://www.youtube.com/watch?v=H92Gd2G9DhM)]{url="https://www.youtube.com/watch?v=H92Gd2G9DhM"}



## 第4部分：运行服务器并连接到Multiplay

- 运行服务器并连接到Multiplay。

::embed[[https://www.youtube.com/watch?v=FmK6JNlSjJA](https://www.youtube.com/watch?v=FmK6JNlSjJA)]{url="https://www.youtube.com/watch?v=FmK6JNlSjJA"}



## 第5部分：脚本

### Schemas.json

:::CodeblockTabs
schemas.json

```json
{
"State" : {"players" : {"map" : "玩家"}},
"Player" : {"sessionId" : "字符串","zepetoUserId" : "字符串","transform" : "变换","state" : "数字","subState" : "数字"},
"Transform" : {"position" : "向量3","rotation" : "向量3"},
"Vector3" : {"x" : "数字","y" : "数字","z" : "数字"}
}
```
:::



### 服务器代码

:::CodeblockTabs
index.ts

```typescript
import {Sandbox, SandboxOptions, SandboxPlayer} from "ZEPETO.Multiplay";
import {DataStorage} from "ZEPETO.Multiplay.DataStorage";
import {Player, Transform, Vector3} from "ZEPETO.Multiplay.Schema";

export default class extends Sandbox {


    storageMap:Map<string,DataStorage> = new Map<string, DataStorage>();
    
    constructor() {
        super();
    }

    onCreate(options: SandboxOptions) {
      	// 当房间对象被创建时调用。
        // 处理房间对象的状态或数据初始化。

        this.onMessage("onChangedTransform", (client, message) => {
            const player = this.state.players.get(client.sessionId);

            const transform = new Transform();
            transform.position = new Vector3();
            transform.position.x = message.position.x;
            transform.position.y = message.position.y;
            transform.position.z = message.position.z;

            transform.rotation = new Vector3();
            transform.rotation.x = message.rotation.x;
            transform.rotation.y = message.rotation.y;
            transform.rotation.z = message.rotation.z;

            if (player) {
                player.transform = transform;
            }
        });

        this.onMessage("onChangedState", (client, message) => {
            const player = this.state.players.get(client.sessionId);
            if (player) {
                player.state = message.state;
                player.subState = message.subState; // 角色控制器 V2
            }
        });
    }
    
   
    
    async onJoin(client: SandboxPlayer) {

        // 创建在 schemas.json 中定义的玩家对象并设置初始值。
        console.log(`[OnJoin] sessionId : ${client.sessionId}, userId : ${client.userId}`)

        const player = new Player();
        player.sessionId = client.sessionId;

        if (client.userId) {
            player.zepetoUserId = client.userId;
        }

        // [DataStorage] 进入玩家的数据存储加载
        const storage: DataStorage = client.loadDataStorage();

        this.storageMap.set(client.sessionId,storage);

        let visit_cnt = await storage.get("VisitCount") as number;
        if (visit_cnt == null) visit_cnt = 0;

        console.log(`[OnJoin] ${client.sessionId} 的访问计数 : ${visit_cnt}`)

        // [DataStorage] 更新玩家的访问计数并保存存储
        await storage.set("VisitCount", ++visit_cnt);

        // 使用 sessionId 管理玩家对象，这是客户端对象的唯一键值。
        // 客户端可以通过将 add_OnAdd 事件添加到 players 对象来检查通过 set 添加的玩家对象的信息。
        this.state.players.set(client.sessionId, player);
    }

    onTick(deltaTime: number): void {
        //  在服务器中每次设定时间重复调用，并且可以使用 deltaTime 管理某个间隔事件。
    }

    async onLeave(client: SandboxPlayer, consented?: boolean) {

				// 通过设置 allowReconnection，可以保持电路的连接，但在基本指南中立即清理。
        // 客户端可以通过将 add_OnRemove 事件添加到 players 对象来检查已删除的玩家对象的信息。
        this.state.players.delete(client.sessionId);
    }
}
```
:::



### 客户代码

:::CodeblockTabs
ClientStarter.ts

```typescript
import {ZepetoScriptBehaviour} from 'ZEPETO.Script'
import {ZepetoWorldMultiplay} from 'ZEPETO.World'
import {Room, RoomData} from 'ZEPETO.Multiplay'
import {Player, State, Vector3} from 'ZEPETO.Multiplay.Schema'
import {CharacterState, SpawnInfo, ZepetoPlayers, ZepetoPlayer, CharacterJumpState} from 'ZEPETO.Character.Controller'
import * as UnityEngine from "UnityEngine";


export default class ClientStarterV2 extends ZepetoScriptBehaviour {

    public multiplay: ZepetoWorldMultiplay;

    private room: Room;
    private currentPlayers: Map<string, Player> = new Map<string, Player>();

    private zepetoPlayer: ZepetoPlayer;

    private Start() {

        this.multiplay.RoomCreated += (room: Room) => {
            this.room = room;
        };

        this.multiplay.RoomJoined += (room: Room) => {
            room.OnStateChange += this.OnStateChange;
        };

        this.StartCoroutine(this.SendMessageLoop(0.04));
    }

    // 在预定的间隔时间内将本地角色变换发送到服务器。
    private* SendMessageLoop(tick: number) {
        while (true) {
            yield new UnityEngine.WaitForSeconds(tick);

            if (this.room != null && this.room.IsConnected) {
                const hasPlayer = ZepetoPlayers.instance.HasPlayer(this.room.SessionId);
                if (hasPlayer) {
                    const character = ZepetoPlayers.instance.GetPlayer(this.room.SessionId).character;                                  
                    this.SendTransform(character.transform);
                    this.SendState(character.CurrentState);
                }
            }
        }
    }

    private OnStateChange(state: State, isFirst: boolean) {

        // 当接收到第一个 OnStateChange 事件时，记录完整的状态快照。
        if (isFirst) {

            // [CharacterController] (本地) 当玩家实例在场景中完全加载时调用
            ZepetoPlayers.instance.OnAddedLocalPlayer.AddListener(() => {
                const myPlayer = ZepetoPlayers.instance.LocalPlayer.zepetoPlayer;
                this.zepetoPlayer = myPlayer;
            });

            // [CharacterController] (本地) 当玩家实例在场景中完全加载时调用
            ZepetoPlayers.instance.OnAddedPlayer.AddListener((sessionId: string) => {
                const isLocal = this.room.SessionId === sessionId;
                if (!isLocal) {
                    const player: Player = this.currentPlayers.get(sessionId);

                    // [RoomState] 每当玩家实例的状态更新时调用。
                    player.OnChange += (changeValues) => this.OnUpdatePlayer(sessionId, player);
                }
            });
        }

        let join = new Map<string, Player>();
        let leave = new Map<string, Player>(this.currentPlayers);

        state.players.ForEach((sessionId: string, player: Player) => {
            if (!this.currentPlayers.has(sessionId)) {
                join.set(sessionId, player);
            }
            leave.delete(sessionId);
        });

        // [RoomState] 为进入房间的玩家创建玩家实例
        join.forEach((player: Player, sessionId: string) => this.OnJoinPlayer(sessionId, player));

        // [RoomState] 移除退出房间的玩家实例
        leave.forEach((player: Player, sessionId: string) => this.OnLeavePlayer(sessionId, player));
    }

    private OnJoinPlayer(sessionId: string, player: Player) {
        console.log(`[OnJoinPlayer] players - sessionId : ${sessionId}`);
        this.currentPlayers.set(sessionId, player);

        const spawnInfo = new SpawnInfo();
        const position = this.ParseVector3(player.transform.position);
        const rotation = this.ParseVector3(player.transform.rotation);
        spawnInfo.position = position;
        spawnInfo.rotation = UnityEngine.Quaternion.Euler(rotation);

        const isLocal = this.room.SessionId === player.sessionId;
        ZepetoPlayers.instance.CreatePlayerWithUserId(sessionId, player.zepetoUserId, spawnInfo, isLocal);
    }

    private OnLeavePlayer(sessionId: string, player: Player) {
        console.log(`[OnRemove] players - sessionId : ${sessionId}`);
        this.currentPlayers.delete(sessionId);

        ZepetoPlayers.instance.RemovePlayer(sessionId);
    }

    private OnUpdatePlayer(sessionId: string, player: Player) {

        const position = this.ParseVector3(player.transform.position);

        const zepetoPlayer = ZepetoPlayers.instance.GetPlayer(sessionId);

        var moveDir = UnityEngine.Vector3.op_Subtraction(position, zepetoPlayer.character.transform.position);
        moveDir = new UnityEngine.Vector3(moveDir.x, 0, moveDir.z);

        if (moveDir.magnitude < 0.05) {
            if (player.state === CharacterState.MoveTurn)
                return;
            zepetoPlayer.character.StopMoving();
        } else {
            zepetoPlayer.character.MoveContinuously(moveDir);
        }

        if (player.state === CharacterState.Jump) {
            if (zepetoPlayer.character.CurrentState !== CharacterState.Jump) {
                zepetoPlayer.character.Jump();
            }

            if (player.subState === CharacterJumpState.JumpDouble) {
                zepetoPlayer.character.DoubleJump();
            }
        }
    }

    private SendTransform(transform: UnityEngine.Transform) {
        const data = new RoomData();

        const pos = new RoomData();
        pos.Add("x", transform.localPosition.x);
        pos.Add("y", transform.localPosition.y);
        pos.Add("z", transform.localPosition.z);
        data.Add("position", pos.GetObject());

        const rot = new RoomData();
        rot.Add("x", transform.localEulerAngles.x);
        rot.Add("y", transform.localEulerAngles.y);
        rot.Add("z", transform.localEulerAngles.z);
        data.Add("rotation", rot.GetObject());
        this.room.Send("onChangedTransform", data.GetObject());
    }

    private SendState(state: CharacterState) {
        const data = new RoomData();
        data.Add("state", state);
        if(state === CharacterState.Jump) { 
            data.Add("subState", this.zepetoPlayer.character.MotionV2.CurrentJumpState);
        }
        this.room.Send("onChangedState", data.GetObject());
    }

    private ParseVector3(vector3: Vector3): UnityEngine.Vector3 {
        return new UnityEngine.Vector3
        (
            vector3.x,
            vector3.y,
            vector3.z
        );
    }
}
```
:::