📞 Lesson 10.3: RPCs — Server, Client & Multicast

Three Directions

An RPC is declared with a UFUNCTION specifier that names where it runs. The three:

Server RPCs

The workhorse: a client asks the server to do something authoritative. Declared with Server, defined in a _Implementation function (the same suffix pattern as BlueprintNativeEvent, Lesson 6.1).

// Weapon.h
// Server = runs on server; Reliable = guaranteed; WithValidation = anti-cheat check.
UFUNCTION(Server, Reliable, WithValidation)
void ServerFire(const FVector& Direction);

// Weapon.cpp
// The actual body goes in _Implementation:
void AWeapon::ServerFire_Implementation(const FVector& Direction)
{
    // This runs on the SERVER, with authority (Lesson 10.1).
    // Do the real, authoritative work: trace, apply damage, spend ammo.
    // ...then Multicast the cosmetic effect (next section)...
}

// _Validate runs on the server BEFORE _Implementation — reject cheating.
bool AWeapon::ServerFire_Validate(const FVector& Direction)
{
    // Return false to drop the RPC and flag the client as misbehaving.
    return Direction.IsNormalized();   // e.g. reject a malformed direction
}

You call it plainly from the client — Unreal routes it to the server:

// On the client (e.g. from input, Lesson 4.1):
void AWeapon::TryFire()
{
    const FVector Dir = GetAimDirection();
    ServerFire(Dir);   // looks like a normal call; actually runs on the server
}

Multicast & Client RPCs

Once the server has done authoritative work, it often needs to tell others. NetMulticast tells everyone (great for cosmetic effects); Client tells one specific player.

// NetMulticast: the server calls it, it runs on server + all clients.
UFUNCTION(NetMulticast, Unreliable)
void MulticastPlayFireFX();

void AWeapon::MulticastPlayFireFX_Implementation()
{
    // Runs everywhere — play muzzle flash, sound, tracer on every machine.
    PlayFireEffects();
}

// Client: the server calls it, it runs only on the owning client.
UFUNCTION(Client, Reliable)
void ClientNotifyLevelUp(int32 NewLevel);

void APlayerState::ClientNotifyLevelUp_Implementation(int32 NewLevel)
{
    // Runs only on THAT player's client — show their personal level-up UI.
}

Reliable vs Unreliable

Every RPC is Reliable or Unreliable — a real performance/correctness trade-off:

The Full Fire Pattern

Now the three-part pattern from Lesson 10.1 in complete code — a networked weapon fire:

// 1) CLIENT presses fire → asks the server (Server RPC).
void AWeapon::TryFire()
{
    if (!CanFire()) { return; }
    ServerFire(GetAimDirection());   // routes to server
}

// 2) SERVER does the authoritative work, then tells everyone the cosmetic part.
void AWeapon::ServerFire_Implementation(const FVector& Dir)
{
    // Authoritative (server): trace + apply damage + spend ammo.
    --CurrentAmmo;                                   // replicated (Lesson 10.2)
    FHitResult Hit;
    if (TraceShot(Dir, Hit))                          // trace (Lesson 5.2)
    {
        if (UHealthComponent* HC = Hit.GetActor()->FindComponentByClass<UHealthComponent>())
        {
            HC->ApplyDamage(Damage);                  // server-authoritative
        }
    }
    // 3) Tell everyone to play the effect (Multicast).
    MulticastPlayFireFX();
}

bool AWeapon::ServerFire_Validate(const FVector& Dir) { return Dir.IsNormalized(); }

void AWeapon::MulticastPlayFireFX_Implementation()
{
    PlayFireEffects();   // muzzle flash + sound on server & every client
}

Hands-on Exercise & Quiz

Summary

📚 Additional Resources

• Remote Procedure Calls (Epic)
• Networking & Multiplayer (Epic)

🚀 What's Next?

You have all three networking tools — authority, replication, and RPCs. The module finale ties them into one complete replicated gameplay feature, walked end to end, so you see the whole pattern working together.