LiteNetLib Documentation

The NetManager class provides several configuration properties to tune network behavior.

Connection & Timing

• UpdateTime: Library logic update and send period in milliseconds (Default: 15 msec).
• PingInterval: Interval for latency detection and connection checking (Default: 1000 msec).
• DisconnectTimeout: Time before a connection is closed due to inactivity (Default: 5000 msec).
• ReconnectDelay: Delay between connection attempts (Default: 500 msec).
• MaxConnectAttempts: Maximum connection attempts before calling disconnect event (Default: 10).

Features

• UnconnectedMessagesEnabled: Enables receiving messages without a connection (Default: false).
• NatPunchEnabled: Enables NAT punch messages (Default: false).
• BroadcastEnabled: Allows receiving Broadcast packets (Default: false).
• UnsyncedEvents: Experimental feature; events are called from another thread without calling PollEvents() (Default: false).

Network Simulation (Requires DEBUG build or SIMULATE_NETWORK defined)

• SimulatePacketLoss: Enables random packet dropping (Default: false).
• SimulateLatency: Enables random packet holding (Default: false).
• SimulationPacketLossChance: Percentage chance of packet loss (Default: 10).
• SimulationMinLatency: Minimum simulated latency in msec (Default: 30 msec).
• SimulationMaxLatency: Maximum simulated latency in msec (Default: 100 msec).

To create a server, instantiate an EventBasedNetListener and pass it to a NetManager. Call Start(port) to begin listening on a specific port. You must handle ConnectionRequestEvent to accept or reject incoming connections and call PollEvents() in a loop. Use PeerConnectedEvent to interact with newly connected peers.

EventBasedNetListener listener = new EventBasedNetListener();
NetManager server = new NetManager(listener);
server.Start(9050 /* port */);

listener.ConnectionRequestEvent += request =>
{
    if(server.PeersCount < 10 /* max connections */)
        request.AcceptIfKey("SomeConnectionKey");
    else
        request.Reject();
};

listener.PeerConnectedEvent += peer =>
{
    Console.WriteLine("We got connection: {0}", peer.EndPoint); // Show peer ip
    NetDataWriter writer = new NetDataWriter();                 // Create writer class
    writer.Put("Hello client!");                                // Put some string
    peer.Send(writer, DeliveryMethod.ReliableOrdered);             // Send with reliability
};

while (!Console.KeyAvailable)
{
    server.PollEvents();
    Thread.Sleep(15);
}
server.Stop();

Since NetPacketProcessor does not support nested structs or classes by default, you must register custom type processors using RegisterNestedType. There are three ways to handle this:

1. Using static Serialize/Deserialize methods

For basic structs, provide static methods that use NetDataWriter and NetDataReader.

struct MyType {
    public int Value1;
    public static void Serialize(NetDataWriter writer, MyType mytype) => writer.Put(mytype.Value1);
    public static MyType Deserialize(NetDataReader reader) => new MyType { Value1 = reader.GetInt() };
}
// Registration:
netPacketProcessor.RegisterNestedType(MyType.Serialize, MyType.Deserialize);

2. Implementing INetSerializable

For structs or classes, implement the INetSerializable interface. This is the most automated way.

struct MyType : INetSerializable {
    public int Value1;
    public void Serialize(NetDataWriter writer) => writer.Put(Value1);
    public void Deserialize(NetDataReader reader) => Value1 = reader.GetInt();
}
// Registration:
netPacketProcessor.RegisterNestedType<MyType>();

3. Registering Classes with Constructors

If using a class instead of a struct, you must implement INetSerializable and provide a constructor factory to the registration method.

class MyType : INetSerializable {
    public int Value1;
    public void Serialize(NetDataWriter writer) => writer.Put(Value1);
    public void Deserialize(NetDataReader reader) => Value1 = reader.GetInt();
}
// Registration (must provide constructor factory):
netPacketProcessor.RegisterNestedType<MyType>(() => new MyType());

// Example of Registering a custom type via static methods
struct MyType
{
    public int Value1;
    public string Value2;

    public static void Serialize(NetDataWriter writer, MyType mytype)
    {
        writer.Put(mytype.Value1);
        writer.Put(mytype.Value2);
    }

    public static MyType Deserialize(NetDataReader reader)
    {
        MyType res = new MyType();
        res.Value1 = reader.GetInt();
        res.Value2 = reader.GetString();
        return res;
    }
}

netPacketProcessor = new NetPacketProcessor();
netPacketProcessor.RegisterNestedType( MyType.Serialize, MyType.Deserialize );