ZEPETO Players

21min
﻿
ZepetoPlayers adalah kelas Manajer (Singleton) yang dirancang untuk mengontrol baik Pemain ZEPETO maupun Karakter ZEPETO.
Dengan menambahkan ZepetoPlayers ke dalam sebuah Adegan, Anda dapat membuat, menghapus, dan memanipulasi Pemain ZEPETO.
ZepetoPlayer mewakili sebuah instance individu dari karakter ZEPETO yang digunakan untuk mengelola baik pemain yang Anda kendalikan secara langsung di dunia multiplayer maupun pemain lainnya.
Setiap ZepetoPlayer yang dibuat di dunia multiplayer diberikan ID sesi unik dan dikelola menggunakan ID sesi ini.
Karena ZepetoPlayer memiliki atribut ZepetoCharacter, ia dapat dikendalikan menggunakan fungsi yang terkait dengan ZepetoCharacter.
Ada tiga jenis ZepetoPlayer:
ZepetoPlayer
Deskripsi
Pemain Lokal
Mewakili instansi karakter ZEPETO yang dikendalikan langsung oleh pengguna lokal.

- Dilengkapi dengan komponen Pengendali Karakter/Kamera Zepeto.
Pemain Jaringan (Pemain Jarak Jauh)
Instansi karakter ZEPETO yang dapat dimuat dan digunakan dalam konten multiplay.

- Tidak memiliki komponen Pengendali Karakter/Kamera Zepeto yang terpasang.
Pemain Bot
Instansi karakter ZEPETO untuk konten multiplay, tetapi dikendalikan oleh bot alih-alih pengguna nyata.

Digunakan sebagai pengganti saat memulai dunia multiplayer dengan pemain yang tidak mencukupi atau jika seorang pemain meninggalkan permainan selama bermain.

- Tidak memiliki komponen Pengendali Karakter/Kamera Zepeto yang terpasang.
Silakan merujuk ke panduan berikut.
[ZEPETO Players﻿]
[Panduan Pembuatan Pemain Bot﻿]
ZepetoCharacter adalah unit instance dasar dari karakter ZEPETO yang dapat dimuat dan dikendalikan di World Scene.
ZepetoCharacter memiliki penampilan avatar yang dibuat melalui aplikasi ZEPETO.
Silakan merujuk ke panduan berikut. [Karakter ZEPETO﻿]
Menambahkan ZepetoPlayers
Di jendela Hierarchy, pilih ZEPETO → tab ZepetoPlayers.
﻿
Anda sekarang dapat menambahkannya ke Adegan Anda.
﻿
Perhatikan bahwa hanya menambahkan ZepetoPlayers tidak membawa Pemain Zepeto ke dalam Adegan. Anda perlu menerapkan skrip menggunakan API pembuatan karakter dari ZepetoPlayers.
Jika Anda ingin dengan cepat membuat dan mencoba hanya Pemain Lokal dalam sebuah Adegan, silakan merujuk ke panduan:
Silakan merujuk ke panduan berikut. [Membuat karakter Zepeto﻿]
﻿
Untuk contoh tentang cara menampilkan nama dan foto profil pemain Zepeto, lihat panduan berikut:
Silakan merujuk ke panduan berikut. [Informasi Pengguna﻿]
﻿
API Pemain ZEPETO
Jika Anda tertarik dengan API ZepetoPlayers, silakan merujuk ke dokumentasi:
Silakan merujuk ke panduan berikut. [API ZEPETO.Character.Controller]
﻿
Panduan ini terutama mencakup contoh penggunaan Pemain ZEPETO dalam skenario multipemain.
﻿
Mengimplementasikan Sinkronisasi Posisi Multiplay menggunakan Pemain ZEPETO
Dalam dunia pemain tunggal, hanya Pemain Lokal yang perlu dibuat dan karena hanya Pemain Lokal yang muncul di layar, sinkronisasi tidak diperlukan.
Namun, dalam dunia multiplay, tidak hanya Pemain Lokal yang Anda kendalikan secara langsung tetapi juga Pemain lain, yang disebut Pemain Jaringan, perlu ditampilkan di layar.
Setiap tindakan Pemain Jaringan - bergerak, melompat, dan melakukan gerakan tertentu - harus muncul identik di layar Anda.
Proses ini disebut sinkronisasi.
Tanpa menerapkan skrip sinkronisasi, Anda tidak akan dapat melihat penampilan atau gerakan Pemain Jaringan.
Dalam dunia multiplay tanpa sinkronisasi, satu-satunya cara untuk mengetahui apakah klien lain telah masuk ke Ruangan adalah melalui tombol beranda.
Penampilan ketika hanya pengaturan multiplay diterapkan tanpa pembuatan karakter dan skrip sinkronisasi
﻿
﻿
LANGKAH 1 : Menyiapkan Lingkungan Multiplay
Disarankan untuk memulai dengan memahami pengaturan dasar dan konsep multiplay melalui video tutorial multiplay.
Silakan merujuk ke panduan berikut.
[Tutorial Bermain Ganda﻿ ]
[Bermain Ganda﻿]
﻿
LANGKAH 2 : Menampilkan Pemain Lain di Layar Anda
Pemain Lokal Anda diperlakukan sebagai Pemain Jaringan di perangkat orang lain.
Ini berarti bahwa bahkan Pemain Lokal Anda harus mengirim informasi ke server untuk sinkronisasi.
Semua Pemain yang terhubung ke dunia multiplay harus berbagi informasi mereka.
Semua Klien yang terhubung ke Ruangan Multiplay berbagi data Status Ruangan Multiplay.
Data Status Ruangan ini mengikuti Skema yang ditentukan dalam Schemas.json.
(Silakan anggap Skema sebagai struktur data)
Dalam panduan ini, Anda akan menyinkronkan posisi pemain melalui data Status Ruangan. Oleh karena itu, definisikan Skema dalam Schemas.json yang dapat mewakili data posisi untuk setiap pemain.
schema.json
{
"State" : {"players" : {"map" : "Player"}},
"Player" : {"sessionId" : "string","zepetoUserId" : "string","transform" : "Transform","state" : "number","subState" : "number"},
"Transform" : {"position" : "Vector3","rotation" : "Vector3"},
"Vector3" : {"x" : "number","y" : "number","z" : "number"}
}
{
"State" : {"players" : {"map" : "Player"}},
"Player" : {"sessionId" : "string","zepetoUserId" : "string","transform" : "Transform","state" : "number","subState" : "number"},
"Transform" : {"position" : "Vector3","rotation" : "Vector3"},
"Vector3" : {"x" : "number","y" : "number","z" : "number"}
}
﻿
Silakan merujuk ke panduan berikut. [Status Ruangan Multiplay﻿ ]
﻿
👍 Tips
Simpan semua informasi yang harus dibagikan oleh server dan semua klien di Status Ruangan Multiplay.
Simpan data individu untuk setiap Pemain, seperti level, poin pengalaman, skor, dll., menggunakan DataStorage.
﻿
Skrip server dapat mengenali ketika Pemain lain telah memasuki Ruangan dan dapat mengirimkan informasi itu ke klien untuk memuat Pemain tersebut ke dalam Adegan.
﻿
LANGKAH 2-1 : Skrip Server Dasar
Ketika seorang Pemain memasuki Ruangan dunia multiplay, onJoin() dipanggil.
Dalam skrip server, tambahkan informasi tentang pemain yang terhubung ke Pemain Ruang Status.
﻿
Juga, ketika seorang Pemain keluar dari Ruangan, onLeave() dipanggil.
Skrip server akan menghapus informasi pemain yang keluar dari Pemain Ruang Status.
TypeScript
import {Sandbox, SandboxOptions, SandboxPlayer} from "ZEPETO.Multiplay";
import {Player} from "ZEPETO.Multiplay.Schema";
 
export default class extends Sandbox {
 
 
    onCreate(options: SandboxOptions) {
 
    }
 
 
    async onJoin(client: SandboxPlayer) {
        const player = new Player();
        player.sessionId = client.sessionId;
 
        if (client.userId) {
            player.zepetoUserId = client.userId;
        }
 
 
 
        // Kelola objek Pemain menggunakan sessionId, nilai kunci unik dari objek klien.
        // Klien dapat memeriksa informasi tentang objek pemain yang ditambahkan dengan menambahkan acara add_OnAdd ke objek pemain.
        this.state.players.set(client.sessionId, player);
    }
 
    async onLeave(client: SandboxPlayer, consented?: boolean) {
 
        this.state.players.delete(client.sessionId);
    }
}
import {Sandbox, SandboxOptions, SandboxPlayer} from "ZEPETO.Multiplay";
import {Player} from "ZEPETO.Multiplay.Schema";
 
export default class extends Sandbox {
 
 
    onCreate(options: SandboxOptions) {
 
    }
 
 
    async onJoin(client: SandboxPlayer) {
        const player = new Player();
        player.sessionId = client.sessionId;
 
        if (client.userId) {
            player.zepetoUserId = client.userId;
        }
 
 
 
        // Kelola objek Pemain menggunakan sessionId, nilai kunci unik dari objek klien.
        // Klien dapat memeriksa informasi tentang objek pemain yang ditambahkan dengan menambahkan acara add_OnAdd ke objek pemain.
        this.state.players.set(client.sessionId, player);
    }
 
    async onLeave(client: SandboxPlayer, consented?: boolean) {
 
        this.state.players.delete(client.sessionId);
    }
}
﻿
﻿
LANGKAH 2-2 : Skrip Klien Dasar
Saat membuat dunia multiplay, skrip klien diperlukan untuk berkomunikasi dengan server.
Di bawah ini adalah contoh skrip klien dasar untuk permainan multiplayer.
Di sisi klien, kami mengelola data pemain yang akan ditampilkan di klien kami menggunakan currentPlayers struktur data peta.
﻿
Baris kode yang penting diilustrasikan di bawah ini:
ZepetoPlayers.instance.CreatePlayerWithUserId(sessionId, player.zepetoUserId, spawnInfo, isLocal); 
Ketika klien menerima informasi pemain dari Status Ruang server dan seorang pemain baru bergabung ke Ruang, sebuah ID sesi diberikan. Jika ID sesi dari pemain yang sedang dibuat cocok dengan ID sesi kita sendiri, pemain tersebut dianggap lokal. Dalam hal ini, pemain akan diinstansiasi dengan isLocal = true, yang menunjukkan bahwa itu adalah pemain lokal.
Selanjutnya, pemain yang bukan lokal dibuat dengan isLocal = false. Ini memastikan bahwa penampilan semua pemain, baik lokal maupun non-lokal, ditampilkan di layar.
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 MultiplayClientCode 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;
        };
 
    }
 
 
    private OnStateChange(state: State, isFirst: boolean) {
 
        // Ketika event OnStateChange pertama diterima, snapshot status penuh dicatat.
        if (isFirst) {
 
            // [CharacterController] (Lokal) Dipanggil ketika instance Pemain sepenuhnya dimuat di Scene
            ZepetoPlayers.instance.OnAddedLocalPlayer.AddListener(() => {
                const myPlayer = ZepetoPlayers.instance.LocalPlayer.zepetoPlayer;
                this.zepetoPlayer = myPlayer;
            });
 
            // [CharacterController] (Lokal) Dipanggil ketika instance Pemain sepenuhnya dimuat di Scene
            ZepetoPlayers.instance.OnAddedPlayer.AddListener((sessionId: string) => {
                const isLocal = this.room.SessionId === sessionId;
                if (!isLocal) {
                    const player: Player = this.currentPlayers.get(sessionId);
 
                }
            });
        }
 
        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] Buat instance pemain untuk pemain yang masuk ke Ruangan
        join.forEach((player: Player, sessionId: string) => this.OnJoinPlayer(sessionId, player));
 
        // [RoomState] Hapus instance pemain untuk pemain yang keluar dari ruangan
        leave.forEach((player: Player, sessionId: string) => this.OnLeavePlayer(sessionId, player));
    }
 
    private OnJoinPlayer(sessionId: string, player: Player) {
        console.log(`[OnJoinPlayer] pemain - sessionId : ${sessionId}`);
        this.currentPlayers.set(sessionId, player);
         
        // Buat Pemain
        const isLocal = this.room.SessionId === player.sessionId;
        ZepetoPlayers.instance.CreatePlayerWithUserId(sessionId, player.zepetoUserId, new SpawnInfo(), isLocal);
    }
 
    private OnLeavePlayer(sessionId: string, player: Player) {
        console.log(`[OnRemove] pemain - sessionId : ${sessionId}`);
        this.currentPlayers.delete(sessionId);
 
        ZepetoPlayers.instance.RemovePlayer(sessionId);
    }
}

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 MultiplayClientCode 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;
        };
 
    }
 
 
    private OnStateChange(state: State, isFirst: boolean) {
 
        // Ketika event OnStateChange pertama diterima, snapshot status penuh dicatat.
        if (isFirst) {
 
            // [CharacterController] (Lokal) Dipanggil ketika instance Pemain sepenuhnya dimuat di Scene
            ZepetoPlayers.instance.OnAddedLocalPlayer.AddListener(() => {
                const myPlayer = ZepetoPlayers.instance.LocalPlayer.zepetoPlayer;
                this.zepetoPlayer = myPlayer;
            });
 
            // [CharacterController] (Lokal) Dipanggil ketika instance Pemain sepenuhnya dimuat di Scene
            ZepetoPlayers.instance.OnAddedPlayer.AddListener((sessionId: string) => {
                const isLocal = this.room.SessionId === sessionId;
                if (!isLocal) {
                    const player: Player = this.currentPlayers.get(sessionId);
 
                }
            });
        }
 
        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] Buat instance pemain untuk pemain yang masuk ke Ruangan
        join.forEach((player: Player, sessionId: string) => this.OnJoinPlayer(sessionId, player));
 
        // [RoomState] Hapus instance pemain untuk pemain yang keluar dari ruangan
        leave.forEach((player: Player, sessionId: string) => this.OnLeavePlayer(sessionId, player));
    }
 
    private OnJoinPlayer(sessionId: string, player: Player) {
        console.log(`[OnJoinPlayer] pemain - sessionId : ${sessionId}`);
        this.currentPlayers.set(sessionId, player);
         
        // Buat Pemain
        const isLocal = this.room.SessionId === player.sessionId;
        ZepetoPlayers.instance.CreatePlayerWithUserId(sessionId, player.zepetoUserId, new SpawnInfo(), isLocal);
    }
 
    private OnLeavePlayer(sessionId: string, player: Player) {
        console.log(`[OnRemove] pemain - sessionId : ${sessionId}`);
        this.currentPlayers.delete(sessionId);
 
        ZepetoPlayers.instance.RemovePlayer(sessionId);
    }
}
﻿
﻿
Sekarang, ketika seorang Pemain masuk, Anda dapat mengonfirmasi bahwa karakter ZEPETO dibuat di layar Anda.
Tetapi, gerakan Pemain belum tercermin di layar.
Di layar saya, hanya pemain lokal saya yang bergerak, dan pemain lain tampak statis meskipun mereka sebenarnya bergerak.
﻿
﻿
Mari kita lanjutkan ke penyelarasan posisi berikutnya.
﻿
LANGKAH 3 : Menyelaraskan dengan Mengambil Informasi Pemain Lain
Untuk penyelarasan, setiap kali seorang Pemain bergerak atau melakukan tindakan, mereka harus mengirimkan perubahan status mereka ke server.
Mengirim pesan yang berisi perubahan status mereka ke server dilakukan melalui komunikasi Pesan Ruangan.
Ketika server menerima pesan tentang perubahan status Pemain, server memperbarui Status Ruangan.
Silakan merujuk ke panduan berikut. [[err] ﻿]
﻿
Misalnya, mari kita anggap bahwa pemain lokal Anda bernama B.
Ketika Pemain Jaringan A bergabung dengan Ruangan, mereka diinstansiasi pada koordinat x:0, y:0, z:0.
Jika Pemain A bergerak ke posisi x: -10, y: 0, z: 0, B tidak memiliki cara nyata untuk mengetahui bahwa A sedang bergerak.
Ini karena keduanya dioperasikan secara lokal di perangkat terpisah, sehingga di klien yang terpisah.
Dengan demikian, orang yang mengendalikan A perlu mengkomunikasikan gerakannya ke server melalui Pesan Ruangan.
Setelah server menerima informasi ini, ia memberitahu semua orang yang hadir di Ruangan tentang posisi A secara real-time. Dengan cara ini, B akhirnya menyadari bahwa A sedang bergerak.
Agar server dapat memberi tahu pemain lain, ada dua metode:
Menggunakan siaran Pesan Ruangan.
Memperbarui Status Ruangan, kemudian meminta klien untuk mengambil dan menerapkan Status Ruangan.
Panduan ini menggunakan metode kedua untuk memperbarui Status Ruangan.
﻿
﻿
Mengingat bahwa Pemain Zepeto yang dimuat ke dalam Adegan memiliki atribut karakter Zepeto, Anda dapat menggunakan fungsi karakter Zepeto untuk memerintahkan gerakan ke lokasi tertentu atau memulai lompatan.
Agar klien B dapat memvisualisasikan gerakan A ke x:-10, y:0, z:0, pendekatan yang paling intuitif adalah menggunakan MoveToPosition(). Fungsi ini akan memindahkan pemain ke posisi terbaru A yang diterima dari server.
Tidak hanya perubahan posisi, tetapi juga gerakan, penggunaan keterampilan, pengumpulan item, dan semua perubahan status memerlukan komunikasi server-klien untuk sinkronisasi.
Anda perlu menerapkan sinkronisasi untuk menjaga setiap tindakan tetap harmonis di seluruh jaringan.
👍 Ringkasan Konsep Sinkronisasi
Ketika Pemain Lokal mengalami perubahan status, mereka mengirimkannya ke server menggunakan Pesan Ruangan.
Server memberi tahu semua pemain lain kecuali pemain lokal tentang perubahan status.
Setelah menerima pesan perubahan status, kode klien memperbarui status Pemain yang mengirim pesan tersebut.
﻿
LANGKAH 3-1 : Skrip Server dengan Sinkronisasi Posisi yang Selesai
Dalam skrip server dasar, implementasi tambahan diperlukan untuk memperbarui Status Ruangan setiap kali pesan tentang perubahan status dari klien Pemain Lokal diterima.
TypeScript
import {Sandbox, SandboxOptions, SandboxPlayer} from "ZEPETO.Multiplay";

import {Player, Transform, Vector3} from "ZEPETO.Multiplay.Schema";
 
export default class extends Sandbox {
 
     
    constructor() {
        super();
    }
 
    onCreate(options: SandboxOptions) {
        // Dipanggil ketika objek Ruangan dibuat.
        // Tangani inisialisasi status atau data objek Ruangan.
 
        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; // Pengendali Karakter V2
            }
        });
    }
     
    
     
    async onJoin(client: SandboxPlayer) {
 
        // Buat objek pemain yang didefinisikan dalam schemas.json dan atur nilai awal.
        console.log(`[OnJoin] sessionId : ${client.sessionId}, userId : ${client.userId}`)
 
        const player = new Player();
        player.sessionId = client.sessionId;
 
        if (client.userId) {
            player.zepetoUserId = client.userId;
        }
         // Kelola objek Pemain menggunakan sessionId, nilai kunci unik dari objek klien.
        // Klien dapat memeriksa informasi tentang objek pemain yang ditambahkan dengan menambahkan acara add_OnAdd ke objek pemain.
        this.state.players.set(client.sessionId, player);
    }
 
    async onLeave(client: SandboxPlayer, consented?: boolean) {
 
        // Dengan mengatur allowReconnection, dimungkinkan untuk mempertahankan koneksi untuk sirkuit, tetapi bersihkan segera dalam panduan dasar.
        // Klien dapat memeriksa informasi tentang objek pemain yang dihapus dengan menambahkan acara add_OnRemove ke objek pemain.
        this.state.players.delete(client.sessionId);
    }
}


import {Sandbox, SandboxOptions, SandboxPlayer} from "ZEPETO.Multiplay";

import {Player, Transform, Vector3} from "ZEPETO.Multiplay.Schema";
 
export default class extends Sandbox {
 
     
    constructor() {
        super();
    }
 
    onCreate(options: SandboxOptions) {
        // Dipanggil ketika objek Ruangan dibuat.
        // Tangani inisialisasi status atau data objek Ruangan.
 
        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; // Pengendali Karakter V2
            }
        });
    }
     
    
     
    async onJoin(client: SandboxPlayer) {
 
        // Buat objek pemain yang didefinisikan dalam schemas.json dan atur nilai awal.
        console.log(`[OnJoin] sessionId : ${client.sessionId}, userId : ${client.userId}`)
 
        const player = new Player();
        player.sessionId = client.sessionId;
 
        if (client.userId) {
            player.zepetoUserId = client.userId;
        }
         // Kelola objek Pemain menggunakan sessionId, nilai kunci unik dari objek klien.
        // Klien dapat memeriksa informasi tentang objek pemain yang ditambahkan dengan menambahkan acara add_OnAdd ke objek pemain.
        this.state.players.set(client.sessionId, player);
    }
 
    async onLeave(client: SandboxPlayer, consented?: boolean) {
 
        // Dengan mengatur allowReconnection, dimungkinkan untuk mempertahankan koneksi untuk sirkuit, tetapi bersihkan segera dalam panduan dasar.
        // Klien dapat memeriksa informasi tentang objek pemain yang dihapus dengan menambahkan acara add_OnRemove ke objek pemain.
        this.state.players.delete(client.sessionId);
    }
}

﻿
﻿
LANGKAH 3-2 : Skrip Klien dengan Sinkronisasi Posisi yang Selesai
Implementasi kunci dalam skrip klien dasar adalah:
Secara otomatis panggil OnStateChange ketika Status Ruangan server berubah.
Menggunakan SendMessageLoop(0.04) fungsi, kirim posisi pemain lokal dan informasi status lompatan karakter ke server setiap 0,04 detik.
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));
    }
 
    // Kirim transformasi karakter lokal ke server pada Interval Waktu yang dijadwalkan.
    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) {
 
        // Ketika event OnStateChange pertama diterima, snapshot status penuh dicatat.
        if (isFirst) {
 
            // [CharacterController] (Lokal) Dipanggil ketika instance Pemain sepenuhnya dimuat di Scene
            ZepetoPlayers.instance.OnAddedLocalPlayer.AddListener(() => {
                const myPlayer = ZepetoPlayers.instance.LocalPlayer.zepetoPlayer;
                this.zepetoPlayer = myPlayer;
            });
 
            // [CharacterController] (Lokal) Dipanggil ketika instance Pemain sepenuhnya dimuat di Scene
            ZepetoPlayers.instance.OnAddedPlayer.AddListener((sessionId: string) => {
                const isLocal = this.room.SessionId === sessionId;
                if (!isLocal) {
                    const player: Player = this.currentPlayers.get(sessionId);
 
                    // [RoomState] Dipanggil setiap kali status instance pemain diperbarui.
                    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] Buat instance pemain untuk pemain yang masuk ke Ruangan
        join.forEach((player: Player, sessionId: string) => this.OnJoinPlayer(sessionId, player));
 
        // [RoomState] Hapus instance pemain untuk pemain yang keluar dari ruangan
        leave.forEach((player: Player, sessionId: string) => this.OnLeavePlayer(sessionId, player));
    }
 
    private OnJoinPlayer(sessionId: string, player: Player) {
        console.log(`[OnJoinPlayer] pemain - 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] pemain - 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
        );
    }
}
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));
    }
 
    // Kirim transformasi karakter lokal ke server pada Interval Waktu yang dijadwalkan.
    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) {
 
        // Ketika event OnStateChange pertama diterima, snapshot status penuh dicatat.
        if (isFirst) {
 
            // [CharacterController] (Lokal) Dipanggil ketika instance Pemain sepenuhnya dimuat di Scene
            ZepetoPlayers.instance.OnAddedLocalPlayer.AddListener(() => {
                const myPlayer = ZepetoPlayers.instance.LocalPlayer.zepetoPlayer;
                this.zepetoPlayer = myPlayer;
            });
 
            // [CharacterController] (Lokal) Dipanggil ketika instance Pemain sepenuhnya dimuat di Scene
            ZepetoPlayers.instance.OnAddedPlayer.AddListener((sessionId: string) => {
                const isLocal = this.room.SessionId === sessionId;
                if (!isLocal) {
                    const player: Player = this.currentPlayers.get(sessionId);
 
                    // [RoomState] Dipanggil setiap kali status instance pemain diperbarui.
                    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] Buat instance pemain untuk pemain yang masuk ke Ruangan
        join.forEach((player: Player, sessionId: string) => this.OnJoinPlayer(sessionId, player));
 
        // [RoomState] Hapus instance pemain untuk pemain yang keluar dari ruangan
        leave.forEach((player: Player, sessionId: string) => this.OnLeavePlayer(sessionId, player));
    }
 
    private OnJoinPlayer(sessionId: string, player: Player) {
        console.log(`[OnJoinPlayer] pemain - 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] pemain - 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
        );
    }
}
﻿
﻿
Dengan kode sinkronisasi posisi diterapkan, tidak hanya pemain lokal saya tetapi juga gerakan pemain lain ditampilkan.
﻿
﻿
👍 Tips
Panduan ini hanya menerapkan sinkronisasi posisi. Sinkronisasi gerakan, sinkronisasi objek, dll., belum diterapkan.
Prinsipnya sama untuk semua, tetapi proses mengirim dan menerima Pesan Ruang pada setiap momen yang diperlukan adalah hal yang penting.
Jika Anda ingin menerapkan sinkronisasi dengan lebih nyaman, pertimbangkan untuk menggunakan modul sinkronisasi multiplay.
﻿
ZepetoPlayer	Deskripsi
Pemain Lokal	Mewakili instansi karakter ZEPETO yang dikendalikan langsung oleh pengguna lokal. - Dilengkapi dengan komponen Pengendali Karakter/Kamera Zepeto.
Pemain Jaringan (Pemain Jarak Jauh)	Instansi karakter ZEPETO yang dapat dimuat dan digunakan dalam konten multiplay. - Tidak memiliki komponen Pengendali Karakter/Kamera Zepeto yang terpasang.
Pemain Bot	Instansi karakter ZEPETO untuk konten multiplay, tetapi dikendalikan oleh bot alih-alih pengguna nyata. Digunakan sebagai pengganti saat memulai dunia multiplayer dengan pemain yang tidak mencukupi atau jika seorang pemain meninggalkan permainan selama bermain. - Tidak memiliki komponen Pengendali Karakter/Kamera Zepeto yang terpasang.
Diperbarui 11 Oct 2024
Apakah halaman ini membantu Anda?