Revert RakNet source files back to the original v2.518 state

* Add RakNet source files to the VS project

raknet/NetworkIDGenerator.cpp

@@ -0,0 +1,291 @@
+/// \file
+///
+/// This file is part of RakNet Copyright 2003 Kevin Jenkins.
+///
+/// Usage of RakNet is subject to the appropriate license agreement.
+/// Creative Commons Licensees are subject to the
+/// license found at
+/// http://creativecommons.org/licenses/by-nc/2.5/
+/// Single application licensees are subject to the license found at
+/// http://www.rakkarsoft.com/SingleApplicationLicense.html
+/// Custom license users are subject to the terms therein.
+/// GPL license users are subject to the GNU General Public
+/// License as published by the Free
+/// Software Foundation; either version 2 of the License, or (at your
+/// option) any later version.
+
+#include "NetworkIDGenerator.h"
+
+#ifdef _COMPATIBILITY_1
+#elif defined(_WIN32)
+#include <malloc.h> // alloca
+#elif defined(_COMPATIBILITY_2)
+#include "Compatibility2Includes.h"
+#else
+#include <stdlib.h> // alloca
+#endif
+
+#include <assert.h>
+
+// Note you will need to save and load this if your game supports saving and loading so you start at the same index you left off.
+// If you don't do this you can overwrite indices
+unsigned short NetworkIDGenerator::staticItemID = 0;
+DataStructures::AVLBalancedBinarySearchTree<NetworkIDNode> NetworkIDGenerator::IDTree;
+PlayerID NetworkIDGenerator::externalPlayerId=UNASSIGNED_PLAYER_ID;
+
+bool NetworkIDNode::operator==( const NetworkIDNode& right ) const
+{
+	if ( networkID == right.networkID )
+		return !0;
+
+	return 0;
+}
+
+bool NetworkIDNode::operator > ( const NetworkIDNode& right ) const
+{
+	if ( networkID > right.networkID )
+		return !0;
+
+	return 0;
+}
+
+bool NetworkIDNode::operator < ( const NetworkIDNode& right ) const
+{
+	if ( networkID < right.networkID )
+		return !0;
+
+	return 0;
+}
+
+NetworkIDNode::NetworkIDNode()
+{
+	object = 0;
+}
+
+NetworkIDNode::NetworkIDNode( NetworkID _networkID, NetworkIDGenerator *_object )
+{
+	networkID = _networkID;
+	object = _object;
+}
+
+
+//////////////////////////////////////////////////////////////////////
+// Construction/Destruction
+//////////////////////////////////////////////////////////////////////
+
+NetworkIDGenerator::NetworkIDGenerator()
+{
+	callGenerationCode=true;
+	networkID=UNASSIGNED_NETWORK_ID;
+	parent=0;
+}
+
+//-------------------------------------------------------------------------------------
+
+
+NetworkIDGenerator::~NetworkIDGenerator()
+{
+	if (networkID!=UNASSIGNED_NETWORK_ID)
+	{
+		NetworkIDNode * object = NetworkIDGenerator::IDTree.GetPointerToNode( NetworkIDNode( ( networkID ), 0 ) );
+		if ( object->object == this )
+			IDTree.Del( NetworkIDNode( object->networkID, 0 ) );
+	}
+}
+
+//////////////////////////////////////////////////////////////////////
+// Public Methods
+//////////////////////////////////////////////////////////////////////
+
+NetworkID NetworkIDGenerator::GetNetworkID( void )
+{
+	if (callGenerationCode && IsNetworkIDAuthority())
+	{
+		GenerateID();
+		callGenerationCode=false;
+	}
+
+	return networkID;
+};
+
+//-------------------------------------------------------------------------------------
+
+unsigned short NetworkIDGenerator::GetStaticNetworkID( void )
+{
+	return staticItemID;
+}
+
+//-------------------------------------------------------------------------------------
+
+void NetworkIDGenerator::SetStaticNetworkID( unsigned short i )
+{
+	staticItemID = i;
+}
+
+//-------------------------------------------------------------------------------------
+void NetworkIDGenerator::SetExternalPlayerID(PlayerID playerId)
+{
+	assert(playerId!=UNASSIGNED_PLAYER_ID);
+	externalPlayerId=playerId;
+}
+//-------------------------------------------------------------------------------------
+PlayerID NetworkIDGenerator::GetExternalPlayerID(void)
+{
+	return externalPlayerId;
+}
+//-------------------------------------------------------------------------------------
+
+bool NetworkIDGenerator::RequiresSetParent(void) const
+{
+	return false;
+}
+
+//-------------------------------------------------------------------------------------
+
+void NetworkIDGenerator::SetNetworkID( NetworkID id )
+{
+	callGenerationCode=false;
+
+	if ( id == UNASSIGNED_NETWORK_ID )
+	{
+		// puts("Warning: NetworkIDGenerator passed UNASSIGNED_NETWORK_ID.  SetID ignored");
+		return ;
+	}
+
+	if ( networkID == id )
+	{
+		// printf("NetworkIDGenerator passed %i which already exists in the tree.  SetID ignored", id);
+		return ;
+	}
+
+	NetworkIDNode* collision = NetworkIDGenerator::IDTree.GetPointerToNode( NetworkIDNode( ( id ), 0 ) );
+
+	if ( collision )   // Tree should have only unique values.  The new value is already in use.
+	{
+		//printf("Warning: NetworkIDGenerator::SetID passed %i, which has an existing node in the tree.  Old node removed, which will cause the item pointed to to be inaccessible to the network", id);
+		IDTree.Del( NetworkIDNode( collision->networkID, collision->object ) );
+	}
+
+	if ( networkID == UNASSIGNED_NETWORK_ID )   // Object has not had an ID assigned so does not already exist in the tree
+	{
+		networkID = id;
+		IDTree.Add( NetworkIDNode( networkID, this ) );
+	}
+	else // Object already exists in the tree and has an assigned ID
+	{
+		IDTree.Del( NetworkIDNode( networkID, this ) ); // Delete the node with whatever ID the existing object is using
+		networkID = id;
+		IDTree.Add( NetworkIDNode( networkID, this ) );
+	}
+}
+
+//-------------------------------------------------------------------------------------
+void NetworkIDGenerator::SetParent( void *_parent )
+{
+	parent=_parent;
+
+#ifdef _DEBUG
+	// Avoid duplicate parents in the tree
+	unsigned size = IDTree.Size();
+	NetworkIDNode *nodeArray;
+
+	bool usedAlloca=false;
+	#if !defined(_COMPATIBILITY_1)
+	if (sizeof(NetworkIDNode) * size < MAX_ALLOCA_STACK_ALLOCATION)
+	{
+		nodeArray = (NetworkIDNode*) alloca(sizeof(NetworkIDNode) * size);
+		usedAlloca=true;
+	}
+	else
+	#endif
+		nodeArray = new NetworkIDNode[size];
+
+
+	IDTree.DisplayBreadthFirstSearch( nodeArray );
+	unsigned i;
+	for (i=0; i < size; i++)
+	{
+		// If this assert hits then this _parent is already in the tree.  Classes instance should never contain more than one NetworkIDGenerator
+		assert(nodeArray->object->GetParent()!=parent);
+	}
+	
+	if (usedAlloca==false)
+		delete [] nodeArray;
+	
+#endif
+}
+
+//-------------------------------------------------------------------------------------
+void* NetworkIDGenerator::GetParent( void ) const
+{
+	return parent;
+}
+//-------------------------------------------------------------------------------------
+void NetworkIDGenerator::GenerateID(void)
+{
+	assert(IsNetworkIDAuthority());
+
+	NetworkIDNode* collision;
+	do
+	{
+		networkID.localSystemId=staticItemID++;
+		if (NetworkID::peerToPeerMode)
+		{
+			 // If this assert hits you forgot to call SetExternalPlayerID
+			assert(externalPlayerId!=UNASSIGNED_PLAYER_ID);
+			networkID.playerId=externalPlayerId;
+		}
+		collision = NetworkIDGenerator::IDTree.GetPointerToNode( NetworkIDNode( ( networkID ), 0 ) );
+	}
+	while ( collision );
+
+	IDTree.Add( NetworkIDNode( networkID, this ) );
+}
+
+//-------------------------------------------------------------------------------------
+void* NetworkIDGenerator::GET_BASE_OBJECT_FROM_ID( NetworkID x )
+{
+	if ( x == UNASSIGNED_NETWORK_ID )
+		return 0;
+
+	NetworkIDNode *n = NetworkIDGenerator::IDTree.GetPointerToNode( NetworkIDNode( ( x ), 0 ) );
+
+	if ( n )
+	{
+		return n->object;
+	}
+
+	return 0;
+}
+//-------------------------------------------------------------------------------------
+void* NetworkIDGenerator::GET_OBJECT_FROM_ID( NetworkID x )
+{
+	NetworkIDGenerator *object = (NetworkIDGenerator *) GET_BASE_OBJECT_FROM_ID( x );
+	if (object)
+	{
+		if (object->GetParent())
+		{
+			return object->GetParent();
+		}
+		else
+		{
+#ifdef _DEBUG
+			// If this assert hit then this object requires a call to SetParent and it never got one.
+			assert(object->RequiresSetParent()==false);
+#endif
+			return object;
+		}
+	}
+
+	return 0;
+}
+//-------------------------------------------------------------------------------------
+void* GET_OBJECT_FROM_ID( NetworkID x )
+{
+	return NetworkIDGenerator::GET_OBJECT_FROM_ID( x );
+}
+
+
+//////////////////////////////////////////////////////////////////////
+// EOF
+//////////////////////////////////////////////////////////////////////