Multiplayer and Networking Basics

# CHAPTER 15

Multiplayer and Networking Basics #

1. Introduction #

2. Learning Objectives #

• Understand the Authoritative Client-Server architecture.

• Differentiate between a Host, a Client, and a Dedicated Server.

• Understand how Network Transforms synchronize positions.

• Use Remote Procedure Calls (RPCs) to trigger events across the network.

• Understand the dangers of "Trusting the Client."

3. The Client-Server Model (The Referee) #

• The Server (The Referee): This machine holds the absolute truth. If the Server says Player A is dead, Player A is dead. It receives input from clients, calculates the physics, and broadcasts the results.

• The Client (The Player): The player's computer. It is essentially a "dumb terminal." It says, "I pressed the W key," sends that to the Server, and then waits for the Server to reply, "Okay, draw your character moving forward."

4. Hosting vs. Dedicated Servers #

• Dedicated Server: A massive computer sitting in a server farm (like AWS). It runs a version of the game with *no graphics*. It purely calculates math for 100 players. (Used for MMOs and Battle Royales).

• Listen Server (Host): Player A starts the game and acts as BOTH the Server and a Client. Player B connects directly to Player A's IP address. (Used for co-op indie games like *Lethal Company*).

5. Synchronizing Variables (State Replication) #

• Instead of using a standard int health;, you use a NetworkVariable<int> health;.

• When the Server changes the health variable, the engine automatically packages that data, sends it across the internet 30 times a second, and applies it to Player A's avatar on Player B's screen.

6. Remote Procedure Calls (RPCs) #

• ServerRpc: A Client calls this, but the code ONLY runs on the Server. (e.g., "Server, I would like to buy this sword, please check my gold.")

• ClientRpc: The Server calls this, and the code runs on EVERY Client's computer. (e.g., "Clients, the boss is dead, play the victory music!")

// Example using a generic networking structure

// 1. Client asks the Server to fire a gun
[ServerRpc]
void RequestFireServerRpc()
{
    // Server checks if we have ammo
    if (ammo > 0)
    {
        ammo--;
        // Server tells EVERYONE to play the visual effect
        PlayShootEffectClientRpc(); 
    }
}

// 2. Server forces all Clients to run this visual code
[ClientRpc]
void PlayShootEffectClientRpc()
{
    // This happens on Player A, B, and C's screens simultaneously!
    Instantiate(muzzleFlash, gunBarrel.position, Quaternion.identity);
    audioSource.Play();
}

7. Visual Learning: The RPC Flow #

[ Player A (Client 1) ]
Presses 'Fire' Button -> Calls 'RequestFireServerRpc()'
         |
    (Internet)
         |
         v
[ Server (The Host) ] -> Receives RPC, checks Ammo, executes 'PlayShootEffectClientRpc()'.
         |
    (Internet)
         |
         v
[ Player B (Client 2) ] -> Receives RPC -> Automatically executes 'PlayShootEffect()'.
Player B sees Player A shoot!

8. Best Practices #

• Network Authority: By default, the Server owns everything. If a Client tries to move a network bullet, the Server will ignore it. You must explicitly set "Ownership". The Server must grant Client #2 ownership of Character #2, allowing that specific C# script to send movement updates.

9. Common Mistakes #

• Trusting the Client: If you let the Client's UI subtract $100 from their inventory and send an RPC saying BuySwordServerRpc(Sword), a hacker can easily intercept that code, alter the RPC to say they have infinite gold, and give themselves infinite swords. *Never trust the client.* The client should only send an RPC saying RequestPurchaseServerRpc(). The Server checks the gold, calculates the math, and syncs the new inventory back to the client.

10. Mini Project: Networked Movement Logic #

class NetworkPlayer : NetworkBehaviour // (Using generic netcode structure)
{
    void Update()
    {
        // MAGIC CHECK: Am I the human sitting at this specific keyboard?
        // If not, STOP reading the input! Let the network sync my position instead.
        if (!IsOwner) return;

        // I own this object, so I can control it!
        float h = Input.GetAxis("Horizontal");
        transform.Translate(new Vector3(h, 0, 0) * Time.deltaTime);
    }
}

11. Practice Exercises #

1. 1. What is the fundamental difference between a ServerRpc and a ClientRpc?

1. 2. Why is the "Authoritative Server" model the industry standard for preventing hacking in online games?

12. MCQs with Answers #

13. Interview Questions #

• Q: Explain the concept of "Network Authority." Why must a specific peer ID be assigned ownership of a Node before allowing a client to control it?

• Q: Walk me through the security vulnerability of "Trusting the Client." Give an example of how a client-side hit detection script for a sniper rifle could be exploited, and how you would fix it using Server Authority.

• Q: Contrast state replication (Network Variables) with Remote Procedure Calls (RPCs). When would you explicitly choose to use an RPC instead of a Network Variable?

14. FAQs #

15. Summary #

16. Next Chapter Recommendation #