Index of every page on this site: llms.txt
All skills
jame581 avatar

/multiplayer-basics

@426e8ab
by Jan Mesarčjame581/godotprompter979 stars
63
Run it yourself

Use when implementing multiplayer — MultiplayerAPI, ENet/WebSocket peers, RPCs, and authority model

Use this Skill: https://skilld.dev/gh/jame581/godotprompter/multiplayer-basics

Nothing lands on disk. Nothing to clean up.

Fork this Skill

Edit a local copy. It keeps the author and licence.

SKILL.md

≈30 tokens for metadata: the name and description. ≈3.2k when used: this file. ≈3.9k more on demand in 4 files.

Description uses 1.5% of example budget

Before choosing a Skill, your Agent reads its name and description. All available Skills share that space.

  • A shorter description leaves more room for other Skills. This entry exceeds our 1% size suggestion.

In our Claude Code example, all Skill names and descriptions share 8,000 characters. This Skill uses ≈120 characters, or 1.5%.

The 1% threshold is a size suggestion. Longer descriptions can still fit.

Your model, settings, and other Skills decide how much text your Agent can read.

Example settings and source

The example uses a 200k-token context and default Claude Code settings. The count includes the name, description, separators, and when_to_use when present. Codex also counts local file paths.

Skit's source and limits: Codex 0.160.1, Claude Code 2.1.292.

Multiplayer Basics in Godot 4.3+

All examples target Godot 4.3+ with no deprecated APIs. GDScript is shown first, C# follows.

Related skills: See multiplayer-sync for state synchronization and interpolation. See dedicated-server for headless export and server deployment.


1. Multiplayer Architecture

Godot uses a client-server model built on top of MultiplayerAPI. One peer acts as the server; all others are clients. Every peer has a unique integer ID assigned by the network layer:

Peer ID Role
1 The server (always)
2+ Connected clients — randomly generated unique IDs, not sequential

Multiplayer authority is the concept of ownership over a node. Only the authoritative peer should read input and drive that node's state. By default the server (peer 1) is the authority for every node. Call set_multiplayer_authority(peer_id) to transfer ownership to a client — on every peer, since the call is local and is not replicated.

Server (peer 1)
    ├── Owns game state by default
    ├── Spawns and validates objects
    └── Routes RPCs
Client (peer 2, 3, …)
    ├── Sends input to server via RPC
    └── Receives state updates from server

2. Setting Up ENetMultiplayerPeer

Both sides use the same three steps: create an ENetMultiplayerPeer, call create_server(port, max_clients) or create_client(address, port), then assign it to multiplayer.multiplayer_peer and connect the MultiplayerAPI signals (peer_connected, peer_disconnected, connected_to_server, connection_failed, plus server_disconnected — see §7). Check the create_* return value — it returns an Error, and a silent ERR_CANT_CREATE (port already in use) otherwise looks exactly like a hang.

The server is always peer ID 1; clients receive randomly generated unique IDs, so never assume they are sequential.

Full server and client implementations with every signal handler, in GDScript and C#: references/enet-setup.md


3. RPCs

@rpc (GDScript) / [Rpc] (C#) marks a method as callable across the network. Choose the mode and transfer settings carefully — they affect both security and performance.

RPC Modes

Mode Who may call it Executes on
"authority" (default) Only the authority peer The peer(s) it is sent to
"any_peer" Any connected peer The peer(s) it is sent to

Transfer Modes

Mode Delivery Order Use For
"reliable" Guaranteed In-order Chat, spawn events, important state
"unreliable" Best-effort Unordered High-frequency position updates
"unreliable_ordered" Best-effort In-order per channel Smooth movement streams

GDScript

# chat.gd
extends Node2D

# Any peer can call; server validates then broadcasts to all peers.
@rpc("any_peer", "reliable")
func send_chat_message(text: String) -> void:
	if not multiplayer.is_server():
		return
	var sender_id := multiplayer.get_remote_sender_id()
	_broadcast_chat.rpc(sender_id, text)


# Only the authority (server) can call this; runs on every peer.
@rpc("authority", "reliable", "call_local")
func _broadcast_chat(sender_id: int, text: String) -> void:
	print("[%d]: %s" % [sender_id, text])


# Client → server: request to spawn an object.
@rpc("any_peer", "reliable")
func request_spawn(scene_path: String, spawn_position: Vector2) -> void:
	if not multiplayer.is_server():
		return
	# Server validates and performs the actual spawn.
	var scene: PackedScene = load(scene_path)
	if scene == null:
		return
	var instance := scene.instantiate()
	instance.global_position = spawn_position
	get_tree().root.add_child(instance)


# High-frequency sync; unreliable_ordered + a channel keeps this off other RPC traffic.
@rpc("authority", "unreliable_ordered", "call_local", 1)
func sync_position(pos: Vector2) -> void:
	global_position = pos

Sending to specific peers:

# Send to everyone (including self if call_local is set):
send_chat_message.rpc("Hello!")

# Send to one specific peer:
send_chat_message.rpc_id(target_peer_id, "Hello!")

C#

// Chat.cs
using Godot;

public partial class Chat : Node2D
{
    // Any peer can call; executes on the server only.
    [Rpc(MultiplayerApi.RpcMode.AnyPeer, TransferMode = MultiplayerPeer.TransferModeEnum.Reliable)]
    public void SendChatMessage(string text)
    {
        if (!Multiplayer.IsServer()) return;
        int senderId = Multiplayer.GetRemoteSenderId();
        Rpc(MethodName.BroadcastChat, senderId, text);
    }

    // Authority only; runs on every peer including the caller.
    [Rpc(MultiplayerApi.RpcMode.Authority,
         CallLocal = true,
         TransferMode = MultiplayerPeer.TransferModeEnum.Reliable)]
    private void BroadcastChat(int senderId, string text)
        => GD.Print($"[{senderId}]: {text}");

    // Client → server: request a spawn.
    [Rpc(MultiplayerApi.RpcMode.AnyPeer, TransferMode = MultiplayerPeer.TransferModeEnum.Reliable)]
    public void RequestSpawn(string scenePath, Vector2 spawnPosition)
    {
        if (!Multiplayer.IsServer()) return;
        var scene = GD.Load<PackedScene>(scenePath);
        if (scene == null) return;
        var instance = scene.Instantiate<Node2D>();
        instance.GlobalPosition = spawnPosition;
        GetTree().Root.AddChild(instance);
    }

    // High-frequency position sync.
    [Rpc(MultiplayerApi.RpcMode.Authority,
         CallLocal = true,
         TransferMode = MultiplayerPeer.TransferModeEnum.UnreliableOrdered,
         TransferChannel = 1)]
    public void SyncPosition(Vector2 pos)
        => GlobalPosition = pos;
}

Sending to specific peers in C#:

// Broadcast to all:
Rpc(MethodName.SendChatMessage, "Hello!");

// Send to one peer:
RpcId(targetPeerId, MethodName.SendChatMessage, "Hello!");

4. Authority Model

Every node has exactly one authoritative peer — the peer that is permitted to send state updates for that node. Other peers should treat incoming state as read-only.

GDScript

# player.gd
extends CharacterBody2D

func _ready() -> void:
	# multiplayer.get_unique_id() = this peer's ID; server assigns authority during spawn (see Section 6).
	pass


func _physics_process(delta: float) -> void:
	# Guard: authority-only input and movement.
	if not is_multiplayer_authority():
		return

	var direction := Input.get_vector("ui_left", "ui_right", "ui_up", "ui_down")
	velocity = direction * 200.0
	move_and_slide()

	sync_position.rpc(global_position)


@rpc("authority", "unreliable_ordered", "call_local", 1)
func sync_position(pos: Vector2) -> void:
	if not is_multiplayer_authority():
		global_position = pos


func print_authority_info() -> void:
	print("My peer ID : %d" % multiplayer.get_unique_id())
	print("Authority  : %d" % get_multiplayer_authority())
	print("Am I auth? : %s" % str(is_multiplayer_authority()))

C#

// Player.cs
using Godot;

public partial class Player : CharacterBody2D
{
    public override void _PhysicsProcess(double delta)
    {
        // Guard: authority-only input.
        if (!IsMultiplayerAuthority()) return;

        var direction = Input.GetVector("ui_left", "ui_right", "ui_up", "ui_down");
        Velocity = direction * 200f;
        MoveAndSlide();

        Rpc(MethodName.SyncPosition, GlobalPosition);
    }

    [Rpc(MultiplayerApi.RpcMode.Authority,
         CallLocal = true,
         TransferMode = MultiplayerPeer.TransferModeEnum.UnreliableOrdered,
         TransferChannel = 1)]
    private void SyncPosition(Vector2 pos)
    {
        if (!IsMultiplayerAuthority())
            GlobalPosition = pos;
    }
}

API summary:

Method Returns Notes
multiplayer.get_unique_id() int This peer's ID
get_multiplayer_authority() int ID of the peer that owns this node
is_multiplayer_authority() bool True if this peer owns this node
set_multiplayer_authority(id) void Transfer ownership; local only — call it on every peer (e.g. in the spawn function)

5. Spawning Networked Objects

Use MultiplayerSpawner to replicate scene instances across peers. Register the scenes (add_spawnable_scene() or the inspector's Auto Spawn List); when the server adds an instance of one as a direct child of the spawn_path node, the spawner instantiates it on every peer. For a spawn that needs data (position, owner), set spawn_function and call spawn(data) on the server.

See references/spawning-networked-objects.md for MultiplayerSpawner scene setup and the spawn-on-server flow (GDScript + C#).


6. Player Join Flow

The full lobby-join lifecycle: peer connects → server allocates a slot → load lobby scene → spawn player node → broadcast peer-list to all clients → on "start match" RPC, transition all peers to gameplay scene.

See references/player-join-flow.md for the full GDScript and C# implementation (peer-connected handler, slot allocation, lobby state, gameplay transition).


7. Disconnect Handling

Listen for peer_disconnected(id) on the multiplayer API. On the server: free the disconnected peer's player node and broadcast the updated peer-list. On clients: detect a server-disconnect and route to a reconnect / main-menu screen.

See references/disconnect-handling.md for the timeout detection settings, server-side cleanup, and client-side reconnect flow (GDScript + C#).


8. Common Pitfalls

Pitfall Symptom Fix
Calling an RPC on the wrong authority Method never runs; the receiver logs RPC '…' is not allowed on node … Check is_multiplayer_authority() before sending; use "any_peer" only where intentional
Desync from unordered RPCs Positions jitter or snap Use "unreliable_ordered" for streams; use "reliable" for critical state changes
Reading input in _process vs _physics_process Movement desyncs on different frame rates Always move CharacterBody2D in _physics_process; send sync RPCs from there too
Not checking is_multiplayer_authority() before input Every peer controls every player Add an if not is_multiplayer_authority(): return guard at the top of input handling
Spawning without MultiplayerSpawner Object appears on server, missing on clients Add replicated instances under a MultiplayerSpawner's spawn_path (scene in its spawnable list), or use its spawn() with a spawn_function
Forgetting call_local on authority RPCs Server state diverges from its own node Add "call_local" when the sender also needs to execute the RPC locally
Calling rpc() before the client has connected Error Trying to call an RPC via a multiplayer peer which is not connected. On clients, send RPCs only after connected_to_server (before a peer is assigned, the default OfflineMultiplayerPeer runs only call_local RPCs, and only locally)
Not stripping res:// scenes from exported builds Clients can read server-only scripts Leave server-only files out of the client preset (Resources tab: export mode or exclude filters), or use PCK encryption for sensitive server code

9. Checklist

  • ENetMultiplayerPeer.create_server() / create_client() return OK before assigning to multiplayer.multiplayer_peer
  • All five multiplayer signals connected: peer_connected, peer_disconnected, connected_to_server, connection_failed, server_disconnected
  • Every node that reads player input guards with if not is_multiplayer_authority(): return
  • Input processing and sync_position RPC are both in _physics_process, not _process
  • RPC modes chosen deliberately: "any_peer" only for client → server calls; "authority" for server → client
  • Unreliable RPCs used only for high-frequency updates (position, rotation); reliable for events (spawn, damage, chat)
  • MultiplayerSpawner configured with all spawnable scenes before the first player joins
  • set_multiplayer_authority(peer_id) called on every peer when each player node is spawned (e.g. inside the spawn_function)
  • peer_disconnected handler frees the player node and removes it from tracking collections
  • server_disconnected handler on clients returns to main menu and nulls multiplayer.multiplayer_peer
  • is_instance_valid() checked before dereferencing any stored node reference in disconnect callbacks
  • No client rpc() calls made before connected_to_server fires

Source: SKILL.md on GitHub

No rule matched.

skilld matched fixed text patterns in SKILL.md and file names. Patterns miss obfuscated code.

skilld run checks every file with the same patterns. It asks for approval before it loads a Skill with a behavior marked Needs approval.

1 alert29d3 checks · Risk HIGH
  • Gen Agent Trust Hub29d

    The skill contains a significant security vulnerability in its multiplayer implementation. It provides example code for an RPC (Remote Procedure Call) that allows remote clients to specify arbitrary file paths for the server to load and instantiate. This pattern enables a malicious peer to execute unauthorized code or access sensitive resources on the server.

  • Socket29d

    No alerts

  • Snyk29d

    Risk: LOW · No issues

Signed by skilld at 426e8ab. This ties the file your Agent reads to that commit on GitHub. It does not review the instructions.

Last checked against GitHub 6 days ago.

Activeupdated last month

README badge

README badge for jame581/godotprompter/multiplayer-basics