Merge https://github.com/openmultiplayer/RakNet

Author: Northn

Include/raknet/RakPeer.h

@@ -476,6 +476,13 @@ namespace RakNet
 		/// \sa RakNetStatistics.h
 		RakNetStatisticsStruct * GetStatistics( const PlayerID playerId ) override;
 
+#ifndef RAKNET_BUILD_FOR_CLIENT
+		/// Reserves a number of connection slots for internal use (e.g., NPCs).
+		/// Reserved slots are subtracted from the maximum peer limit when accepting new connections.
+		/// \param[in] count: The number of slots to reserve.
+		void ReserveSlots(unsigned short count) override;
+#endif
+
 		// --------------------------------------------------------------------------------------------EVERYTHING AFTER THIS COMMENT IS FOR INTERNAL USE ONLY--------------------------------------------------------------------------------------------
 		/// \internal
 		RPCMap *GetRPCMap( const PlayerID playerId) override;
@@ -594,6 +601,11 @@ namespace RakNet
 		///Store number of active peers.
 		unsigned short activePeersCount;
 
+#ifndef RAKNET_BUILD_FOR_CLIENT
+		///Store reserved slots, for the times slots are taken outside of RakNet
+		unsigned short reservedSlots;
+#endif
+
 		//05/02/06 Just using maximumNumberOfPeers instead
 		///Store the maximum number of peers able to connect, including reserved connection slots for pings, etc.
 		//unsigned short remoteSystemListSize;

Include/raknet/RakPeerInterface.h

@@ -448,6 +448,13 @@ namespace RakNet
 		/// \sa RakNetStatistics.h
 		virtual RakNetStatisticsStruct * GetStatistics( const PlayerID playerId )=0;
 
+#ifndef RAKNET_BUILD_FOR_CLIENT
+		/// Reserves a number of connection slots for internal use (e.g., NPCs).
+		/// Reserved slots are subtracted from the maximum peer limit when accepting new connections.
+		/// \param[in] count: The number of slots to reserve.
+		virtual void ReserveSlots(unsigned short count) = 0;
+#endif
+
 		// --------------------------------------------------------------------------------------------EVERYTHING AFTER THIS COMMENT IS FOR INTERNAL USE ONLY--------------------------------------------------------------------------------------------
 		/// \internal
 		virtual RPCMap *GetRPCMap( const PlayerID playerId)=0;

Include/raknet/RakServer.h

@@ -443,6 +443,13 @@ namespace RakNet
 		/// Get Remote System data for a player from their ID
 		virtual RakPeer::RemoteSystemStruct* GetRemoteSystemFromPlayerID(const PlayerID playerId) override;
 
+#ifndef RAKNET_BUILD_FOR_CLIENT
+		/// Reserves a number of connection slots for internal use (e.g., NPCs).
+		/// Reserved slots are subtracted from the maximum peer limit when accepting new connections.
+		/// \param[in] count: The number of slots to reserve.
+		void ReserveSlots(unsigned short count) override;
+#endif
+
 	private:
 		unsigned int seed, nextSeed;
 		RakNetTime broadcastPingsTime, nextSeedUpdate;

Include/raknet/RakServerInterface.h

@@ -436,6 +436,13 @@ namespace RakNet
 
 		/// Get Remote System data for a player from their ID
 		virtual RakPeer::RemoteSystemStruct* GetRemoteSystemFromPlayerID(const PlayerID playerId) = 0;
+
+#ifndef RAKNET_BUILD_FOR_CLIENT
+		/// Reserves a number of connection slots for internal use (e.g., NPCs).
+		/// Reserved slots are subtracted from the maximum peer limit when accepting new connections.
+		/// \param[in] count: The number of slots to reserve.
+		virtual void ReserveSlots(unsigned short count) = 0;
+#endif
 	};
 }
 

SAMPRakNet.cpp

@@ -29,6 +29,7 @@ unsigned int SAMPRakNet::messagesLimit_ = 500;
 unsigned int SAMPRakNet::messageHoleLimit_ = 3000;
 unsigned int SAMPRakNet::acksLimit_ = 3000;
 unsigned int SAMPRakNet::networkLimitsBanTime_ = 60000;
+float SAMPRakNet::minimumSendBitsPerSecond_ = 96000.0f;
 bool SAMPRakNet::logCookies_ = false;
 ICore* SAMPRakNet::core_ = nullptr;
 FlatHashSet<uint32_t> SAMPRakNet::incomingConnections_;

SAMPRakNet.hpp

@@ -166,6 +166,9 @@ class SAMPRakNet
 	static void SetGracePeriod(unsigned int time) { gracePeriod_ = RakNet::GetTime() + time; }
 	static RakNet::RakNetTime GetGracePeriod() { return gracePeriod_; }
 
+	static void SetMinimumSendBitsPerSecond(float bps) { minimumSendBitsPerSecond_ = bps; }
+	static inline float GetMinimumSendBitsPerSecond() { return minimumSendBitsPerSecond_; }
+
 	static ICore* GetCore() { return core_; }
 
 	static void ReplyToOmpClientAccessRequest(SOCKET connectionSocket, const RakNet::PlayerID& playerId, uint32_t encryptionKey);
@@ -272,6 +275,7 @@ class SAMPRakNet
 	static unsigned int messageHoleLimit_;
 	static unsigned int acksLimit_;
 	static unsigned int networkLimitsBanTime_;
+	static float minimumSendBitsPerSecond_;
 	static ICore* core_;
 	static FlatHashSet<uint32_t> incomingConnections_;
 	static RakNet::RakNetTime gracePeriod_;

Source/RakPeer.cpp

@@ -177,6 +177,9 @@ RakPeer::RakPeer()
 	maximumIncomingConnections = 0;
 	maximumNumberOfPeers = 0;
 	activePeersCount = 0;
+#ifndef RAKNET_BUILD_FOR_CLIENT
+	reservedSlots = 0;
+#endif
 	//remoteSystemListSize=0;
 	remoteSystemList = 0;
 	bytesSentPerSecond = bytesReceivedPerSecond = 0;
@@ -292,6 +295,9 @@ bool RakPeer::Initialize( unsigned short maxConnections, unsigned short localPor
 		// Clear the lookup table.  Safe to call from the user thread since the network thread is now stopped
 		remoteSystemLookup.Clear();
 		activePeersCount = 0;
+#ifndef RAKNET_BUILD_FOR_CLIENT
+	reservedSlots = 0;
+#endif
 	}
 
 	// For histogram statistics
@@ -698,6 +704,9 @@ void RakPeer::Disconnect( unsigned int blockDuration, unsigned char orderingChan
 	maximumNumberOfPeers = 0;
 	//remoteSystemListSize = 0;
 	activePeersCount = 0;
+#ifndef RAKNET_BUILD_FOR_CLIENT
+	reservedSlots = 0;
+#endif
 
 	// Free any packets the user didn't deallocate
 	Packet **packet;
@@ -2520,6 +2529,13 @@ RakNetStatisticsStruct * RakPeer::GetStatistics( const PlayerID playerId )
 	return 0;
 }
 
+#ifndef RAKNET_BUILD_FOR_CLIENT
+void RakPeer::ReserveSlots(unsigned short count)
+{
+	reservedSlots = count;
+}
+#endif
+
 // --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 /*
 void RakPeer::RemoveFromRequestedConnectionsList( const PlayerID playerId )
@@ -2828,8 +2844,14 @@ RakPeer::RemoteSystemStruct * RakPeer::AssignPlayerIDToRemoteSystemList( const P
 	RakAssert(playerId!=UNASSIGNED_PLAYER_ID);
 
 	// Check if maximum number of peers is reached .. without looping them.
-	if (activePeersCount == maximumNumberOfPeers)
+#ifndef RAKNET_BUILD_FOR_CLIENT
+	if (activePeersCount >= maximumNumberOfPeers - reservedSlots)
+#else
+	if (activePeersCount >= maximumNumberOfPeers)
+#endif
+	{
 		return 0;
+	}
 
 	// remoteSystemList in user thread
 	for ( i = 0; i < maximumNumberOfPeers; i++ )
@@ -4653,7 +4675,7 @@ namespace RakNet
 				}
 
 				// Taken from SA-MP 0.3.7 changes
-				if ((remoteSystem->connectMode == RemoteSystemStruct::DISCONNECT_ASAP || remoteSystem->connectMode == RemoteSystemStruct::DISCONNECT_ASAP_SILENTLY) && timeMS - remoteSystem->lastReliableSend > 20000)
+				if ((remoteSystem->connectMode == RemoteSystemStruct::DISCONNECT_ASAP || remoteSystem->connectMode == RemoteSystemStruct::DISCONNECT_ASAP_SILENTLY) && timeMS > remoteSystem->connectionTime && timeMS - remoteSystem->lastReliableSend > 20000)
 				{
 					packet = AllocPacket(sizeof(char));
 					packet->data[0] = ID_CONNECTION_LOST; // DeadConnection
@@ -4663,7 +4685,7 @@ namespace RakNet
 
 					AddPacketToProducer(packet);
 
-					CloseConnectionInternal(playerId, false, true, 0);
+					CloseConnectionInternal(playerId, false, true, 2);
 					continue;
 				}
 
@@ -5177,19 +5199,19 @@ namespace RakNet
 							}
 						}
 #endif
-						else
+						else if (data[0] == (unsigned char)ID_CONNECTION_LOST)
 						{
-							if (data[0]>=(unsigned char)ID_RPC)
-							{
-								packet=AllocPacket(byteSize, data);
-								packet->bitSize = bitSize;
-								packet->playerId = playerId;
-								packet->playerIndex = ( PlayerIndex ) remoteSystemIndex;
-								AddPacketToProducer(packet);					
-							}
-							//else
-								// Some internal type got returned to the user?
-								//RakAssert(0);
+							// Do nothing - packet is received through network.
+							// This shouldn't happen as it's an internal packet.
+							delete[] data;
+						}
+						else if (data[0] >= (unsigned char)ID_RPC)
+						{
+							packet = AllocPacket(byteSize, data);
+							packet->bitSize = bitSize;
+							packet->playerId = playerId;
+							packet->playerIndex = (PlayerIndex)remoteSystemIndex;
+							AddPacketToProducer(packet);
 						}
 					}
 

Source/ReliabilityLayer.cpp

@@ -45,8 +45,6 @@ using namespace RakNet;
 
 static const int DEFAULT_HAS_RECEIVED_PACKET_QUEUE_SIZE=512;
 static const float PACKETLOSS_TOLERANCE=.02f; // What percentile packetloss we are willing to accept as background noise.
-static const double MINIMUM_SEND_BPS=14400.0; // Won't go below this send rate
-static const double STARTING_SEND_BPS=28800.0; // What send rate to start at.
 static const float PING_MULTIPLIER_TO_RESEND=3.0; // So internet ping variation doesn't cause needless resends
 static const RakNetTime MIN_PING_TO_RESEND=30; // So system timer changes and CPU lag don't send needless resends
 static const RakNetTimeNS TIME_TO_NEW_SAMPLE=500000; // How many ns to wait before starting a new sample.  This way buffers have time to overflow or relax at the new send rate, if they are indeed going to overflow.
@@ -184,14 +182,14 @@ void ReliabilityLayer::InitializeVariables( void )
 	splitPacketId = 0;
 	messageNumber = 0;
 	availableBandwidth=0;
-	lastUpdateTime= RakNet::GetTimeNS();
-	currentBandwidth=STARTING_SEND_BPS;
+	lastUpdateTime = RakNet::GetTimeNS();
+	currentBandwidth = SAMPRakNet::GetMinimumSendBitsPerSecond() * 2.0f;
 	// lastPacketSendTime=retransmittedFrames=sentPackets=sentFrames=receivedPacketsCount=bytesSent=bytesReceived=0;
 
 	deadConnection = cheater = false;
 	lastAckTime = 0;
 
-	lowBandwidth=STARTING_SEND_BPS;
+	lowBandwidth = SAMPRakNet::GetMinimumSendBitsPerSecond();
 	histogramStartTime=lastUpdateTime+TIME_TO_NEW_SAMPLE+ping*2*1000;
 	histogramEndTime=histogramStartTime+MAX_TIME_TO_SAMPLE;
 
@@ -1113,6 +1111,8 @@ void ReliabilityLayer::Update( SOCKET s, PlayerID playerId, int MTUSize, RakNetT
 		return;
 	}
 
+	const auto minimumSendBPS = SAMPRakNet::GetMinimumSendBitsPerSecond();
+
 	// Water canister has to have enough room to put more water in :)
 	double requiredBuffer=(float)((MTUSize+UDP_HEADER_SIZE)*8);
 	if (requiredBuffer > currentBandwidth)
@@ -1168,8 +1168,8 @@ void ReliabilityLayer::Update( SOCKET s, PlayerID playerId, int MTUSize, RakNetT
 					lowBandwidth*=.9;
 				}
 
-				if (lowBandwidth < MINIMUM_SEND_BPS)
-					lowBandwidth=MINIMUM_SEND_BPS;
+				if (lowBandwidth < minimumSendBPS)
+					lowBandwidth=minimumSendBPS;
 
 				delta = (highBandwidth-lowBandwidth)/2;
 				currentBandwidth=delta+lowBandwidth;
@@ -1200,12 +1200,12 @@ void ReliabilityLayer::Update( SOCKET s, PlayerID playerId, int MTUSize, RakNetT
 				if (packetloss > .2)
 				{
 					lowBandwidth/=2;
-					if (lowBandwidth < MINIMUM_SEND_BPS)
-						lowBandwidth=MINIMUM_SEND_BPS;
+					if (lowBandwidth < minimumSendBPS)
+						lowBandwidth=minimumSendBPS;
 				}
 
 				delta = (highBandwidth-lowBandwidth)/2;
-				if (delta < MINIMUM_SEND_BPS/4)
+				if (delta < minimumSendBPS/4)
 				{
 					// If no packetloss and done searching, increase the high range by 50%
 					if (packetloss==0.0)
@@ -1221,8 +1221,8 @@ void ReliabilityLayer::Update( SOCKET s, PlayerID playerId, int MTUSize, RakNetT
 					{
 						// If some packetloss, but not a huge amount and done searching, decrease the low range by 10%
 						lowBandwidth*=.9;
-						if (lowBandwidth < MINIMUM_SEND_BPS)
-							lowBandwidth=MINIMUM_SEND_BPS;
+						if (lowBandwidth < minimumSendBPS)
+							lowBandwidth=minimumSendBPS;
 					}
 					delta = (highBandwidth-lowBandwidth)/2;
 				}

Source/SocketLayer.cpp

@@ -200,7 +200,7 @@ SOCKET SocketLayer::CreateBoundSocket( unsigned short port, bool blockingSocket,
 	setsockopt(listenSocket, SOL_SOCKET, SO_RCVBUF, ( char * ) & sock_opt, sizeof ( sock_opt ) );
 
 	// This doesn't make much difference: 10% maybe
-	sock_opt=1024*16;
+	sock_opt=1024*128;
 	setsockopt(listenSocket, SOL_SOCKET, SO_SNDBUF, ( char * ) & sock_opt, sizeof ( sock_opt ) );
 
 	#if defined(_WIN32) && !defined(_COMPATIBILITY_1) && defined(_DEBUG)

Source/rakserver.cpp

@@ -160,7 +160,7 @@ Packet* RakServer::Receive( void )
 
 void RakServer::Kick(const PlayerID playerId)
 {
-    RakPeer::NotifyAndFlagForDisconnect(playerId, false, 0);
+    RakPeer::NotifyAndFlagForDisconnect(playerId, false, 2);
 }
 
 void RakServer::DeallocatePacket( Packet *packet )
@@ -460,6 +460,11 @@ RakPeer::RemoteSystemStruct* RakServer::GetRemoteSystemFromPlayerID(const Player
 }
 
 #ifndef RAKNET_BUILD_FOR_CLIENT
+void RakServer::ReserveSlots(unsigned short count)
+{
+		RakPeer::ReserveSlots(count);
+}
+
 SAMPRakNet::RemoteSystemData RakServer::GetSAMPDataFromPlayerID(const PlayerID playerId)
 {
 	RemoteSystemStruct* remoteSystem = RakPeer::GetRemoteSystemFromPlayerID(playerId, false, false);