ENetMultiplayerPeer in Godot – Complete Guide

Managing the network layer of a multiplayer game can be as thrilling as the game itself. Expect a journey through the realms of peer connections, client creation, and server management, all orchestrated by the ENetMultiplayerPeer class in Godot 4. And that’s exactly what we’re here to explore.

Through this series of tutorials, we aim to demystify the complexities of network communications using Godot’s powerful ENet library, ensuring your foray into multiplayer game development is as smooth as setting a high score in your favorite game.

What is ENetMultiplayerPeer?

ENetMultiplayerPeer is a versatile class in Godot 4 that acts as the backbone for networked multiplayer experiences. It oversees communication between peers over the network using the ENet library, which is known for its efficiency and reliability in handling UDP (User Datagram Protocol) traffic. This class allows developers to set up both clients and servers, paving the way for real-time interactions in multiplayer games.

What is it for?

The ENetMultiplayerPeer is utilized for constructing scalable, network-aware games. It’s the conductor that leads the orchestra of packets between players, ensuring that every jump, shot, and movement is synchronized across the gaming session. Whether you’re hosting a match on a dedicated server or connecting to an existing multiplayer environment, this class makes the process straightforward.

Why should I learn it?

Mastering ENetMultiplayerPeer not only opens the doors to creating vibrant multiplayer games but also equips you with a deep understanding of how game networking functions. Here’s why it’s worth your time:

High demand: With the rising popularity of multiplayer games, knowledge in this area is highly sought after.

Technical edge: Understanding the low-level network operations gives you an advantage when building complex game systems.

Transferable skills: Networking concepts learned here can be applied to other platforms and programming languages.

Equipped with this knowledge, you’re well on your way to bringing players together in the virtual worlds you create. Let’s gear up and delve into the fascinating universe of multiplayer game development with Godot 4.

CTA Small Image

Setting Up a Basic ENet Server

Let’s begin by setting up a basic server using Godot. We first create a new script attached to a Node in our scene and include the necessary ENet classes:

extends Node

# Import the ENet library
var peer = NetworkedMultiplayerENet.new()

func _ready():
    # Initialize the server on a specific port
    var server_port = 9050
    peer.create_server(server_port, max_clients)

    # Assign the ENet peer to the networked multiplayer peer of this node

With just a few lines, we have a server running and listening for connections on port 9050. Next, we will define max_clients, which limits how many players can connect to our game:

var max_clients = 4  # Number of players allowed to connect

Emitting a Signal When Clients Connect

To know when a client has connected successfully, we can make use of Godot’s signaling system:

func _ready():
    peer.connect("peer_connected", self, "_on_peer_connected")

func _on_peer_connected(id):
    print("Peer connected with id: " + str(id))

The peer_connected signal automatically fires when a new client joins the server. The _on_peer_connected() function will print a message showing which unique ID has connected.

Setting Up a Basic ENet Client

On the client side, the setup is quite similar. We initialize a new ENet peer to act as a client and connect it to a running server:

extends Node

var peer = NetworkedMultiplayerENet.new()

func _ready():
    var server_ip = ""
    var server_port = 9050
    # Connect to the server as a client
    peer.create_client(server_ip, server_port)

For local testing, we’re using localhost ( as the server IP. This client will attempt to connect to our server which is listening on port 9050.

Handling Disconnections and Errors

In a robust multiplayer environment, it’s essential to handle disconnections and networking errors gracefully. Here’s how we can detect such events:

# Server Script
func _ready():
    peer.connect("peer_disconnected", self, "_on_peer_disconnected")

func _on_peer_disconnected(id):
    print("Peer disconnected with id: " + str(id))

# Client Script
func _ready():
    # Handle connection errors
    var connection_status = peer.get_connection_status()
    if connection_status == NetworkedMultiplayerPeer.CONNECTION_ERROR:
        print("Connection failed!")

    # This signal is emitted when the connection to the server is lost
    peer.connect("connection_failed", self, "_on_connection_failed")

func _on_connection_failed():
    print("Failed to connect to the server!")

By listening for peer_disconnected on the server and connection_failed on the client, we have a way to detect when a client drops off or if the connection can’t be established.

Sending and Receiving Messages

Messaging is what breathes life into our multiplayer game. Here’s a simple way to send a message from the client to the server and back:

# Server Script
func _ready():
    get_tree().connect("network_peer_packet", self, "_on_packet_received")

func _on_packet_received(id, packet):
    var msg = packet.get_string_from_utf8()
    print("Server received message from ID " + str(id) + ": " + msg)

# Client Script
func _ready():

func send_message(msg):
    # Create packet from string
    var packet = msg.to_utf8()
    # Send packet to server

We use get_string_from_utf8() to decode the message on the server side. Conversely, the client encodes a message with to_utf8() before sending. This demonstrates a basic chat system where clients can send messages to the server.

With these foundations, you’re ready to create simple multiplayer interactions. Remember to test regularly and expand upon the core network mechanics as you add more features to your game. In our upcoming tutorial sections, we’ll dive deeper into complex examples and fine-tune our networking skills.

As we progress deeper into the world of Godot’s networking features, it is crucial to understand how to efficiently manage traffic between clients and servers. Here we will explore advanced aspects like RPCs (Remote Procedure Calls), handling different message types, and synchronizing game states among peers.

Using Remote Procedure Calls (RPCs)

RPCs are one of the most powerful features in Godot’s networking arsenal. They allow you to invoke functions on remote peers cleanly and intuitively. Here’s a quick demonstration:

# Client Script
func _ready():
    # This can be called on the client to invoke 'receive_message' on the server
    rpc_id(1, "receive_message", "Hello Server!")

# Server Script
remote func receive_message(message):
    print("Server: Received - " + message)

By calling rpc_id(), we tell Godot to execute the receive_message function on the peer with the ID we specify. The remote keyword is essential here – it signals Godot that this function can be called from a different peer. This allows us to write concise code for networked interactions.

Handling different message types

In a typical multiplayer game, you’ll be exchanging various types of data, not just chat messages. Let’s look at how to distinguish between different packet types:

# Server Script
func _on_packet_received(id, packet):
    var msg = packet.get_string_from_utf8()
    var message_type = msg.get_slicec(',', 0)
    match message_type:
            _handle_chat_message(id, msg.get_slicec(',', 1))
            _handle_move_message(id, msg.get_slicec(',', 1))
            print("Unknown message type received.")

func _handle_chat_message(id, message):
    print("Chat message from ID " + str(id) + ": " + message)

func _handle_move_message(id, message):
    print("Move message from ID " + str(id) + ": " + message)

In the example above, we’re using a simple protocol where the first part of the message specifies the type (e.g., “chat,Hello” or “move,left”). The server parses this and directs the message to the appropriate handler.

Synchronizing Game States

State synchronization is pivotal in ensuring all players perceive the game world identically. One technique often used is sending periodic state updates from the server to all clients:

# Server Script
func _process(delta):
    if get_tree().is_network_server():
        var state = get_game_state() # Assume this function collects current game state
        var packet = str("state," + state).to_utf8()
        rpc("update_game_state", state)

remote func receive_state(state):
    print("Received state update: " + state)

# Client Script
remote func update_game_state(state):
    print("Client: Received state - " + state)

Here, the server periodically gathers the game state and sends this information to all clients using the rpc() function. Meanwhile, the clients have a remotely callable function, update_game_state(), that updates their local state based on the server’s state.

Automatic Network Synchronization

Godot provides tools to automate the synchronization process of properties. Just a single keyword, puppet, and Godot will handle the rest:

# Relevant to both client and server scripts

# Variable synchronization
puppet var player_position = Vector2()

# Function that sets the position; to be called with puppet keyword on clients
puppet func set_player_position(new_position):
    player_position = new_position

The puppet keyword alongside the variable ensures that it will automatically be synchronized for the puppet (client) by the master (server). When a function is marked with puppet, it means it is intended to be called on the client remotely by the server.

Leveraging these methods, your multiplayer game can efficiently handle various interactions, update the game state across all connected clients, and maintain a consistent experience for every player. Remember, it’s essential to test your network code thoroughly, as even minor discrepancies can significantly impact gameplay.

As we wrap up this section of our multiplayer networking tutorial, remember that Godot’s networking is a potent toolset. Take the time to understand and apply these concepts, and you’ll be on your way to creating engaging multiplayer games that players around the world can enjoy together.

Building further on the multiplayer experience, it’s essential to refine our approach to client-server interaction. This involves handling dynamic client joins and leaves, game input synchronization, lag compensation, and more. All of these aspects are critical to ensuring a seamless and fair gaming experience for all participants.

Dynamic Client Handling

As players come and go, our server needs to dynamically adjust to these changes. Here’s how we can handle a new client joining the game and broadcast this event to all connected players:

# Server Script
func _on_peer_connected(id):
    print("Peer connected with id: " + str(id))
    var new_player_info = "new_player," + str(id)
    # Send the information about the new player to all connected clients
    rpc("add_new_player", new_player_info)

remote func add_new_player(new_player_info):
    print("Adding new player with info: " + new_player_info)

This code snippet will inform all existing clients about a newly joined player, allowing them to update their game state accordingly.

Input Synchronization

To keep a game’s action synchronized across clients, we need to send input events to the server. This allows the server to process and relay the results back to clients, keeping the game state uniform. Here’s an example of how to do this:

# Client Script
func _input(event):
    if event is InputEventKey:
        if event.pressed:
            # We create a simple string to represent the input, e.g., "input,space"
            var input_message = "input," + str(event.scancode)
            rpc_id(1, "process_player_input", input_message)

# Server Script
remote func process_player_input(input):
    var input_type = input.get_slicec(',', 1)
    match input_type:
        # Handle other inputs correspondingly

func _handle_jump():
    # Broadcast jump to all clients

In this case, when a player presses a key, we send that input to the server using an RPC call. The server then processes it and updates all clients with the result.

Lag Compensation

Dealing with network lag is a complex yet crucial aspect of multiplayer games, especially for fast-paced genres. Here’s a simple strategy using timestamps to ensure player actions are processed at the correct time:

# Client Script
func _process(delta):
    var current_input = get_player_input()  # Assume a method that gets current inputs
    var timestamp = OS.get_system_time_secs()
    rpc_id(1, "process_input_with_timestamp", current_input, timestamp)

# Server Script
remote func process_input_with_timestamp(input, timestamp):
    # Calculate lag based on the current time and the timestamp
    var lag = OS.get_system_time_secs() - timestamp
    _process_input_at_correct_time(input, lag)

func _process_input_at_correct_time(input, lag):
    # Implement lag compensation logic here

This script takes the current system time and sends it along with the player input. The server then adjusts the game state based on the input and the calculated lag time.

Authority Management

In a networked game, it’s crucial to manage which node or player has the authority to control certain actions or objects. Godot allows for setting network master, which can be elegantly handled as follows:

# Server Script
func _on_peer_connected(id):
    # Grant authority over a newly spawned character to the connecting client
    var new_character = spawn_character() # Assume a method for spawning a new character

# Client Script
func _ready():
    # This client's character will only process movement commands if it's the network master
    if is_network_master():

func _process_input(delta):
    # Get and handle the input events here

In this scenario, authority over a character is granted to the client that controls it. This is essential for avoiding conflicts wherein two clients might try to control the same character.

Through these examples, we’ve seen how to manage client connections dynamically, synchronize inputs, compensate for lag, and delegate authority. Applying these concepts will lead to a robust and responsive multiplayer environment. Continue experimenting with these techniques to fine-tune the multiplayer experience in your Godot 4 projects and remember—a smooth and fair multiplayer experience can greatly amplify the enjoyment and longevity of any game.

Continuing Your Game Development Journey in Godot 4

Congratulations on making it through this tutorial series on managing multiplayer networking with the ENetMultiplayerPeer class in Godot 4! While we’ve covered a lot of ground, there’s still an incredible amount of exciting territory to explore in game development with Godot 4.

To keep honing your skills and to take your game development journey even further, we highly recommend checking out our Godot Game Development Mini-Degree. This comprehensive collection of courses is specially designed to deepen your understanding of Godot 4 and broaden your skills in creating engaging, cross-platform games. You’ll dive into everything from handling 2D and 3D assets to implementing gameplay control flows, crafting intricate UI systems, and building various game mechanics across multiple genres. The Mini-Degree suits both beginners and seasoned developers, guiding you through hands-on projects where you can craft your own games and see your game design dreams come to life.

And if you’re craving even more Godot content, head over to our full suite of Godot courses at Zenva Academy. With over 250 courses on a variety of coding and game development topics, you can elevate your knowledge from basic to professional. Plus, our courses are accessible anytime, allowing for a learning experience that fits around your schedule. Whether you just discovered your passion for game development or are looking to upskill, our Godot courses will support you every step of the way.

There’s no better time than now to further your game development career, and at Zenva, we’re here to help you achieve just that. Stay curious, keep learning, and turn your creativity into playable realities. Let the journey continue!


As we wrap up this enlightening exploration into Godot 4’s networked multiplayer realm, we hope you feel inspired and equipped with the knowledge to bring your own multiplayer visions to fruition. The journey of game development is ongoing, filled with constant learning and innovation, and mastering multiplayer is a rewarding milestone in that journey. Whether you aspire to connect players in cooperative quests or competitive battles, the skills you’ve honed here will serve as a powerful toolset in your development arsenal.

Embark on the next chapter of your development adventure with Zenva’s Godot Game Development Mini-Degree and continue to grow, create, and innovate. There’s an entire community of gamers eagerly awaiting the experiences you will build, and we can’t wait to see what you’ll develop next. The world of game creation is at your fingertips – keep crafting, keep coding, and keep dazzling us with your immersive multiplayer worlds!

Python Blog Image

FINAL DAYS: Unlock coding courses in Unity, Godot, Unreal, Python and more.