C# Godot Template

The project is divided into the generator logic and the testing suite:

Project Structure

• PacketGen/: Contains the Roslyn incremental source generator logic.
• PacketGen.Tests/: Contains generator tests that compile generated code and validate runtime behavior.

Key Files for Reference

• PacketGen/PacketGenerator.cs: The entry point for the incremental generator.
• PacketGen/Generators/PacketGenerationOrchestrator.cs: Handles the assembly of source code for each packet.
• PacketGen/Generators/PacketRegistryGenerator.cs: Generates the source for the packet registry.
• PacketGen/Generators/TypeHandlers/*: Contains the serialization logic for various type shapes.
• PacketGen/Generators/TypeHandlers/SerializablePropertySelector.cs: The central filter used to determine which properties are eligible for serialization.
• PacketGen/PacketGenConstants.cs: Contains shared string constants used across the generator.

For C# users, performance can be significantly improved (up to 3.5x) by avoiding thousands of individual _Process calls on separate nodes. Instead, use the Component class to implement a centralized component pattern.

When extending from Component:

• Use Ready(), Process(double delta), and ExitTree() instead of the standard Godot underscore-prefixed methods.
• Process is disabled by default; you must call SetProcess(true) to enable it.
• This allows a centralized manager to handle the execution of these components more efficiently.

public class EntityMovementComponent(Player player) : Component(player)
{
    protected override void Ready()
    {
        // Process is disabled by default and we must enable it ourselves
        SetProcess(true);
    }

    protected override void Process(double delta)
    {
        // Handle process...
    }

    protected override void ExitTree()
    {
        // Handle exit tree...
    }
}

Packets use source generation to automatically implement Write and Read methods for supported types.

Excluding Properties

Use the [NetExclude] attribute to prevent specific properties from being serialized into the packet.

Manual Serialization

If you need conditional logic (e.g., only sending data if a boolean is true) or if you are using unsupported types, manually override the Write(PacketWriter writer) and Read(PacketReader reader) methods. When you manually override these, the source generator will not produce them for you.

Supported Types

public partial class SPacketPlayerJoinLeave : ServerPacket
{
    public uint Id { get; set; }
    public string Username { get; set; }
    public Vector2 Position { get; set; }
    public bool Joined { get; set; }

    public override void Write(PacketWriter writer)
    {
        writer.Write((uint)Id);
        writer.Write((bool)Joined);

        if (Joined)
        {
            writer.Write((string)Username);
            writer.Write((Vector2)Position);
        }
    }

    public override void Read(PacketReader reader)
    {
        Id = reader.ReadUInt();
        Joined = reader.ReadBool();

        if (Joined)
        {
            Username = reader.ReadString();
            Position = reader.ReadVector2();
        }
    }
}

To use PacketGen, your packet types must follow these requirements:

1. The type must be a partial class (or partial struct).
2. The type must inherit from either ClientPacket or ServerPacket.
3. If the type already implements Write or Read methods, PacketGen will skip generation for that type.

Supported properties include:

• Primitives and common netcode types (e.g., bool, int, char, string, byte[], Godot.Vector2, Godot.Vector3).
• Recursive collections: List<T>, Dictionary<TKey, TValue>, and arrays.
• Nested structs and classes.

Use the [NetExclude] attribute on individual properties to skip them during generation.

public struct PlayerStats
{
    public int Level { get; set; }
    public Vector2 Spawn { get; set; }
}

public class PlayerProfile
{
    public string Name { get; set; }
    public PlayerStats Stats { get; set; }
}

// Must be partial and inherit from ClientPacket or ServerPacket
public partial class CPacketPlayerInfo : ClientPacket
{
    public uint Id { get; set; }
    public PlayerProfile Profile { get; set; }
}

The framework uses a high-performance, low-overhead packet system for multiplayer. Packets are defined as partial classes extending either ClientPacket (sent from client to server) or ServerPacket (sent from server to client).

To implement netcode:

1. Define your packet classes.
2. Use GodotClient to handle client-side logic and GodotServer for server-side logic.
3. Use OnPacket<T> to register handlers for incoming packets.
4. Use Send(packet) to transmit data.
5. Use the Net<TClient, TServer> class to orchestrate the connection in your game world.

// 1. Define Packets
public partial class CPlayerJoined : ClientPacket
{
    public string Username { get; set; }
}

public partial class SPlayerPositions : ServerPacket
{
    public Dictionary<uint, Vector2> Positions { get; set; }
}

// 2. Implement Client
public partial class GameClient : GodotClient
{
    public GameClient()
    {
        OnPacket<SPlayerPositions>(packet => {
            // Handle received positions
        });
    }

    protected override void OnConnected()
    {
        Send(new CPlayerJoined("Valk"));
    }
}

// 3. Implement Server
public partial class GameServer : GodotServer
{
    public GameServer()
    {
        OnPacket<CPlayerJoined>(peer => {
            // Handle player joining
            Send(new SPlayerPositions(new Dictionary<uint, Vector2>()), peer.PeerId);
        });
    }
}

// 4. Orchestrate in World
public partial class World : Node
{
    private Net<GameClient, GameServer> _net = null!;

    public override void _Ready()
    {
        _net = new Net<GameClient, GameServer>();
        _net.StartServer(25565);
        _net.StartClient("127.0.0.1", 25565);
    }
}