Why bother

Humans are the most interesting source of unpredictability.

The Challenge

• Every feature exists twice: what it does, and how the other machines find out.
• You cannot test alone. Two builds, two machines, every single time.
• Bugs stop being easily reproducible. they now depend on timing.
• The game does not degrade gracefully. It works, or the world desyncs.

The four axes

These are independent. Local co-op is multiplayer and does not need networking at all.

Latency

Pick your latency budget before you pick your genre, not after.

Who owns the world state

The whole subject reduces to one question: when two machines disagree, who is right?

• One machine is the authority. Its copy of the state is, by definition, the truth.
• Everyone else holds a prediction of that truth, and is told when they are wrong.
• Every "the state got out of sync" bug is two machines both believing they are right.

Decide this ealry, retrofitting authority into a game is challenging

Two topologies

P2P: n(n-1)/2 links, no owner. Client-server: n links, one authority.

Three flavours of server

Godot makes no distinction. Server or client, same engine, same API, same project.

P2P's real problem is finding you

• Easy: both endpoints have public IPs. Connect directly.
• Best: one endpoint has a public IP and everyone connects to it. That is a server.
• Hard: your machine is behind a Firewall it has no address the outside world can reach.

Almost every home and campus machine is behind NAT. "Just connect to my IP" works in the lab and fails from home.

NAT hole punching

You still need a server with a public IP, just not for the game traffic.

The OSI model

No network protocol actually fits this model. It is vocabulary, not a build spec. Your game logic sits at the top; most games are at layer 4, on UDP.

TCP or UDP

ENet is UDP with reliability you request per message. That is Godot's solution.

Godot 4.7: host or join

const PORT := 25666
var peer := ENetMultiplayerPeer.new()

func become_host() -> void:
    peer.create_server(PORT, MAX_PLAYERS)             # this process is now peer 1
    peer.get_host().compress(ENetConnection.COMPRESS_RANGE_CODER)
    multiplayer.multiplayer_peer = peer

func join_as_client(ip: String) -> void:
    peer.create_client(ip, PORT)                      # server hands me an id
    peer.get_host().compress(ENetConnection.COMPRESS_RANGE_CODER)
    multiplayer.multiplayer_peer = peer

Godot 4.7: the connection signals

func _ready() -> void:
    multiplayer.peer_connected.connect(_on_peer_connected)
    multiplayer.peer_disconnected.connect(_on_peer_disconnected)
    multiplayer.connected_to_server.connect(_on_connected_ok)
    multiplayer.server_disconnected.connect(_on_server_gone)

func _on_peer_connected(id: int) -> void:
    if not multiplayer.is_server(): return
    roster[id] = {"name": "", "slide": 0}            # only the server keeps the roster

Put this on an autoload, so the node path is identical on every machine.

Three levers on every RPC

@rpc("authority", "call_local", "reliable")   # only peer 1 may call it
@rpc("any_peer",  "call_remote", "reliable")  # any client may call it
@rpc("any_peer",  "unreliable")               # fire and forget: position spam

Pattern 1 — client asks, server decides

# levels/slides/slides.gd — the lecturer presses the arrow key
Lecture.set_slide(current)             # → _request_slide.rpc_id(1, index)

# scripts/lecture_session.gd — the server rules on it
@rpc("any_peer", "reliable")
func _request_slide(index: int) -> void:
    if not multiplayer.is_server(): return
    if not _is_lecturer(multiplayer.get_remote_sender_id()):
        return                         # a student asking is simply ignored
    _broadcast_slide(index)

"any_peer" means anyone may call it. The body decides whether to act.

Pattern 2 — server tells everyone

func _broadcast_slide(index: int) -> void:
    current_slide = index
    _set_slide.rpc(index)                   # server → every peer

@rpc("authority", "call_local", "reliable")
func _set_slide(index: int) -> void:
    current_slide = index
    slide_changed.emit(index)               # every listening scene reacts

"authority" — a client calling this is refused by the engine, before your code runs.

Pattern 3 — server tells one peer

# scripts/lecture_session.gd — a peer has just identified itself
_auth_reply.rpc_id(sender, granted, message, role)
_set_pack.rpc_id(sender, current_pack, current_slide)
_set_activity.rpc_id(sender, current_activity, current_slide)

Same function, three audiences:

The three patterns together

Authority decides who may speak; rpc / rpc_id decides who hears it.

Authority per node, not per game

# prefabs/player/player.gd
func _enter_tree() -> void:
    set_multiplayer_authority(name.to_int(), true)    # "Player7" → peer 7 owns it

func _physics_process(delta: float) -> void:
    if multiplayer.has_multiplayer_peer() and not is_multiplayer_authority():
        return                                        # remote copies read no input
    velocity.x = move_toward(velocity.x, Input.get_axis("left", "right") * SPEED, ACCELERATION)
    move_and_slide()

You cannot drive my character, because you do not hold authority over that node.

The two nodes that do the work

# levels/main/main.gd
player_spawner.spawn_function = spawn_player
if multiplayer.is_server():
    player_spawner.spawn(player_id)      # one call; every peer gets the node

You write move_and_slide(). The engine writes the packets.

Replicate this, recompute that

Optimisizing bandwidth by not using it in the first place.

Unreal 5.8: the same ideas, different nouns

bReplicateMovement gives you Location, Rotation and Velocity automatically.

The scope ladder

Recap and reading

• One machine is the authority. Everyone else holds a guess and gets corrected.
• Client-server unless you have a reason; the server is peer 1 in Godot.
• Three RPC levers: who may call, who hears it, may it be lost.
• Replicate input and events; recompute everything you can derive.

Godot high-level multiplayer · MultiplayerSynchronizer · Unreal networking · Gambetta, Fast-Paced Multiplayer