Combines both tcp and udp with 'DeliveryMethod'

[nvh2001]

Like this.

client.ToData(data, DeliveryMethod.TCP)
client.ToData(data, DeliveryMethod.UDP)

is this lib have RUDP?
thanks

[alec1o]

RUDP or Reliable UDP: Isn't working now but I'll do this working on release of Netly4

Until then, it's a concept that I'm thinking about to make it really reliable and very fast than TCP

If implemented you can use like this:

client.To.Data("hello world", RUDP.Unreliable); // can lost packet
client.To.Data("hello world", RUDP.Reliable); // can't lost packet (like TCP)

---

It's imposible combile in same object! How TCP and UDP can be same?

But.. This level of programming is unbelievable... 🤣🤣🤣 it's like magic! TCP and UDP together as ONE... 🤣🤣🤣 But it is possible to encapsulate it to work like this. Look below. 👨‍💻

• USAGE

NetworkTransport client = new NetworkTransport(new Host("127.0.0.1", 13001), new Host("127.0.0.1", 13002));

client.ToData("hello world", DeliveryMethod.TCP); // tcp only
client.ToData("hello world", DeliveryMethod.UDP); // udp only
client.ToData("hello world", DeliveryMethod.Any);  // tdp and udp

• HACK

public enum DeliveryMethod
{
    TCP = 1,
    UDP = 2,
    Any = 0,
}

public class NetworkTransport
{

    private TcpClient tcpClient;
    private UdpClient udpClient;

    public NetworkTransport(Host tcpHost, Host udpHost)
    {
        tcpClient = new TcpClient(framing: true);
        tcpClient.Open(tcpHost);
        udpClient = new UdpClient(false);
        udpClient.Open(udpHost);
    }

    public void ToData(byte[] data, DeliveryMethod method)
    {
        if (method == DeliveryMethod.TCP) tcpClient.ToData(data);
        else if (method == DeliveryMethod.UDP) udpClient.ToData(data);
        else if (method == DeliveryMethod.Any)
        {
             tcpClient.ToData(data);
            udpClient.ToData(data);
        }
    }

    public void ToData(string data, DeliveryMethod method)
    {
        ToData(Encoding.UTF8.GetBytes(daya), method);
    }

[nvh2001]

On receiver side, need to create two client.OnEvent((string name, byte[] data) => for tcp and udp

[alec1o]

yes ma'am you can implement this bahaviour.

[alec1o]

Increment this code: @nvh2001 @vanhaodev

Sorry for long delay 😭
But Feel free to open issues if have a bug, mistake or want a help about Netly integration 👨‍💻
(I feel happy when Netly is used for big project! ❤️)

Usage

I created complete wrapper code, I hope this help your project (I create all code here 👇 on github, maybe have syntax error)... 🦖

NetworkTransport client = new NetworkTransport();

// connect to server
client.Open(new Host("127.0.0.1", 13001), new Host("127.0.0.1", 13002));

// disconnect
client.Close();

// opened connection callback
client.OnOpen(deliveryMethod =>
{
    ...
});

// closed connection callback
client.OnClose(deliveryMethod =>
{
    ...
});

// receive data callback
client.OnData((bytes, deliveryMethod) =>
{
    ...
});

// receive event callback
client.OnEvent((name, bytes, deliveryMethod) =>
{
    ...
});

// send data
client.ToData("hello world", DeliveryMethod.TCP); // tcp only
client.ToData("hello world", DeliveryMethod.UDP); // udp only
client.ToData("hello world", DeliveryMethod.Any);  // tdp and udp

// send event
client.ToEvent("event-name", "hello world", DeliveryMethod.TCP); // tcp only
client.ToEvent("event-name", "hello world", DeliveryMethod.UDP); // udp only
client.ToEvent("event-name", "hello world", DeliveryMethod.Any);  // tdp and udp

---

Source Code

• DeliveryMethod.cs

public enum DeliveryMethod
{
    TCP = 1,
    UDP = 2,
    Any = 0,
}

• NetworkTransport.cs

public class NetworkTransport
{
    private TcpClient tcpClient;
    private UdpClient udpClient;

    public NetworkTransport
    {
        tcpClient = new TcpClient(framing: true);
        udpClient = new UdpClient(false);
    }

    public void Open(Host tcpHost, Host udpHost)
    {
        tcpClient.Open(tcpHost);
        udpClient.Open(udpHost);
    }
    
    public void Close()
    {
        tcpClient.Close();
        udpClient.Close();
    }

    public void ToData(byte[] data, DeliveryMethod method)
    {
        if (method == DeliveryMethod.TCP) tcpClient.ToData(data);
        else if (method == DeliveryMethod.UDP) udpClient.ToData(data);
        else if (method == DeliveryMethod.Any)
        {
            tcpClient.ToData(data);
            udpClient.ToData(data);
        }
    }

    public void ToData(string data, DeliveryMethod method)
    {
        ToData(Encoding.UTF8.GetBytes(data), method);
    }

    public void ToEvent(string name, byte[] data, DeliveryMethod method)
    {
        if (method == DeliveryMethod.TCP) tcpClient.ToData(data);
        else if (method == DeliveryMethod.UDP) udpClient.ToData(data);
        else if (method == DeliveryMethod.Any)
        {
            tcpClient.ToEvent(name, data);
            udpClient.ToEvent(name, data);
        }
    }

    public void ToEvent(string name, string data, DeliveryMethod method)
    {
        ToEvent(name, Encoding.UTF8.GetBytes(data), method);
    }

    void OnEvent(Action<string, byte[], DeliveryMethod> callback)
    {
        tcpClient.OnEvent((name, data) => 
        {
            callback(name, data, DeliveryMethod.TCP);
        });
    
        udpClient.OnEvent((name, data) =>
        {
            callback(name, data, DeliveryMethod.UDP);
        });
    }
    
    void OnData(Action<byte[], DeliveryMethod> callback)
    {
        tcpClient.OnData((data) => 
        {
            callback(data, DeliveryMethod.TCP);
        });
    
        udpClient.OnData((data) =>
        {
            callback(data, DeliveryMethod.UDP);
        });
    }
    
    void OnClose(Action<DeliveryMethod> callback)
    {
        tcpClient.OnClose(() => 
        {
            callback(DeliveryMethod.TCP);
        });
    
        udpClient.OnClose(() =>
        {
            callback(DeliveryMethod.UDP);
        });
    }
    
    void OnOpen(Action<DeliveryMethod> callback)
    {
        tcpClient.OnOpen(() => 
        {
            callback(DeliveryMethod.TCP);
        });
    
        udpClient.OnOpen(() =>
        {
            callback(DeliveryMethod.UDP);
        });
    }
}

[vanhaodev]

I have some reference :)))

public enum DeliveryMethod : byte
    {
        /// <summary>
        /// Unreliable. Packets can be dropped, can be duplicated, can arrive without order.
        /// </summary>
        Unreliable = 4,

        /// <summary>
        /// Reliable. Packets won't be dropped, won't be duplicated, can arrive without order.
        /// </summary>
        ReliableUnordered = 0,

        /// <summary>
        /// Unreliable. Packets can be dropped, won't be duplicated, will arrive in order.
        /// </summary>
        Sequenced = 1,

        /// <summary>
        /// Reliable and ordered. Packets won't be dropped, won't be duplicated, will arrive in order.
        /// </summary>
        ReliableOrdered = 2,

        /// <summary>
        /// Reliable only last packet. Packets can be dropped (except the last one), won't be duplicated, will arrive in order.
        /// Cannot be fragmented
        /// </summary>
        ReliableSequenced = 3
    }

[alec1o]

Huh... Remember we're using TCP and UDP connection.

This way that you wish is RUDP (Reliable UDP) like programming.

But we can simulate this: using TCP for send reliable data and using UDP for send unreliable data.
I'll simplify TCP connection always will use ^{(DeliveryMethod.ReliableSequence)} and always UDP connection will use ^{(DeliveryMethod.Unreliable)}

Netly RUDP is under planning but I'll release on version 4:
and you can use like this 👇 :

RUDP client = new RUDP.Client();

...

client.On.Open(() =>
{
    // raw data
    client.To.Data("hello world!", RUDP.Unreliable); // DeliveryMethod.Unreliable
    client.To.Data("hello world!", RUDP.Reliable); // DeliveryMethod.ReliableSequenced & DeliveryMethod.Sequenced
    client.To.Data("hello world!", RUDP.ReliableUnordered); // (Inspired by. DeliveryMethod.ReliableUnordered)
    
    // event data
    client.To.Event("welcome", "hello world!", RUDP.Unreliable);
    client.To.Event("welcome", "hello world!", RUDP.Reliable);
    client.To.Event("welcome", "hello world!", RUDP.ReliableUnordered);
});

...

Anyway this is the code:

public enum DeliveryMethod : byte
{
        Unreliable = 4, // UDP

        ReliableUnordered = 0, // TCP

        Sequenced = 1, // TCP

        ReliableOrdered = 2, // TCP

        ReliableSequenced = 3 // TCP
}

public class NetworkTransport
{
    private TcpClient tcpClient;
    private UdpClient udpClient;

    public NetworkTransport
    {
        tcpClient = new TcpClient(framing: true);
        udpClient = new UdpClient(false);
    }

    public void Open(Host tcpHost, Host udpHost)
    {
        tcpClient.Open(tcpHost);
        udpClient.Open(udpHost);
    }
    
    public void Close()
    {
        tcpClient.Close();
        udpClient.Close();
    }

    public void ToData(byte[] data, DeliveryMethod method)
    {
        if (method == DeliveryMethod.Unreliable) udpClient.ToData(data);
        else tcpClient.ToData(data);
    }

    public void ToData(string data, DeliveryMethod method)
    {
        ToData(Encoding.UTF8.GetBytes(data), method);
    }

    public void ToEvent(string name, byte[] data, DeliveryMethod method)
    {
        if (method == DeliveryMethod.Unreliable) udpClient.ToEvent(name, data);
        else  tcpClient.ToEvent(name, data);
    }

    public void ToEvent(string name, string data, DeliveryMethod method)
    {
        ToEvent(name, Encoding.UTF8.GetBytes(data), method);
    }

    void OnEvent(Action<string, byte[], DeliveryMethod> callback)
    {
        tcpClient.OnEvent((name, data) => 
        {
            callback(name, data, DeliveryMethod.ReliableSequenced);
        });
    
        udpClient.OnEvent((name, data) =>
        {
            callback(name, data, DeliveryMethod.Unreliable);
        });
    }
    
    void OnData(Action<byte[], DeliveryMethod> callback)
    {
        tcpClient.OnData((data) => 
        {
            callback(data, DeliveryMethod.ReliableSequenced);
        });
    
        udpClient.OnData((data) =>
        {
            callback(data, DeliveryMethod.Unreliable);
        });
    }
    
    void OnClose(Action<DeliveryMethod> callback)
    {
        tcpClient.OnClose(() => 
        {
            callback(DeliveryMethod.ReliableSequenced);
        });
    
        udpClient.OnClose(() =>
        {
            callback(DeliveryMethod.Unreliable);
        });
    }
    
    void OnOpen(Action<DeliveryMethod> callback)
    {
        tcpClient.OnOpen(() => 
        {
            callback(DeliveryMethod.ReliableSequenced);
        });
    
        udpClient.OnOpen(() =>
        {
            callback(DeliveryMethod.Unreliable);
        });
    }
}

[vanhaodev]

Yep, my game just need tcp and udp (ordered) <3

[alec1o]

Ohh:: It's very simple adding ordered UDP.

Well let's separate something here, ordered UDP does not mean reliable UDP, it just means that after recent data is received the old data will be discarded so as not to create problems by e.g. "Player moving forward and then backward" (due to the old data).

So with this in mind we can add an ID per message as soon as the message ID if is less than the previous message means old data (so we will delete/destroy/discard it), thus now having the effect of (Ordered data)

Code:

public enum DeliveryMethod : byte
{
    Unreliable = 4, // UDP
    
    ReliableUnordered = 0, // TCP
    
    Sequenced = 1, // TCP
    
    ReliableOrdered = 2, // TCP
    
    ReliableSequenced = 3 // TCP
}

public class NetworkTransport
{
    private TcpClient tcpClient;
    private UdpClient udpClient;
    private uint sendDataId = 0;
    private uint sendEventId = 0;
    private uint receiveDataId = 0;
    private uint receiveEventId = 0;

    public NetworkTransport
    {
        tcpClient = new TcpClient(framing: true);
        udpClient = new UdpClient(false);
    }

    public void Open(Host tcpHost, Host udpHost)
    {
        tcpClient.Open(tcpHost);
        udpClient.Open(udpHost);
    }
    
    public void Close()
    {
        tcpClient.Close();
        udpClient.Close();
    }

    public void ToData(byte[] data, DeliveryMethod method)
    {
        if (method == DeliveryMethod.Unreliable)
        {
            var r = new Byter.Reader();
            sendDataId++;
            r.Add(sendDataId);
            r.Add(data);
            udpClient.ToData(r.GetBytes());
        }
        else tcpClient.ToData(data);
    }

    public void ToData(string data, DeliveryMethod method)
    {
        ToData(Encoding.UTF8.GetBytes(data), method);
    }

    public void ToEvent(string name, byte[] data, DeliveryMethod method)
    {
        if (method == DeliveryMethod.Unreliable)
        {
            var r = new Byter.Reader();
            sendEventId++;
            r.Add(sendEventId);
            r.Add(data);
            udpClient.ToEvent(name, r.GetBytes());
        }
        else  tcpClient.ToEvent(name, data);
    }

    public void ToEvent(string name, string data, DeliveryMethod method)
    {
        ToEvent(name, Encoding.UTF8.GetBytes(data), method);
    }

    void OnEvent(Action<string, byte[], DeliveryMethod> callback)
    {
        tcpClient.OnEvent((name, data) => 
        {
            callback(name, data, DeliveryMethod.ReliableSequenced);
        });
    
        udpClient.OnEvent((name, buffer) =>
        {
            byte[] data = IsOrdered(ref buffer, false);

            if (data != null)
            {
                callback(name, data, DeliveryMethod.Unreliable);
            }
        });
    }
    
    void OnData(Action<byte[], DeliveryMethod> callback)
    {
        tcpClient.OnData((data) => 
        {
            callback(data, DeliveryMethod.ReliableSequenced);
        });
    
        udpClient.OnData((buffer) =>
        {
            byte[] data = IsOrdered(ref buffer, true);

            if (data != null)
            {
                callback(data, DeliveryMethod.Unreliable);
            }
        });
    }
    
    void OnClose(Action<DeliveryMethod> callback)
    {
        tcpClient.OnClose(() => 
        {
            callback(DeliveryMethod.ReliableSequenced);
        });
    
        udpClient.OnClose(() =>
        {
            callback(DeliveryMethod.Unreliable);
        });
    }
    
    void OnOpen(Action<DeliveryMethod> callback)
    {
        tcpClient.OnOpen(() => 
        {
            callback(DeliveryMethod.ReliableSequenced);
        });
    
        udpClient.OnOpen(() =>
        {
            callback(DeliveryMethod.Unreliable);
        });
    }

    byte[] IsOrdered(ref byte[] buffer, boo isData)
    {
        using (var r = new Byter.Reader(buffer))
        {
            uint id = r.Read<uint>();
            byte[] data = r.Read<byte[]>();
        
        if (r.Success == false) return null;
        
        if (isData)
        {
            if (id < currentDataId) return null; // ignored: old data
            receiveDataId = id; // update latest id
        }
        else
        {
            if (id < currentEventId) return null; // ignored: old event data
            receiveEventId = id; // update latest id
        }
        
        return data;
    }
    }
}