Describe the bug
When i send an unreliable packet, I receive an AckNotification for that packet. But i don't want to get an ack.

To Reproduce
Steps to reproduce the behavior:

1. Send an Unreliable or UnreliableOrdered packet.
2. Check for AckNotification event.

Expected behavior
There should be no Ack.

Environment (please complete the following information):

• OS: Win11 and Manjaro
• Unity Version: 2022.3.6f1
• Ruffles Version: v11.1.9

When using Ruffles as transport for MLAPI v11, when iOS client device has screen locked for over ~5 seconds, after the device is unlocked Ruffles library begins spamming error messages and the transport stops working entirely.

Error includes this exception in printout:
System.Net.Sockets.SocketException (0x80004005): The socket is not connected

Error message is being printed in the Socket's StartSocketLogic loop.

This issue appears to be identical to issue that is reported to LiteNetLib repo here:
RevenantX/LiteNetLib#312

For reference on solution, LiteNetLib fixed this issue in the following commits:
RevenantX/LiteNetLib@6142768
RevenantX/LiteNetLib@dac4fea

Describe the bug
FNV is not suitable for Hashcash.

Any math undergrad can break this in his spare time.
You need a stronger cryptographic algorithm for hashcash. The state of the art appears to be sha256, or at least sha1:
https://en.bitcoin.it/wiki/Hashcash#Hash_function_choices

When calling GetCurrentRtt with an invalid clientId causes an exception two different ways:

KeyNotFoundException: The given key was not present in the dictionary.
System.Collections.Generic.Dictionary`2[TKey,TValue].get_Item (TKey key) (at :0)
RufflesTransport.RufflesTransport.GetCurrentRtt (System.UInt64 clientId) (at C:/projects/mlapi-transports/RufflesTransport/RufflesTransport.cs:281)

NullReferenceException: Object reference not set to an instance of an object
RufflesTransport.RufflesTransport.GetRufflesConnectionDetails (System.UInt64 clientId, System.UInt64& connectionId) (at C:/projects/mlapi-transports/RufflesTransport/RufflesTransport.cs:332)
RufflesTransport.RufflesTransport.GetCurrentRtt (System.UInt64 clientId) (at C:/projects/mlapi-transports/RufflesTransport/RufflesTransport.cs:279)

Could GetCurrentRtt simply not throw an exception but rather return 0?

Hi and big thanks for a great library!
Could you explain how the ack packets are merged into bitfields? I'm trying to understand the method behind it all...

A nice feature would be to introduce FEC on messages that are fragmented, trading bandwidth for reliability. This is specially useful on scenarios where clients are far from a streaming server.
Reed-Solomon would be enough, a message could be reconstructed using 2 out of 3 packets, 3 out of 4, etc, avoiding retransmition in most cases, saving a lot of round trips.

Is your feature request related to a problem? Please describe.
The problem with UnreliableOrdered is that it drops older messages even if the game didn't read the pending ones yet. This is a waste of information that is useful to the game and unnecessary packet loss.

Describe the solution you'd like
The solution is to implement a UnreliableSequenced channel that keeps older messages and sorts them until the game/MLAPI performs a read on them. After the read, older packets are dropped.

Additional context
A good example of this in practice is this post from the Lead Networking Programmer of Epic Games where they had to implement this in Fortnite to fix the packet loss problem:
https://www.reddit.com/r/FortNiteBR/comments/awagpo/packet_reordering_technical_post/

@TwoTenPvP is this being developed as part of an application you're working on?

Any future planes to implement an async version as opposed to manual threads?

Not really sure where to even start with it. Most of the built libs are generating way too much garbage to be used to encrypt packets.

Is this intentional?

Is your feature request related to a problem? Please describe.
Can SendTo be triggered by the main thread? i have a game loop on my game server and want to send all messages at the end of every step
Describe the solution you'd like
Main Thread trigger Event at end of loop, SendTo Thread "WaitsFor" Event to run logic

Describe alternatives you've considered
A clear and concise description of any alternative solutions or features you've considered.

Additional context
Add any other context or screenshots about the feature request here.

The readme part of the ReliableOrdered said "Message delivery is not guarenteed. It is a reliable channel. Shouldn't it be reliable?

RuffleSocket's public behavior should be exposed as an interface (ISocket) to allow for easier unit-testing (i.e. by mocking implementation)

The old SlidingWindow collections shall be replaced with the new, O(1) collections.

Is your feature request related to a problem? Please describe.
Keeping assets up to date in unity is extremely painful. It pollutes your project file structure. If you upgrade, it doesn't delete old files. There is no way to tell which version you have installed.

Describe the solution you'd like
Unity came up with a much better way to use assets: UPM. Please provide a UPM package.json file in your repo so that I can install ruffles using UPM.

See here for some documentation:
https://medium.com/openupm/how-to-maintain-upm-package-part-1-7b4daf88d4c4

See here for MirrorNG, which does provide UPM distribution:
https://github.com/MirrorNG/MirrorNG

Additional context
My goal is to make a MirrorNG transport for ruffles, I would like to add ruffles as a UPM dependency so that I don't have to maintain a copy of your files.

Describe the bug
Using the simulator in MLAPI and ruffles as a transport.
Setting latency to 1800-2000ms has no effect and latency is still 0ms.
To Reproduce
Steps to reproduce the behavior:

1. Create MLAPI project
2. Use ruffles
3. Enable Simulator with latency
4. Test latency
5. 0 ms

Expected behavior

There should be a delay of 1800-2000ms.

Environment (please complete the following information):

• OS: Windows 10
• Unity Version: 2019.1
• Ruffles Version: LTS from MLAPI installer

I see the project is still actively being developed and updated as of 20 days ago... Is there any chance a build against .net core 3.1 could be supplied officially too? I have no troubles building it myself to get that now, but it would be nice since this is still maintained to have nuget packages against the core version I'm using to get clean/quick updates to the latest build as I'm starting a project that will possibly have a community maintaining it in the future. As a spoiler to what that project will be, It'll be a C# based project for modding N64/PS1 games with built in network functionality (This for my own mods in mind being online multiplayer based).

After network switch client's IP can change. TCP connection will die after this. And it looks like Ruffles connection will die too. So to keep player connected i have to reconnect and keep my own queue of delivered messages over reliable channel.

Is there any way to keep connection alive after IP change? Or some way to copy reliable channels data to new connection?

Or may be you know if any other library support such feature?

Describe the bug
Client can not connect to a host using Ruffles Transport. Error message is "Connection not alive". Firewall on host is disabled, netstat shows port is being listened

To Reproduce
Simple project using Ruffles transport

Expected behavior
Client connects successfully

Environment (please complete the following information):

OS: Windows 10 & Oculus Quest (Android)
Unity Version: 2019.1.6f1
MLAPI Version: 10.13.0
Ruffles: No version shown in Unity, Ruffles.dll says 1.0.0

Hi,

I'm currently testing ruffles, and before I say anything, you did amazing!

Currently, I try a small simulation of four RuffleSockets, one being the server and three the clients. Each 16 to 20ms all participating sockets send a 256-byte package. The server "broadcasts" the package to the three clients. The clients just send it directly to the server. Each socket creates its own packet, so they are not dependent on any information flow.

After about ~365,000 messages in total (~54000 received payloads on each client, and ~196000 payloads received on the server), each client receives a NetworkEvent with NetworkEventType.Disconnect.

The Disconnects are a couple of seconds apart (roughly the same time I need to press connect on each client). 13 seconds later the server throws a NullReferenceException and then logs that a particular client has disconnected.

NullReferenceException: Object reference not set to an instance of an object Ruffles.Memory.MemoryManager.DeAlloc (Ruffles.Memory.HeapPointers pointers) (at <f3d7047ed8d941c398bcc2452492ea15>:0) Ruffles.Messaging.PacketHandler.SendMessage (System.ArraySegment1[T] payload, Ruffles.Connections.Connection connection, System.Byte channelId, System.Boolean noDelay, Ruffles.Memory.MemoryManager memoryManager) (at :0)
Ruffles.Core.RuffleSocket.Send (System.ArraySegment1[T] payload, Ruffles.Connections.Connection connection, System.Byte channelId, System.Boolean noDelay) (at <f3d7047ed8d941c398bcc2452492ea15>:0)

All this is run inside Unity 2018.4.9f1. It's a simple repo, I can provide access if needed.
Unfortunately, I have no idea why the client suddenly thinks it is disconnected.

The Editor.log from Unity contains a bit of more information:

ClientEvent: Disconnect
[WARNING] Client 123.123.123.123:5674 connection could not be found
The warning is issued without a stack trace.

The server crash seems to be related to:

[ERROR] Outgoing packet window is exhausted. Disconnecting

This probably happens because I try to send via the ChannelType.Reliable channel.

I hope that helps to solve the issue, and or maybe you have ideas on how I can fix it on my side :)

When a server disconnects a connection that has ReliableSequencedFragmented as the channel type (and potentially others), any pending packets are not sent to the client. This results in "friendly disconnects" (use case - user is on the wrong version of the client, needs a message telling them to upgrade, then disconnect them) not being received by the client, since the _pendingSends aren't flushed to the socket, they're simply reclaimed. See ReliableSequencedFragmented.Release().

I believe I understand the motivation - the Disconnect event should disconnect immediately and not dump data to clients - but there isn't a mechanism to flush() partial packets to users. Unfortunately, I think alternative approaches are not good (ask the client to disconnect in the "final packet" and trust them to do so; mark a connection as pending disconnect and complete the disconnect after MergeDelay amount of time; or my solution - expose a second Send() method with noMerge=true for these scenarios).

I'm not sure if this repo is being actively developed any further with the maintainer moving over into other unity networking solutions, but if the maintainer (or anyone else capable) would like to, this would be a nice feature, both for this use case and others.

Proposal 1: Add Flush() to IChannel and implement in the various channel implementations
Proposal 2: Expose method for polling count of _pendingSends in the channels.
Proposal 3: Add another Disconnect() method or parameter that attempts to Flush() pending/unmerged packets to the client.

Thanks for the consideration

The current Ruffles logic loop iterates the the whole Connections array about 7 times. Performing null and dead checks for each.

This could be reduced by either pre-caching the connected connections, or exiting once the last connected is reached.

It could be further reduced by merging the loops and nullchecks into a single loop.

Describe the bug
Endless loop due to wrong data type in counter variable i.

To Reproduce
I don't have enough understanding of the inner workings to tell how exactly to reproduce this. However it's obvious that the for loop in ReliableSequencedChannel.HandleAck(ArraySegment<byte> payload) can never complete when bits is greater than 255. Not sure IF bits should ever be greater than 255, but it is in my case. The debugger shows a value of 4128 in my case.
Same issue may probably occur in ReliableChannel as well.

Expected behavior
It shouldn't lock up. Either the counter i should be of type int or it should be guaranteed that bits can never exceed 255.

Environment (please complete the following information):

• OS: Debian 11
• Unity Version: N/A (this is a pure .NET 7 application)
• Ruffles Version: 11.1.9
• Ruffles Commit: aab94e4

Additional context
The deadlock occurs after a few minutes during loadtests of my game server. It is possible that the game server is sending or receiving too much data which may increase the chance of this issue ocurring.

This line here is missing the cast to ushort, causing the ReliableChannel to stop accepting packets past sequence 65535.

I couldn't find any documentation regarding sending information reliably or unreliably, and it's unclear whether packet loss is checked. There are many questions due to the absence of documentation.

I believe there is big potential for performance upgrades to the SlidingSet. It's not critical as it's only used for validating challenge initialization vectors. But should be investigated.

Ruffles currently reuses everything (including memory, connections and more). It currently does not reuse channels which can contain huge amounts of memory. (Though their memory is usually reused except for collections)