PeersAck.Godot 0.1.0

PeersAck.Godot

Godot 4 integration for the PeersAck networking library. Provides Node-based wrappers with Godot signals for easy integration with both GDScript and C# Godot projects.

Installation

NuGet (Recommended)

dotnet add package PeersAck.Godot

Manual

Add a reference to both PeersAck and PeersAck.Godot in your Godot project's .csproj file.

Quick Start

Using NetworkManagerNode (Easiest)

Add a NetworkManagerNode to your scene tree and configure it in the editor:

// In your game script
public partial class Game : Node
{
    [Export] public NetworkManagerNode Network { get; set; }
    
    public override void _Ready()
    {
        // Connect signals
        Network.ClientConnected += OnClientConnected;
        Network.DataReceived += OnDataReceived;
        
        // Start server
        Network.StartServer(7777);
    }
    
    private void OnClientConnected(long connectionId)
    {
        GD.Print($"Client connected: {connectionId}");
    }
    
    private void OnDataReceived(long connectionId, byte[] data)
    {
        GD.Print($"Received {data.Length} bytes from {connectionId}");
    }
}

Using from GDScript

extends Node

@onready var network = $NetworkManagerNode

func _ready():
    network.client_connected.connect(_on_client_connected)
    network.data_received.connect(_on_data_received)
    network.start_server(7777)

func _on_client_connected(connection_id: int):
    print("Client connected: ", connection_id)

func _on_data_received(connection_id: int, data: PackedByteArray):
    print("Received ", data.size(), " bytes")

Using RoomManagerNode for Room-based Games

public partial class Lobby : Node
{
    [Export] public RoomManagerNode RoomManager { get; set; }
    
    public override void _Ready()
    {
        RoomManager.PlayerJoinedRoom += OnPlayerJoined;
        RoomManager.RoomDataReceived += OnRoomData;
    }
    
    public async void HostGame()
    {
        await RoomManager.StartServerAsync(7777);
        RoomManager.CreateRoom("my-room");
    }
    
    public async void JoinGame(string ip)
    {
        await RoomManager.ConnectAsync(ip, 7777);
        await RoomManager.JoinRoomAsync("my-room");
    }
}

Available Nodes

NetworkManagerNode

Low-level transport wrapper with automatic polling.

Exported Properties:

• TransportType: LAN or Steam
• ConnectionKey: Key for LAN connections
• MaxConnections: Maximum clients (server)
• AutoPoll: Enable automatic polling in _Process

Signals:

• client_connected(connection_id: int)
• client_disconnected(connection_id: int)
• data_received(connection_id: int, data: PackedByteArray)
• connected_to_server()
• disconnected_from_server()

RoomManagerNode

High-level room/lobby system wrapper.

Exported Properties:

• TransportType: LAN or Steam
• AutoCreateRooms: Allow room creation on join
• MaxPlayersPerRoom: Limit per room (0 = unlimited)

Signals:

• player_joined_room(room_id: String, player_id: int)
• player_left_room(room_id: String, player_id: int)
• room_data_received(room_id: String, from_player: int, data: PackedByteArray)
• joined_room(room_id: String)
• left_room(room_id: String)

Thread Safety

All network operations are handled on the main thread via Godot's _Process loop. This ensures thread-safe interaction with the scene tree.

Steam Integration

For Steam support, initialize Steam before using SteamTransport:

public override void _Ready()
{
    Steamworks.SteamClient.Init(YOUR_APP_ID);
    
    var network = GetNode<NetworkManagerNode>("Network");
    network.TransportType = NetworkTransportType.Steam;
}

public override void _Process(double delta)
{
    Steamworks.SteamClient.RunCallbacks();
}

License

MIT License - see the main PeersAck repository for details.