lidgren_patch.patch

Index: Lidgren.Network.csproj
===================================================================
--- Lidgren.Network.csproj	(revision 396)
+++ Lidgren.Network.csproj	(working copy)
@@ -10,7 +10,7 @@
     <AppDesignerFolder>Properties</AppDesignerFolder>
     <RootNamespace>Lidgren.Network</RootNamespace>
     <AssemblyName>Lidgren.Network</AssemblyName>
-    <TargetFrameworkVersion>v4.5.1</TargetFrameworkVersion>
+    <TargetFrameworkVersion>v3.5</TargetFrameworkVersion>
     <FileAlignment>512</FileAlignment>
     <PublishUrl>publish\</PublishUrl>
     <Install>true</Install>
@@ -34,27 +34,30 @@
     <DebugType>full</DebugType>
     <Optimize>false</Optimize>
     <OutputPath>bin\Debug\</OutputPath>
-    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <DefineConstants>TRACE;DEBUG;UNITY_4_5</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
     <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
     <DocumentationFile>bin\Debug\Lidgren.Network.XML</DocumentationFile>
     <Prefer32Bit>false</Prefer32Bit>
+    <PlatformTarget>AnyCPU</PlatformTarget>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
     <DebugType>pdbonly</DebugType>
     <Optimize>true</Optimize>
     <OutputPath>bin\Release\</OutputPath>
-    <DefineConstants>TRACE</DefineConstants>
+    <DefineConstants>TRACE;UNSAFE;UNITY_4_5</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
     <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
     <Prefer32Bit>false</Prefer32Bit>
+    <PlatformTarget>AnyCPU</PlatformTarget>
+    <DocumentationFile>bin\Release\Lidgren.Network.XML</DocumentationFile>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
   </PropertyGroup>
   <ItemGroup>
     <Reference Include="System" />
     <Reference Include="System.Core" />
-    <Reference Include="Microsoft.CSharp" />
     <Reference Include="System.Data" />
     <Reference Include="System.Xml" />
   </ItemGroup>
Index: NetBuffer.cs
===================================================================
--- NetBuffer.cs	(revision 396)
+++ NetBuffer.cs	(working copy)
@@ -70,6 +70,37 @@
 			get { return (int)(m_readPosition / 8); }
 		}
 		
+        /// <summary>
+        /// Gets the remaining number of bits in the buffer to be read
+        /// </summary>
+	    public long RemainingBits
+	    {
+            get { return (long)(m_bitLength - m_readPosition); }
+	    }
+        
+        /// <summary>
+        /// Clones this buffer into dest
+        /// </summary>
+        /// <param name="dest"></param>
+        public void Clone(NetBuffer dest)
+        {
+            dest.m_data = new byte[m_data.Length];
+
+            Buffer.BlockCopy(m_data, 0, dest.m_data, 0, m_data.Length);
+            //foreach loops are faster in release builds until about 32k of bytes. supposedly. probably has something to do with the method call taking time.
+            //dest.m_data = new byte[m_data.Length];
+            //var i = 0;
+            //foreach (var by in m_data)
+            //{
+            //    dest.m_data[i] = by;
+            //    ++i;
+            //}
+
+            //set other values...
+            dest.m_bitLength = m_bitLength;
+            dest.m_readPosition = 0;
+        }
+
 		static NetBuffer()
 		{
 			s_readMethods = new Dictionary<Type, MethodInfo>();
Index: NetConnection.cs
===================================================================
--- NetConnection.cs	(revision 396)
+++ NetConnection.cs	(working copy)
@@ -19,6 +19,8 @@
 		internal NetConnectionStatus m_status;
 		internal NetConnectionStatus m_visibleStatus;
 		internal IPEndPoint m_remoteEndPoint;
+		internal int m_usedSendChannelsCount;
+		internal NetSenderChannelBase[] m_usedSendChannels;
 		internal NetSenderChannelBase[] m_sendChannels;
 		internal NetReceiverChannelBase[] m_receiveChannels;
 		internal NetOutgoingMessage m_localHailMessage;
@@ -85,6 +87,8 @@
 			m_status = NetConnectionStatus.None;
 			m_visibleStatus = NetConnectionStatus.None;
 			m_remoteEndPoint = remoteEndPoint;
+			m_usedSendChannelsCount = 0;
+			m_usedSendChannels = new NetSenderChannelBase[NetConstants.NumTotalChannels];
 			m_sendChannels = new NetSenderChannelBase[NetConstants.NumTotalChannels];
 			m_receiveChannels = new NetReceiverChannelBase[NetConstants.NumTotalChannels];
 			m_queuedOutgoingAcks = new NetQueue<NetTuple<NetMessageType, int>>(4);
@@ -195,7 +199,8 @@
 					m_sendBufferNumMessages++;
 
 					// write acks header
-					sendBuffer[m_sendBufferWritePtr++] = (byte)NetMessageType.Acknowledge;
+					const byte ackByte = (byte) NetMessageType.Acknowledge;
+					sendBuffer[m_sendBufferWritePtr++] = ackByte;
 					sendBuffer[m_sendBufferWritePtr++] = 0; // no sequence number
 					sendBuffer[m_sendBufferWritePtr++] = 0; // no sequence number
 					int len = (acks * 3) * 8; // bits
@@ -248,16 +253,13 @@
 			//
 			if (m_peer.m_executeFlushSendQueue)
 			{
-				for (int i = m_sendChannels.Length - 1; i >= 0; i--)    // Reverse order so reliable messages are sent first
+				for (int i = 0; i < m_usedSendChannelsCount; i++)
 				{
 					var channel = m_sendChannels[i];
 					NetException.Assert(m_sendBufferWritePtr < 1 || m_sendBufferNumMessages > 0);
-					if (channel != null)
-					{
 						channel.SendQueuedMessages(now);
 						if (channel.QueuedSendsCount > 0)
 							m_peer.m_needFlushSendQueue = true; // failed to send all queued sends; likely a full window - need to try again
-					}
 					NetException.Assert(m_sendBufferWritePtr < 1 || m_sendBufferNumMessages > 0);
 				}
 			}
@@ -384,6 +386,14 @@
 							break;
 					}
 					m_sendChannels[channelSlot] = chan;
+
+                    // rebuild m_usedSendChannels
+                    m_usedSendChannelsCount = 0;
+                    for (int i = m_sendChannels.Length - 1; i >= 0; i--) // Reverse order so reliable messages are sent first
+                    {
+                        if (m_sendChannels[i] != null)
+                            m_usedSendChannels[m_usedSendChannelsCount++] = m_sendChannels[i];
+                    }
 				}
 			}
 
Index: NetConnectionStatistics.cs
===================================================================
--- NetConnectionStatistics.cs	(revision 396)
+++ NetConnectionStatistics.cs	(working copy)
@@ -185,7 +185,7 @@
 				if (relSendChan != null)
 				{
 					for (int i = 0; i < relSendChan.m_storedMessages.Length; i++)
-						if (relSendChan.m_storedMessages[i].Message != null)
+						if ((relSendChan.m_usedStoredMessages & ((ulong)1 << i)) != 0)
 							numStored++;
 				}
 			}
Index: NetConstants.cs
===================================================================
--- NetConstants.cs	(revision 396)
+++ NetConstants.cs	(working copy)
@@ -25,18 +25,19 @@
 	/// </summary>
 	internal static class NetConstants
 	{
-		internal const int NumTotalChannels = 99;
+        internal const int NumTotalChannels = 99; // Don't change!
 
-		internal const int NetChannelsPerDeliveryMethod = 32;
+        internal const int NetChannelsPerDeliveryMethod = 32; // Don't change!
 
-		internal const int NumSequenceNumbers = 1024;
+		internal const int NumSequenceNumbers = 1024; // Must be power of two
+        internal const int NumSequenceNumberMask = NumSequenceNumbers - 1; // Don't change!
 
 		internal const int HeaderByteSize = 5;
 
-		internal const int UnreliableWindowSize = 128;
-		internal const int ReliableOrderedWindowSize = 64;
-		internal const int ReliableSequencedWindowSize = 64;
-		internal const int DefaultWindowSize = 64;
+		internal const int UnreliableWindowSize = 1024;
+		internal const int ReliableOrderedWindowSize = 64; // MAX: 64
+        internal const int ReliableSequencedWindowSize = 64; // MAX: 64
+        internal const int DefaultWindowSize = 64; // MAX: 64
 
 		internal const int MaxFragmentationGroups = ushort.MaxValue - 1;
 
Index: NetPeer.MessagePools.cs
===================================================================
--- NetPeer.MessagePools.cs	(revision 396)
+++ NetPeer.MessagePools.cs	(working copy)
@@ -181,7 +181,7 @@
 				Recycle(im);
 		}
 
-		internal void Recycle(NetOutgoingMessage msg)
+		public void Recycle(NetOutgoingMessage msg)
 		{
 			if (m_outgoingMessagesPool == null)
 				return;
Index: NetReliableSenderChannel.cs
===================================================================
--- NetReliableSenderChannel.cs	(revision 396)
+++ NetReliableSenderChannel.cs	(working copy)
@@ -14,6 +14,7 @@
 		private int m_sendStart;
 
 		private NetBitVector m_receivedAcks;
+		internal ulong m_usedStoredMessages; // "used" bits for storedMessages
 		internal NetStoredReliableMessage[] m_storedMessages;
 
 		internal double m_resendDelay;
@@ -27,6 +28,8 @@
 			m_windowStart = 0;
 			m_sendStart = 0;
 			m_receivedAcks = new NetBitVector(NetConstants.NumSequenceNumbers);
+			NetException.Assert(m_windowSize <= 64); // we do only have sizeof(ulong)*8 "used" bits in m_usedStoredMessages
+			m_usedStoredMessages = 0;
 			m_storedMessages = new NetStoredReliableMessage[m_windowSize];
 			m_queuedSends = new NetQueue<NetOutgoingMessage>(8);
 			m_resendDelay = m_connection.GetResendDelay();
@@ -34,7 +37,7 @@
 
 		internal override int GetAllowedSends()
 		{
-			int retval = m_windowSize - ((m_sendStart + NetConstants.NumSequenceNumbers) - m_windowStart) % NetConstants.NumSequenceNumbers;
+			int retval = m_windowSize - ((m_sendStart + NetConstants.NumSequenceNumbers) - m_windowStart) & NetConstants.NumSequenceNumberMask;
 			NetException.Assert(retval >= 0 && retval <= m_windowSize);
 			return retval;
 		}
@@ -64,10 +67,11 @@
 			//
 			// resends
 			//
+			if (m_usedStoredMessages != 0)
+			{
 			for (int i = 0; i < m_storedMessages.Length; i++)
 			{
-				NetOutgoingMessage om = m_storedMessages[i].Message;
-				if (om == null)
+				if ((m_usedStoredMessages & ((ulong)1 << i)) == 0)
 					continue;
 
 				double t = m_storedMessages[i].LastSent;
@@ -89,23 +93,28 @@
 					//m_connection.m_peer.LogVerbose("Resending due to delay #" + m_storedMessages[i].SequenceNumber + " " + om.ToString());
 					m_connection.m_statistics.MessageResent(MessageResendReason.Delay);
 
-					m_connection.QueueSendMessage(om, m_storedMessages[i].SequenceNumber);
+					m_connection.QueueSendMessage(m_storedMessages[i].Message, m_storedMessages[i].SequenceNumber);
 
 					m_storedMessages[i].LastSent = now;
 					m_storedMessages[i].NumSent++;
 				}
 			}
+			}
 
 			int num = GetAllowedSends();
-			if (num < 1)
+			if (num == 0)
 				return;
 
 			// queued sends
-			while (num > 0 && m_queuedSends.Count > 0)
+			int queued = m_queuedSends.Count;
+			while (queued > 0 && num > 0)
 			{
 				NetOutgoingMessage om;
 				if (m_queuedSends.TryDequeue(out om))
+				{
 					ExecuteSend(now, om);
+					queued--;
+				}
 				num--;
 				NetException.Assert(num == GetAllowedSends());
 			}
@@ -114,13 +123,14 @@
 		private void ExecuteSend(double now, NetOutgoingMessage message)
 		{
 			int seqNr = m_sendStart;
-			m_sendStart = (m_sendStart + 1) % NetConstants.NumSequenceNumbers;
+			m_sendStart = (m_sendStart + 1) & NetConstants.NumSequenceNumberMask;
 
 			m_connection.QueueSendMessage(message, seqNr);
 
 			int storeIndex = seqNr % m_windowSize;
-			NetException.Assert(m_storedMessages[storeIndex].Message == null);
+			NetException.Assert((m_usedStoredMessages & ((ulong)1 << storeIndex)) == 0);
 
+			m_usedStoredMessages |= (ulong)1 << storeIndex; // set used bit
 			m_storedMessages[storeIndex].NumSent++;
 			m_storedMessages[storeIndex].Message = message;
 			m_storedMessages[storeIndex].LastSent = now;
@@ -145,6 +155,7 @@
 #if !DEBUG
 			}
 #endif
+			m_usedStoredMessages &= ~((ulong)1 << storeIndex); // clear used bit
 			m_storedMessages[storeIndex] = new NetStoredReliableMessage();
 		}
 
@@ -170,7 +181,7 @@
 
 				m_receivedAcks[m_windowStart] = false;
 				DestoreMessage(m_windowStart % m_windowSize);
-				m_windowStart = (m_windowStart + 1) % NetConstants.NumSequenceNumbers;
+				m_windowStart = (m_windowStart + 1) & NetConstants.NumSequenceNumberMask;
 
 				// advance window if we already have early acks
 				while (m_receivedAcks.Get(m_windowStart))
@@ -179,8 +190,8 @@
 					m_receivedAcks[m_windowStart] = false;
 					DestoreMessage(m_windowStart % m_windowSize);
 
-					NetException.Assert(m_storedMessages[m_windowStart % m_windowSize].Message == null); // should already be destored
-					m_windowStart = (m_windowStart + 1) % NetConstants.NumSequenceNumbers;
+					NetException.Assert((m_usedStoredMessages & ((ulong)1 << (m_windowStart % m_windowSize))) == 0); // should already be destored
+					m_windowStart = (m_windowStart + 1) & NetConstants.NumSequenceNumberMask;
 					//m_connection.m_peer.LogDebug("Advancing window to #" + m_windowStart);
 				}
 
Index: NetUnreliableSenderChannel.cs
===================================================================
--- NetUnreliableSenderChannel.cs	(revision 396)
+++ NetUnreliableSenderChannel.cs	(working copy)
@@ -29,7 +29,10 @@
 
 		internal override int GetAllowedSends()
 		{
-			int retval = m_windowSize - ((m_sendStart + NetConstants.NumSequenceNumbers) - m_windowStart) % m_windowSize;
+			int subtract = (m_sendStart + NetConstants.NumSequenceNumbers) - m_windowStart;
+			while (subtract >= m_windowSize)
+				subtract -= m_windowSize;
+			int retval = m_windowSize - subtract;
 			NetException.Assert(retval >= 0 && retval <= m_windowSize);
 			return retval;
 		}
@@ -61,15 +64,19 @@
 		internal override void SendQueuedMessages(double now)
 		{
 			int num = GetAllowedSends();
-			if (num < 1)
+			if (num == 0)
 				return;
 
 			// queued sends
-			while (num > 0 && m_queuedSends.Count > 0)
+			int queued = m_queuedSends.Count;
+			while (queued > 0 && num > 0)
 			{
 				NetOutgoingMessage om;
 				if (m_queuedSends.TryDequeue(out om))
+				{
 					ExecuteSend(om);
+					queued--;
+				}
 				num--;
 			}
 		}
@@ -79,7 +86,7 @@
 			m_connection.m_peer.VerifyNetworkThread();
 
 			int seqNr = m_sendStart;
-			m_sendStart = (m_sendStart + 1) % NetConstants.NumSequenceNumbers;
+			m_sendStart = (m_sendStart + 1) & NetConstants.NumSequenceNumberMask;
 
 			m_connection.QueueSendMessage(message, seqNr);
 
@@ -111,7 +118,7 @@
 				NetException.Assert(seqNr == m_windowStart);
 
 				m_receivedAcks[m_windowStart] = false;
-				m_windowStart = (m_windowStart + 1) % NetConstants.NumSequenceNumbers;
+				m_windowStart = (m_windowStart + 1) & NetConstants.NumSequenceNumberMask;
 
 				return;
 			}
@@ -122,7 +129,7 @@
 			while (m_windowStart != seqNr)
 			{
 				m_receivedAcks[m_windowStart] = false;
-				m_windowStart = (m_windowStart + 1) % NetConstants.NumSequenceNumbers;
+				m_windowStart = (m_windowStart + 1) & NetConstants.NumSequenceNumberMask;
 			}
 		}
 	}