Multiplayer Desyncs: Memperbaiki Unreal Engine RPC Replication Issue yang Merusak State Anda

Setiap developer indie game multiplayer tahu persis saat di mana netcode mereka mengkhianati mereka. Anda memicu RPC Run on Server untuk melengkapi senjata. Log server mengonfirmasi senjata telah terpasang. Collision cylinder server menunjukkan Anda dalam posisi membidik. Tapi di layar client Anda? Karakter Anda hanya berdiri di sana dalam pose idle default, sama sekali tidak merespons perubahan state.

Ketika logika equip senjata, aim states, interaksi inventaris, dan sistem crafting tiba-tiba berhenti memperbarui di client, kepanikan pun muncul. Anda mungkin menemukan bahwa mengubah RPC menjadi Multicast secara ajaib memperbaiki bug visual tersebut.

Jangan biarkan tetap di Multicast.

Menggunakan Multicast untuk memperbaiki bug state yang persisten adalah solusi sementara yang pada akhirnya akan menghancurkan network performance game Anda dan merusak pengalaman bagi pemain yang baru bergabung (late-joining). Dalam pembahasan mendalam ini, kita akan membongkar akar penyebab dari unreal engine rpc replication issue yang ditakuti, menjelaskan mengapa server states Anda mengabaikan client Anda, dan merancang sinkronisasi state server-authoritative yang tangguh menggunakan C++.

Jebakan Multicast: Mengapa Ini "Berhasil" (Dan Mengapa Ini Akan Merusak Game Anda)

Ketika developer menghadapi bug ini, proses berpikirnya biasanya seperti ini:

1. Client memanggil Server_EquipWeapon().
2. Server melengkapi senjata.
3. Visual client tidak diperbarui.
4. Ubah Server_EquipWeapon() untuk memanggil Multicast_EquipWeapon().
5. Visual client diperbarui! Bug selesai, kan?

Salah. Untuk memahami alasannya, Anda harus memahami perbedaan mendasar antara RPCs (Remote Procedure Calls) dan Property Replication.

RPC adalah event jaringan yang bersifat sementara. Ini seperti teriakan ke ruang hampa. Jika seorang pemain berada dalam network cull distance saat Multicast dipicu, mereka mendengar teriakan itu dan memainkan animasi equip.

Tapi apa yang terjadi jika seorang pemain bergabung ke server 10 detik kemudian? Apa yang terjadi jika seorang pemain berada sejauh 5.000 Unreal Units, berjalan masuk ke relevancy range, dan melihat karakter Anda? Karena Multicast sudah dipicu di masa lalu, client baru tidak pernah menerima event tersebut. Mereka akan melihat karakter Anda memegang senjata yang tidak terlihat, meluncur dalam pose idle sambil menembakkan peluru dari dada mereka.

Multicast adalah untuk event sementara yang tidak kritis bagi gameplay: visual ledakan, efek suara, atau partikel kosmetik.

Untuk apa pun yang bertahan lama—seperti senjata apa yang Anda pegang, apakah Anda sedang membidik, atau apa yang ada di inventaris Anda—Anda harus menggunakan Property Replication.

Akar Penyebab: Mengapa Tiba-tiba Rusak?

Jika RPC Run on Server Anda sebelumnya berfungsi dan tiba-tiba rusak di berbagai sistem (senjata, membidik, crafting), Anda kemungkinan besar menjadi korban dari salah satu dari tiga pergeseran arsitektur dalam proyek Anda:

1. Ilusi Listen Server vs. Dedicated Server

Jika Anda sebelumnya melakukan pengujian di Play-In-Editor (PIE) menggunakan Listen Server, pemain host adalah client sekaligus server. RPC "Run on Server" yang dijalankan oleh host segera memperbarui visual state lokal karena host adalah server. Ketika Anda akhirnya beralih ke pengujian Dedicated Server (atau menguji sebagai Client 2), ilusi itu hancur. Server memperbarui memori yang terisolasi, dan client tertinggal.

2. Ownership ActorComponent yang Rusak

Jika Anda baru saja merefaktorisasi logika inventaris atau senjata ke dalam class UActorComponent, Anda mungkin telah memutus rantai replikasi. RPC hanya dapat dipanggil dari client jika client memiliki (owns) Actor tersebut. Jika komponen Anda di-spawn secara dinamis dan tidak secara eksplisit diberi pemilik melalui SetOwner(PlayerController), server akan mengabaikan RPC atau gagal mereplikasi state kembali. Kami membahas mimpi buruk arsitektur ini dalam panduan kami tentang Multiplayer Inventory Nightmares Fixing Swapped Actorcomponent Owners In Unreal Engine.

3. Melewati Local State

Sebelumnya, input event di sisi client Anda mungkin telah menyetel boolean bIsAiming lokal sebelum memanggil Server RPC. Jika Anda merefaktorisasi kode Anda menjadi murni "Server Authoritative" (menunggu server mendikte state), tetapi lupa mereplikasi state tersebut kembali ke client, client Anda akan menunggu selamanya untuk pembaruan yang tidak pernah datang.

Tutorial Langkah-demi-Langkah: Merancang Replikasi State yang Tangguh

Untuk memperbaiki unreal engine rpc replication issue ini, kita harus beralih dari arsitektur berbasis RPC ke State-Driven Architecture menggunakan RepNotifies.

Berikut cara mengimplementasikan sistem equip senjata dan membidik server-authoritative yang memperbarui client dengan mulus.

Langkah 1: Tentukan Replicated Properties dengan RepNotifies

Alih-alih mempercayai RPC untuk memicu animasi, kita mendeklarasikan variabel persisten. Ketika server mengubah variabel-variabel ini, Net Driver Unreal secara otomatis menyinkronkannya ke client. Dengan melampirkan fungsi ReplicatedUsing (sebuah RepNotify), kita dapat memicu animasi tepat saat client mengetahui tentang perubahan state.

Dalam file Header Karakter (.h) Anda:

UCLASS()
class MYGAME_API AMyCharacter : public ACharacter
{
    GENERATED_BODY()

public:
    AMyCharacter();

    // State persisten. Direplikasi ke semua client.
    UPROPERTY(ReplicatedUsing = OnRep_EquippedWeapon)
    AWeapon* EquippedWeapon;

    UPROPERTY(ReplicatedUsing = OnRep_IsAiming)
    bool bIsAiming;

    // Fungsi RepNotify. Ini berjalan di client saat server memperbarui variabel.
    UFUNCTION()
    void OnRep_EquippedWeapon();

    UFUNCTION()
    void OnRep_IsAiming();

    // Server RPC untuk meminta perubahan state
    UFUNCTION(Server, Reliable, WithValidation)
    void Server_EquipWeapon(AWeapon* NewWeapon);

    UFUNCTION(Server, Reliable, WithValidation)
    void Server_SetAiming(bool bWantsToAim);

    // Setup replikasi inti
    virtual void GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const override;
};

Langkah 2: Implementasikan Server RPC dan Aturan Replikasi

Dalam file .cpp Anda, Anda harus mendaftarkan variabel-variabel ini di GetLifetimeReplicatedProps. Kemudian, tentukan Server RPC untuk hanya memperbarui state yang authoritative.

#include "MyCharacter.h"
#include "Net/UnrealNetwork.h"

void AMyCharacter::GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const
{
    Super::GetLifetimeReplicatedProps(OutLifetimeProps);

    // Replikasi variabel ini ke semua client yang terhubung
    DOREPLIFETIME(AMyCharacter, EquippedWeapon);
    DOREPLIFETIME(AMyCharacter, bIsAiming);
}

// --- LOGIKA MEMBIDIK ---

bool AMyCharacter::Server_SetAiming_Validate(bool bWantsToAim)
{
    // Anti-cheat: Pastikan pemain diizinkan membidik (misalnya tidak mati)
    return !bIsDead;
}

void AMyCharacter::Server_SetAiming_Implementation(bool bWantsToAim)
{
    bIsAiming = bWantsToAim;
    
    // KRITIS: RepNotifies TIDAK berjalan secara otomatis di server dalam C++.
    // Jika server adalah Listen Server, kita harus memanggilnya secara manual.
    if (GetNetMode() != NM_DedicatedServer)
    {
        OnRep_IsAiming();
    }
}

Langkah 3: Implementasikan RepNotifies untuk Pembaruan Visual

Di sinilah logika animasi, pembaruan UI, dan mesh attachment Anda berada. Karena ini bergantung pada replicated state, pemain yang baru bergabung akan secara otomatis memicu logika ini saat karakter Anda menjadi relevan bagi mereka.

void AMyCharacter::OnRep_IsAiming()
{
    if (UAnimInstance* AnimInst = GetMesh()->GetAnimInstance())
    {
        if (UMyAnimInstance* MyAnim = Cast<UMyAnimInstance>(AnimInst))
        { 
            MyAnim->bIsAiming = bIsAiming;
        }
    }

    GetCharacterMovement()->MaxWalkSpeed = bIsAiming ? 300.f : 600.f;
}

void AMyCharacter::OnRep_EquippedWeapon()
{
    if (EquippedWeapon)
    {
        EquippedWeapon->AttachToComponent(GetMesh(), FAttachmentTransformRules::SnapToTargetNotIncludingScale, FName("WeaponSocket"));
        PlayAnimMontage(EquipMontage);
    }
}

Sentuhan Profesional: Client-Side Prediction

Jika Anda hanya mengimplementasikan apa yang tertulis di atas, Anda akan melihat masalah baru: Input Latency. Jika seorang pemain memiliki ping 100ms, mereka akan menekan tombol "Aim", mengirim Server RPC, server memperbarui bIsAiming, dan replikasi membutuhkan 100ms untuk kembali. Pemain merasakan penundaan 200ms sebelum karakter mereka benar-benar membidik. Dalam game shooter modern, ini terasa sangat buruk.

Untuk memperbaikinya, kita mengimplementasikan Client-Side Prediction. Client secara visual memalsukan perubahan state segera, sambil secara bersamaan meminta izin kepada server.

void AMyCharacter::StartAiming()
{
    // 1. Prediksi secara lokal segera (Nol latensi bagi pemain)
    bIsAiming = true;
    OnRep_IsAiming(); 

    // 2. Beritahu server untuk meresmikannya
    if (!HasAuthority())
    {
        Server_SetAiming(true);
    }
}

Jika server tidak setuju, replicated state akan mengoreksi client. Ini adalah dasar dari arsitektur multiplayer yang kuat, mencerminkan konsep yang kami diskusikan di The Unreal Engine Multiplayer Sync Bug Ruining Your World States And How To Fix It.

Menskalakan Melampaui Pertandingan: Persistensi Player State

Memperbaiki replikasi dalam game memastikan bahwa server dan client Anda setuju pada keadaan dunia saat ini selama pertandingan. Tapi apa yang terjadi pada inventaris dan loadout senjata tersebut saat pertandingan berakhir atau dedicated server dimatikan?

Jika Anda ingin pemain menyimpan senjata yang mereka buat, state tersebut harus keluar dari instance Unreal Engine dan disimpan dalam database yang aman. Membangun ini sendiri membutuhkan waktu berminggu-minggu untuk infrastruktur backend.

Dengan horizOn, layanan backend ini sudah dikonfigurasi sebelumnya. Anda dapat menyimpan data pemain langsung ke cloud menggunakan SDK asli. Fokuslah pada merilis game Anda, bukan infrastruktur Anda.

5 Praktik Terbaik untuk Replikasi Unreal Engine

1. Jangan Pernah Menggunakan Multicast untuk Persistent State: Jika sebuah variabel mendeskripsikan keadaan dunia (inventaris, senjata, health), itu harus menjadi Replicated Property. Gunakan Multicast hanya untuk estetika visual.
2. Panggil RepNotifies di Server Secara Manual: Dalam C++, fungsi OnRep_ tidak dipicu secara otomatis di server. Jika server Anda adalah Listen Server, Anda harus memanggilnya secara manual.
3. Validasi Server RPC Anda: Jangan pernah mempercayai client. Gunakan fungsi _Validate untuk memeriksa apakah perubahan state secara logis memungkinkan.
4. Perhatikan NetUpdateFrequency Anda: Jika visual state tampak lag, periksa apakah frekuensi pembaruan Actor Anda menjadi penghambat.
5. Periksa Ownership Komponen: Jika Anda memanggil Server RPC dari UActorComponent, pastikan komponen tersebut disetel untuk mereplikasi dan Actor pemiliknya dikuasai oleh APlayerController.

Berhenti Melawan Net Driver

Sistem replikasi Unreal Engine sangat kuat, tetapi tidak memaafkan jika Anda mencoba melewati aturannya. Saat client states Anda berhenti memperbarui, tahan keinginan untuk menggunakan Multicast secara berlebihan. Ikuti jalur otoritas: client meminta, server mendikte, dan properti mereplikasi.

Siap membawa game multiplayer Anda ke tingkat berikutnya? Berhenti mengkhawatirkan manajemen database dan infrastruktur. Coba horizOn secara gratis hari ini.