GameClient - merge

Code/Game/GameClient/GameClient.vcxproj

@@ -201,7 +201,9 @@
     <ClCompile Include="DanBiasGame_Impl.cpp" />
     <ClCompile Include="GameClientState\Camera_Basic.cpp" />
     <ClCompile Include="GameClientState\Camera.cpp" />
+    <ClCompile Include="GameClientState\Camera_BasicV2.cpp" />
     <ClCompile Include="GameClientState\Camera_FPS.cpp" />
+    <ClCompile Include="GameClientState\Camera_FPSV2.cpp" />
     <ClCompile Include="GameClientState\C_obj\C_DynamicObj.cpp" />
     <ClCompile Include="GameClientState\C_obj\C_Player.cpp" />
     <ClCompile Include="GameClientState\C_obj\C_StaticObj.cpp" />
@@ -226,7 +228,9 @@
     <ClInclude Include="GameClientState\Buttons\EventButtonGUI.h" />
     <ClInclude Include="GameClientState\Buttons\ButtonRectangle.h" />
     <ClInclude Include="GameClientState\Camera.h" />
+    <ClInclude Include="GameClientState\Camera_BasicV2.h" />
     <ClInclude Include="GameClientState\Camera_FPS.h" />
+    <ClInclude Include="GameClientState\Camera_FPSV2.h" />
     <ClInclude Include="GameClientState\C_obj\C_DynamicObj.h" />
     <ClInclude Include="GameClientState\C_obj\C_Player.h" />
     <ClInclude Include="GameClientState\C_obj\C_StaticObj.h" />

Code/Game/GameClient/GameClient.vcxproj.user

@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <PropertyGroup>
-    <ShowAllFiles>false</ShowAllFiles>
+    <ShowAllFiles>true</ShowAllFiles>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
     <LocalDebuggerWorkingDirectory>$(OutDir)</LocalDebuggerWorkingDirectory>

Code/Game/GameClient/GameClientRecieverFunc.h

@@ -1,192 +0,0 @@
-#ifndef DANBIAS_CLIENTRECIEVEROBJECT_H
-#define DANBIAS_CLIENTRECIEVEROBJECT_H
-
-//WTF!? No headers included???
-#include "../DanBiasGame/Include/DanBiasGame.h"
-#include "../GameProtocols/GeneralProtocols.h"
-#include "../GameProtocols/Protocols.h"
-#include "../Network/NetworkAPI/NetworkClient.h"
-#include "GameClientState\GameClientState.h"
-#include "GameClientState\GameState.h"
-
-#include <Utilities.h>
-
-namespace DanBias
-{
-	struct GameRecieverObject : public Oyster::Network::NetworkClient
-	{
-		Client::GameClientState* gameClientState;
-
-		// receiver function for server messages 
-		// parsing protocols and sending it to the gameState
-		//void NetworkCallback(Oyster::Network::CustomNetProtocol& p) override
-		void GameRecieverObject::DataRecieved( Oyster::Network::NetEvent<Oyster::Network::NetworkClient*, Oyster::Network::NetworkClient::ClientEventArgs> e ) override
-		{
-			Oyster::Network::CustomNetProtocol p = e.args.data.protocol;
-			int pType = p[0].value.netInt;
-
-			//printf("Message(%i) arrived at client(%i)\n", pType, this->GetID());
-
-
-			switch (pType)
-			{
-			case protocol_General_Status:
-				{
-					GameLogic::Protocol_General_Status::States state;
-					state =  (GameLogic::Protocol_General_Status::States)p[1].value.netShort;
-					if( state == GameLogic::Protocol_General_Status::States_disconected)
-					{
-						// server disconnected 
-						DanBiasGame::Release();
-					}
-				}
-				break;
-			case protocol_Gameplay_ObjectCreate:
-				{
-					Client::GameClientState::NewObj protocolData;// = new Client::GameClientState::NewObj;
-					protocolData.object_ID = p[1].value.netInt;
-					protocolData.path = p[2].value.netCharPtr;
-					for(int i = 0; i< 16; i++)
-					{
-						protocolData.worldPos[i] = p[i+3].value.netFloat;
-					}
-
-					if(dynamic_cast<Client::GameState*>(gameClientState))
-						((Client::GameState*)gameClientState)->Protocol(&protocolData);
-
-					//delete p[2].value.netCharPtr; //delete char array
-					//delete protocolData;
-					//protocolData = NULL;
-				}
-				break;
-			case protocol_Gameplay_ObjectDisabled:
-				{
-					Client::GameClientState::RemoveObj* protocolData = new Client::GameClientState::RemoveObj;
-					protocolData->object_ID = p[1].value.netInt;
-
-					if(dynamic_cast<Client::GameState*>(gameClientState))
-						((Client::GameState*)gameClientState)->Protocol(protocolData);
-
-					delete protocolData;
-					protocolData = NULL;
-				}
-				break;
-			case protocol_Gameplay_ObjectPosition:
-				{
-					// 0: reserved
-					// 1: objectID
-					// 2,3,4: position
-					// 5,6,7,8: rotation quaternion
-
-					GameLogic::Protocol_ObjectPosition data(p);
-
-					Client::GameClientState::ObjPos protocolData;
-					protocolData.object_ID = data.object_ID;
-					//protocolData.object_ID = p[1].value.netInt;
-
-					for( int i = 0; i < 3; ++i )
-					{
-						protocolData.position[i] = data.position[i];
-					}
-
-					//for(int i = 0; i< 16; i++)
-					//{
-					//	protocolData.worldPos[i] = p[i+2].value.netFloat;
-					//}
-
-					if(dynamic_cast<Client::GameState*>(gameClientState))
-						((Client::GameState*)gameClientState)->Protocol(&protocolData);
-				}
-				break;
-			case protocol_Gameplay_ObjectPositionRotation:
-				{
-
-					Client::GameClientState::ObjPos protocolData;
-					protocolData.object_ID = p[1].value.netInt;
-					for(int i = 0; i< 16; i++)
-					{
-						protocolData.worldPos[i] = p[i+2].value.netFloat;
-					}
-
-					if(dynamic_cast<Client::GameState*>(gameClientState))
-						((Client::GameState*)gameClientState)->Protocol(&protocolData);
-				}
-				break;
-			case protocol_Lobby_Create:
-				{
-					if(dynamic_cast<Client::LobbyState*>(gameClientState))
-					{
-						int id = p.Get(1).value.netInt;
-						std::string name = p.Get(19).value.netCharPtr;
-						Oyster::Math::Float4x4 w;
-						for(int i = 0; i< 16; i++)
-						{
-							w[i] = p[i+2].value.netFloat;
-						}
-
-						gameClientState->Release();
-						delete gameClientState;
-
-						gameClientState = new Client::GameState();
-						gameClientState->Init(this);
-						std::wstring temp;
-						Utility::String::StringToWstring(name, temp);
-						((Client::GameState*)gameClientState)->InitiatePlayer(id, temp, w);
-
-						//Do some wait state?
-					}
-				}
-				break;
-			case protocol_Lobby_Start:
-				{
-					if(dynamic_cast<Client::GameState*>(gameClientState))
-					{
-						//Game state should start in n seconds
-						GameLogic::Protocol_LobbyStartGame p(p);
-						p.seconds;
-
-						//Sleep((int)(p.seconds * 1000));
-					}
-				}
-				break;
-
-			default:
-				break;
-			}	
-
-			if(ProtocolIsLobby(p[0].value.netInt))	ParseLobbyProtocol(p);
-		}
-
-		void ParseLobbyProtocol(Oyster::Network::CustomNetProtocol& p)
-		{
-			switch (p[0].value.netShort)
-			{
-				case protocol_General_Status:	//this->GeneralStatus		(Protocol_General_Status	(p), c);
-				break;
-				case protocol_General_Text:		//this->GeneralText		(Protocol_General_Text		(p), c);
-				break;
-				//case protocol_Lobby_Create:		this->LobbyCreateGame	(Protocol_LobbyCreateGame	(p), c);
-				//break;
-				case protocol_Lobby_Start:		//this->LobbyStartGame	(Protocol_LobbyStartGame	(p), c);
-				break;
-				//case protocol_Lobby_Join:		this->LobbyJoin			(Protocol_LobbyJoin			(p), c);
-				//break;
-				case protocol_Lobby_Login:		//this->LobbyLogin		(Protocol_LobbyLogin		(p), c);
-				break;
-				case protocol_Lobby_Refresh:	//this->LobbyRefresh		(Protocol_LobbyRefresh		(p), c);
-				break;
-				case protocol_Lobby_GameData:	//this->LobbyGameData		(Protocol_LobbyGameData		(p), c);
-				{
-					//GameLogic::Protocol_LobbyGameData temp(p);
-					//printf("%s, %i.%i\n", temp.mapName.c_str(), temp.majorVersion, temp.minorVersion);
-				}
-				break;
-				case protocol_Lobby_ClientData:	//this->LobbyMainData		(Protocol_LobbyClientData	(p), c);
-				break;
-				//case protocol_Lobby_GameData:	this->LobbyGameData		(Protocol_LobbyGameData		(p), c);
-				//break;
-			}
-		}
-	};
-} 
-#endif

Code/Game/GameClient/GameClientState/Camera_BasicV2.cpp

@@ -0,0 +1,117 @@
+#include "Camera_BasicV2.h"
+
+using namespace ::Oyster::Math3D;
+
+Camera_BasicV2::Camera_BasicV2()
+{
+	this->translation = Float3::null;
+	this->rotation = Quaternion::identity;
+	this->projection = Float4x4::identity;
+}
+
+Camera_BasicV2::Camera_BasicV2( const Float3 &position, const Quaternion &rotation, const Float4x4 &projection )
+{
+	this->translation = position;
+	this->rotation = rotation;
+	this->projection = projection;
+}
+
+Camera_BasicV2::~Camera_BasicV2() {}
+
+Camera_BasicV2 & Camera_BasicV2::operator = ( const Camera_BasicV2 &camera )
+{
+	this->translation = camera.translation;
+	this->rotation = camera.rotation;
+	this->projection = camera.projection;
+	return *this;
+}
+
+void Camera_BasicV2::SetPosition( const Float3 &translation )
+{
+	this->translation = translation;
+}
+
+void Camera_BasicV2::SetRotation( const Quaternion &rotation )
+{
+	this->rotation = rotation;
+}
+
+void Camera_BasicV2::SetAngular( const Float3 &axis )
+{
+	this->rotation = Rotation( axis );
+}
+
+void Camera_BasicV2::SetProjection( const Float4x4 &matrix )
+{
+	this->projection = matrix;
+}
+
+void Camera_BasicV2::SetOrthographicProjection( Float width, Float height, Float nearClip, Float farClip )
+{
+	ProjectionMatrix_Orthographic( width, height, nearClip, farClip, this->projection );
+}
+
+void Camera_BasicV2::SetPerspectiveProjection( Float verticalFoV, Float aspectRatio, Float nearClip, Float farClip )
+{
+	ProjectionMatrix_Perspective( verticalFoV, aspectRatio, nearClip, farClip, this->projection );
+}
+
+void Camera_BasicV2::Move( const Float3 &deltaPosition )
+{
+	this->translation += deltaPosition;
+}
+
+void Camera_BasicV2::Rotate( const Quaternion &deltaRotation )
+{
+	this->rotation *= deltaRotation;
+}
+
+void Camera_BasicV2::Rotate( const Float3 &deltaAngularAxis )
+{
+	this->rotation *= Rotation( deltaAngularAxis );
+}
+
+const Float3 & Camera_BasicV2::GetPosition() const
+{
+	return this->translation;
+}
+
+Float3 & Camera_BasicV2::GetAngularAxis( Float3 &targetMem ) const
+{
+	return targetMem = AngularAxis( this->rotation );
+}
+
+Float3 Camera_BasicV2::GetNormalOf( const Float3 &axis ) const
+{
+	return WorldAxisOf( this->rotation, axis );
+}
+
+const Quaternion & Camera_BasicV2::GetRotation() const
+{
+	return this->rotation;
+}
+
+Float3x3 & Camera_BasicV2::GetRotationMatrix( Float3x3 &targetMem ) const
+{
+	return RotationMatrix( this->rotation, targetMem );
+}
+
+Float4x4 & Camera_BasicV2::GetRotationMatrix( Float4x4 &targetMem ) const
+{
+	return RotationMatrix( this->rotation, targetMem );
+}
+
+Float4x4 & Camera_BasicV2::GetViewMatrix( Float4x4 &targetMem ) const
+{
+	return ViewMatrix( this->rotation, this->translation, targetMem );
+}
+
+const Float4x4 & Camera_BasicV2::GetProjectionMatrix() const
+{
+	return this->projection;
+}
+
+Float4x4 & Camera_BasicV2::GetViewsProjMatrix( Float4x4 &targetMem ) const
+{
+	return TransformMatrix( this->projection, this->GetViewMatrix(), targetMem );
+}

Code/Game/GameClient/GameClientState/Camera_BasicV2.h

@@ -0,0 +1,42 @@
+#ifndef CAMERA_BASIC_V2_H
+#define CAMERA_BASIC_V2_H
+
+#include "OysterMath.h"
+
+class Camera_BasicV2
+{
+public:
+	Camera_BasicV2();
+	Camera_BasicV2( const ::Oyster::Math::Float3 &position, const ::Oyster::Math::Quaternion &rotation, const ::Oyster::Math::Float4x4 &projection );
+	virtual ~Camera_BasicV2();
+
+	Camera_BasicV2 & operator = ( const Camera_BasicV2 &camera );
+
+	void SetPosition( const ::Oyster::Math::Float3 &translation );
+	void SetRotation( const ::Oyster::Math::Quaternion &rotation );
+	void SetAngular( const ::Oyster::Math::Float3 &axis );
+	void SetProjection( const ::Oyster::Math::Float4x4 &matrix );
+	void SetOrthographicProjection( ::Oyster::Math::Float width, ::Oyster::Math::Float height, ::Oyster::Math::Float nearClip, ::Oyster::Math::Float farClip );
+	void SetPerspectiveProjection( ::Oyster::Math::Float verticalFoV, ::Oyster::Math::Float aspectRatio, ::Oyster::Math::Float nearClip, ::Oyster::Math::Float farClip );
+
+	void Move( const ::Oyster::Math::Float3 &deltaPosition );
+	void Rotate( const ::Oyster::Math::Quaternion &deltaRotation );
+	void Rotate( const ::Oyster::Math::Float3 &deltaAngularAxis );
+
+	const ::Oyster::Math::Float3	 & GetPosition() const;
+		  ::Oyster::Math::Float3	 & GetAngularAxis( ::Oyster::Math::Float3 &targetMem = ::Oyster::Math::Float3() ) const;
+		  ::Oyster::Math::Float3	   GetNormalOf( const ::Oyster::Math::Float3 &axis ) const;
+	const ::Oyster::Math::Quaternion & GetRotation() const;
+		  ::Oyster::Math::Float3x3   & GetRotationMatrix( ::Oyster::Math::Float3x3 &targetMem ) const;
+		  ::Oyster::Math::Float4x4   & GetRotationMatrix( ::Oyster::Math::Float4x4 &targetMem ) const;
+		  ::Oyster::Math::Float4x4   & GetViewMatrix( Oyster::Math::Float4x4 &targetMem = ::Oyster::Math::Float4x4() ) const;
+	const ::Oyster::Math::Float4x4   & GetProjectionMatrix() const;
+		  ::Oyster::Math::Float4x4   & GetViewsProjMatrix( Oyster::Math::Float4x4 &targetMem = ::Oyster::Math::Float4x4() ) const;
+
+	private:
+			::Oyster::Math::Float3 translation;
+	mutable ::Oyster::Math::Quaternion rotation;
+			::Oyster::Math::Float4x4 projection;
+};
+
+#endif

Code/Game/GameClient/GameClientState/Camera_FPSV2.cpp

@@ -0,0 +1,186 @@
+#include "Camera_FPSV2.h"
+#include "Utilities.h"
+
+using namespace ::Oyster::Math3D;
+using namespace ::Utility::Value;
+
+Camera_FPSV2::Camera_FPSV2()
+{ // this->head is default set to identity uniformprojection at origo
+	this->pitchUp = 0.0f;
+	this->headOffset =
+	this->body.translation = Float3::null;
+	this->body.rotation = Quaternion::identity;
+}
+
+Camera_FPSV2::~Camera_FPSV2() {}
+
+Camera_FPSV2 & Camera_FPSV2::operator = ( const Camera_FPSV2 &camera )
+{
+	this->head = camera.head;
+	this->pitchUp = camera.pitchUp;
+	this->headOffset = camera.headOffset;
+	this->body.translation = camera.body.translation;
+	this->body.rotation = camera.body.rotation;
+	return *this;
+}
+
+void Camera_FPSV2::SetHeadOffset( const Float3 &translation )
+{
+	this->head.Move( translation - this->headOffset );
+	this->headOffset = translation;
+}
+
+void Camera_FPSV2::SetPosition( const Float3 &translation )
+{
+	this->head.Move( translation - this->body.translation );
+	this->body.translation = translation;
+}
+
+void Camera_FPSV2::SetRotation( const Quaternion &rotation )
+{
+	this->body.rotation = rotation;
+	this->head.SetRotation( rotation * Rotation(this->pitchUp, this->GetNormalOf(Float3::standard_unit_x) ) );
+}
+
+void Camera_FPSV2::SetAngular( const Float3 &axis )
+{
+	this->SetRotation( Rotation(axis) );
+}
+
+void Camera_FPSV2::SetProjection( const Float4x4 &matrix )
+{
+	this->head.SetProjection( matrix );
+}
+
+void Camera_FPSV2::SetOrthographicProjection( Float width, Float height, Float nearClip, Float farClip )
+{
+	this->head.SetOrthographicProjection( width, height, nearClip, farClip );
+}
+
+void Camera_FPSV2::SetPerspectiveProjection( Float verticalFoV, Float aspectRatio, Float nearClip, Float farClip )
+{
+	this->head.SetPerspectiveProjection( verticalFoV, aspectRatio, nearClip, farClip );
+}
+
+void Camera_FPSV2::UpdateOrientation()
+{
+	Float4x4 orientation;
+	OrientationMatrix( this->body.rotation, this->body.translation, orientation );
+
+	this->head.SetPosition( (orientation * Float4(this->headOffset, 1.0f)).xyz );
+}
+
+void Camera_FPSV2::SnapUpToNormal( const Float3 &normal )
+{
+	this->body.rotation = Rotation( SnapAngularAxis(AngularAxis(this->body.rotation), WorldAxisOf(this->body.rotation, Float3::standard_unit_y), normal) );
+	this->head.SetRotation( this->body.rotation * Rotation(this->pitchUp * Float3::standard_unit_x) );
+}
+
+void Camera_FPSV2::Move( const Float3 &deltaPosition )
+{
+	this->head.Move( deltaPosition );
+	this->body.translation += deltaPosition;
+}
+
+void Camera_FPSV2::Rotate( const Quaternion &deltaRotation )
+{
+	this->head.Rotate( deltaRotation );
+	this->body.rotation *= deltaRotation;
+}
+
+void Camera_FPSV2::Rotate( const Float3 &deltaAngularAxis )
+{
+	this->Rotate( Rotation(deltaAngularAxis) );
+}
+
+void Camera_FPSV2::MoveForward( Float distance )
+{
+	this->MoveBackward( -distance );
+}
+
+void Camera_FPSV2::MoveBackward( Float distance )
+{
+	this->Move( distance * WorldAxisOf(this->body.rotation, Float3::standard_unit_z) );
+}
+
+void Camera_FPSV2::StrafeRight( Float distance )
+{
+	this->Move( distance * WorldAxisOf(this->body.rotation, Float3::standard_unit_x) );
+}
+
+void Camera_FPSV2::StrafeLeft( Float distance )
+{
+	this->StrafeRight( -distance );
+}
+
+void Camera_FPSV2::PitchUp( Float radian )
+{
+	this->pitchUp = Clamp( this->pitchUp + radian, -0.48f * pi, 0.48f * pi );
+	this->head.SetRotation( this->body.rotation * Rotation(this->pitchUp, Float3::standard_unit_x) );
+}
+
+void Camera_FPSV2::PitchDown( Float radian )
+{
+	this->PitchUp( -radian );
+}
+
+void Camera_FPSV2::YawRight( Float radian )
+{
+	this->YawLeft( -radian );
+}
+
+void Camera_FPSV2::YawLeft( Float radian )
+{
+	Quaternion deltaRotation = Rotation( radian, WorldAxisOf(this->body.rotation, Float3::standard_unit_y) );
+	this->Rotate( deltaRotation );
+}
+
+const Float3 & Camera_FPSV2::GetHeadOffset() const
+{
+	return this->headOffset;
+}
+
+const Float3 & Camera_FPSV2::GetPosition() const
+{
+	return this->body.translation;
+}
+
+Float4x4 & Camera_FPSV2::GetViewMatrix( Float4x4 &targetMem ) const
+{
+	return this->head.GetViewMatrix( targetMem );
+}
+
+const Float4x4 & Camera_FPSV2::GetProjectionMatrix() const
+{
+	return this->head.GetProjectionMatrix();
+}
+
+Float4x4 & Camera_FPSV2::GetViewsProjMatrix( Float4x4 &targetMem ) const
+{
+	return this->head.GetViewsProjMatrix( targetMem );
+}
+
+Float3 Camera_FPSV2::GetNormalOf( const Float3 &axis ) const
+{
+	return this->head.GetNormalOf( axis );
+}
+
+Float3 Camera_FPSV2::GetRight() const
+{
+	return WorldAxisOf( this->body.rotation, Float3::standard_unit_x );
+}
+
+Float3 Camera_FPSV2::GetUp() const
+{
+	return WorldAxisOf( this->body.rotation, Float3::standard_unit_y );
+}
+
+Float3 Camera_FPSV2::GetLook() const
+{
+	return this->head.GetNormalOf( -Float3::standard_unit_z );
+}
+
+Float3 Camera_FPSV2::GetForward() const
+{
+	return WorldAxisOf( this->body.rotation, -Float3::standard_unit_z );
+}

Code/Game/GameClient/GameClientState/Camera_FPSV2.h

@@ -0,0 +1,63 @@
+#ifndef CAMERA_FPSV2_H
+#define CAMERA_FPSV2_H
+
+#include "OysterMath.h"
+#include "Camera_BasicV2.h"
+
+class Camera_FPSV2
+{
+public:
+	Camera_FPSV2();
+	virtual ~Camera_FPSV2();
+
+	Camera_FPSV2 & operator = ( const Camera_FPSV2 &camera );
+
+	void SetHeadOffset( const ::Oyster::Math::Float3 &translation );
+	void SetPosition( const ::Oyster::Math::Float3 &translation );
+	void SetRotation( const ::Oyster::Math::Quaternion &rotation );
+	void SetAngular( const ::Oyster::Math::Float3 &axis );
+	void SetProjection( const ::Oyster::Math::Float4x4 &matrix );
+	void SetOrthographicProjection( ::Oyster::Math::Float width, ::Oyster::Math::Float height, ::Oyster::Math::Float nearClip, ::Oyster::Math::Float farClip );
+	void SetPerspectiveProjection( ::Oyster::Math::Float verticalFoV, ::Oyster::Math::Float aspectRatio, ::Oyster::Math::Float nearClip, ::Oyster::Math::Float farClip );
+
+	void UpdateOrientation();
+
+	void SnapUpToNormal( const ::Oyster::Math::Float3 &normal );
+
+	void Move( const ::Oyster::Math::Float3 &deltaPosition );
+	void Rotate( const ::Oyster::Math::Quaternion &deltaRotation );
+	void Rotate( const ::Oyster::Math::Float3 &deltaAngularAxis );
+
+	void MoveForward( ::Oyster::Math::Float distance );
+	void MoveBackward( ::Oyster::Math::Float distance );
+	void StrafeRight( ::Oyster::Math::Float distance );
+	void StrafeLeft( ::Oyster::Math::Float distance );
+
+	void PitchUp( ::Oyster::Math::Float radian );
+	void PitchDown( ::Oyster::Math::Float radian );
+	void YawRight( ::Oyster::Math::Float radian );
+	void YawLeft( ::Oyster::Math::Float radian );
+
+	const ::Oyster::Math::Float3	 & GetHeadOffset() const;
+	const ::Oyster::Math::Float3	 & GetPosition() const;
+		  ::Oyster::Math::Float4x4   & GetViewMatrix( Oyster::Math::Float4x4 &targetMem = ::Oyster::Math::Float4x4() ) const;
+	const ::Oyster::Math::Float4x4   & GetProjectionMatrix() const;
+		  ::Oyster::Math::Float4x4   & GetViewsProjMatrix( Oyster::Math::Float4x4 &targetMem = ::Oyster::Math::Float4x4() ) const;
+		  ::Oyster::Math::Float3	   GetNormalOf( const ::Oyster::Math::Float3 &axis ) const;
+		  ::Oyster::Math::Float3	   GetRight() const;
+		  ::Oyster::Math::Float3	   GetUp() const;
+		  ::Oyster::Math::Float3	   GetLook() const;
+		  ::Oyster::Math::Float3	   GetForward() const;
+
+private:
+	Camera_BasicV2 head;
+	::Oyster::Math::Float pitchUp;
+	::Oyster::Math::Float3 headOffset;
+	struct
+	{
+		::Oyster::Math::Float3 translation;
+		::Oyster::Math::Quaternion rotation;
+	} body;
+};
+
+#endif

Code/Game/GameClient/GameClientState/GameClientState.cpp

@@ -3,9 +3,14 @@
 using namespace DanBias::Client;
 using namespace ::Oyster::Network;
 
+const GameClientState::NetEvent GameClientState::event_processed = GameClientState::NetEvent();
+
 GameClientState::GameClientState() {}
 
 GameClientState::~GameClientState() {}
 
-void GameClientState::DataRecieved( NetEvent<NetworkClient*, NetworkClient::ClientEventArgs> e )
+const GameClientState::NetEvent & GameClientState::DataRecieved( const GameClientState::NetEvent &message )
-{ /* do nothing */ }
+{
+	/* do nothing */
+	return message;
+}

Code/Game/GameClient/GameClientState/GameClientState.h

@@ -22,7 +22,9 @@ namespace DanBias { namespace Client
 			ClientState_Quit
 		};
 
-	public:
+		typedef ::Oyster::Network::NetEvent<::Oyster::Network::NetworkClient*, ::Oyster::Network::NetworkClient::ClientEventArgs> NetEvent;
+		static const NetEvent event_processed;
+
 		GameClientState();
 		virtual ~GameClientState();
 		virtual bool Init( SharedStateContent &shared ) = 0;
@@ -31,7 +33,11 @@ namespace DanBias { namespace Client
 		virtual bool Release() = 0;
 		virtual void ChangeState( ClientState next ) = 0;
 
-		virtual void DataRecieved( ::Oyster::Network::NetEvent<::Oyster::Network::NetworkClient*, ::Oyster::Network::NetworkClient::ClientEventArgs> e );
+		/******************************************************************
+		 * @param message of the event
+		 * @return message or GameClientState::event_processed.
+		 ******************************************************************/
+		virtual const NetEvent & DataRecieved( const NetEvent &message );
 	};
 } }
 

Code/Game/GameClient/GameClientState/GameState.cpp

@@ -2,7 +2,7 @@
 #include "DllInterfaces/GFXAPI.h"
 #include <Protocols.h>
 #include "NetworkClient.h"
-#include "Camera_FPS.h"
+#include "Camera_FPSV2.h"
 #include <GameServerAPI.h>
 
 #include "C_obj/C_Player.h"
@@ -39,7 +39,7 @@ struct  GameState::MyData
 	bool key_Reload_Shaders;
 
 	C_Player player;
-	Camera_FPS camera;
+	Camera_FPSV2 camera;
 
 	int myId;
 
@@ -85,11 +85,7 @@ bool GameState::Init( SharedStateContent &shared )
 	Graphics::API::SetProjection( this->privData->camera.GetProjectionMatrix() );
 
 	//tell server ready
-	//this->privData->nwClient->Send( Protocol_General_Status(Protocol_General_Status::States_ready) );
+	this->privData->nwClient->Send( Protocol_General_Status(Protocol_General_Status::States_ready) );
-
-	// Debugg hack
-	this->InitiatePlayer( 0, "crate_generic.dan",Float3( 0,132, 10), Quaternion::identity, Float3(1), true );	
-	// end debug hack
 			
 	return true;
 }
@@ -120,7 +116,7 @@ void GameState::InitiatePlayer( int id, const std::string &modelName, const floa
 			this->privData->myId = id;
 			this->privData->camera.SetPosition( this->privData->player.getPos() );
 			Float3 offset = Float3( 0.0f );
-			offset.y = this->privData->player.getScale().y + 0.5f; // debug hack +0.5f
+			offset.y = this->privData->player.getScale().y * 0.9f;
 			this->privData->camera.SetHeadOffset( offset );
 			this->privData->camera.UpdateOrientation();
 		}
@@ -162,7 +158,8 @@ bool GameState::Render()
 	auto dynamicObject = this->privData->dynamicObjects->begin();
 	for( ; dynamicObject != this->privData->dynamicObjects->end(); ++dynamicObject )
 	{
-		dynamicObject->second->Render();
+		if( dynamicObject->second )
+			dynamicObject->second->Render();
 	}
 
 	// RB DEBUG render wire frame 
@@ -237,7 +234,7 @@ void GameState::ReadKeyInput()
 {
 	if( this->privData->input->IsKeyPressed(DIK_W) )
 	{
-		if(!this->privData->key_forward)
+		//if(!this->privData->key_forward)
 		{
 			this->privData->nwClient->Send( Protocol_PlayerMovementForward() );
 			this->privData->key_forward = true;
@@ -248,7 +245,7 @@ void GameState::ReadKeyInput()
 
 	if( this->privData->input->IsKeyPressed(DIK_S) )
 	{
-		if( !this->privData->key_backward )
+		//if( !this->privData->key_backward )
 		{
 			this->privData->nwClient->Send( Protocol_PlayerMovementBackward() );
 			this->privData->key_backward = true;
@@ -259,7 +256,7 @@ void GameState::ReadKeyInput()
 
 	if( this->privData->input->IsKeyPressed(DIK_A) )
 	{
-		if( !this->privData->key_strafeLeft )
+		//if( !this->privData->key_strafeLeft )
 		{
 			this->privData->nwClient->Send( Protocol_PlayerMovementLeft() );
 			this->privData->key_strafeLeft = true;
@@ -270,7 +267,7 @@ void GameState::ReadKeyInput()
 
 	if( this->privData->input->IsKeyPressed(DIK_D) )
 	{
-		if( !this->privData->key_strafeRight )
+		//if( !this->privData->key_strafeRight )
 		{
 			this->privData->nwClient->Send( Protocol_PlayerMovementRight() );
 			this->privData->key_strafeRight = true;
@@ -362,13 +359,22 @@ void GameState::ReadKeyInput()
 	// TODO: implement sub-menu
 }
 
-void GameState::DataRecieved( NetEvent<NetworkClient*, NetworkClient::ClientEventArgs> e )
+const GameClientState::NetEvent & GameState::DataRecieved( const GameClientState::NetEvent &message )
 {
-	CustomNetProtocol data = e.args.data.protocol;
+	if( message.args.type == NetworkClient::ClientEventArgs::EventType_ProtocolFailedToSend )
-	short ID = data[0].value.netShort; // fetching the id data.
+	{ // TODO: Reconnect
+		const char *breakpoint = "temp trap";
+		this->privData->nwClient->Disconnect();
+		this->ChangeState( GameClientState::ClientState_Main );
+	}
+
+	// fetching the id data.
+	short ID = message.args.data.protocol[0].value.netShort;
 
 	if( ProtocolIsGameplay(ID) )
 	{
+		CustomNetProtocol data = message.args.data.protocol;
+
 		switch(ID)
 		{
 		case protocol_Gameplay_ObjectPickup:			break; /** @todo TODO: implement */
@@ -384,13 +390,13 @@ void GameState::DataRecieved( NetEvent<NetworkClient*, NetworkClient::ClientEven
 
 				(*this->privData->dynamicObjects)[decoded.object_ID]->setPos( decoded.position );
 			}
-			break;
+			return GameClientState::event_processed;
 		case protocol_Gameplay_ObjectScale:
 			{
 				Protocol_ObjectScale decoded(data);
 				(*this->privData->dynamicObjects)[decoded.object_ID]->setScale( decoded.scale );
 			}
-			break;
+			return GameClientState::event_processed;
 		case protocol_Gameplay_ObjectRotation:
 			{
 				Protocol_ObjectRotation decoded(data);
@@ -398,11 +404,11 @@ void GameState::DataRecieved( NetEvent<NetworkClient*, NetworkClient::ClientEven
 
 				// if is this player. Remember to change camera
 				if( this->privData->myId == decoded.object_ID )
-					this->privData->camera.SetAngular( AngularAxis(rotation) );
+					this->privData->camera.SetRotation( rotation );
 
 				(*this->privData->dynamicObjects)[decoded.object_ID]->setRot( rotation );
 			}
-			break;
+			return GameClientState::event_processed;
 		case protocol_Gameplay_ObjectPositionRotation:
 			{
 				Protocol_ObjectPositionRotation decoded(data);
@@ -413,14 +419,19 @@ void GameState::DataRecieved( NetEvent<NetworkClient*, NetworkClient::ClientEven
 				if( this->privData->myId == decoded.object_ID )
 				{
 					this->privData->camera.SetPosition( position );
-					this->privData->camera.SetAngular( AngularAxis(rotation) );
+					//this->privData->camera.SetRotation( rotation );
+					this->privData->player.setPos( position );
+					//this->privData->player.setRot( rotation );
 				}
 
 				C_DynamicObj *object = (*this->privData->dynamicObjects)[decoded.object_ID];
-				object->setPos( position );
+				if( object )
-				object->setRot( rotation );
+				{
+					object->setPos( position );
+					object->setRot( rotation );
+				}
 			}
-			break;
+			return GameClientState::event_processed;
 		case protocol_Gameplay_ObjectEnabled:			break; /** @todo TODO: implement */
 		case protocol_Gameplay_ObjectDisabled:
 			{
@@ -433,7 +444,7 @@ void GameState::DataRecieved( NetEvent<NetworkClient*, NetworkClient::ClientEven
 					this->privData->dynamicObjects->erase( object );
 				}
 			}
-			break;
+			return GameClientState::event_processed;
 		case protocol_Gameplay_ObjectCreate:
 			{
 				Protocol_ObjectCreate decoded(data);
@@ -454,13 +465,13 @@ void GameState::DataRecieved( NetEvent<NetworkClient*, NetworkClient::ClientEven
 				(*this->privData->dynamicObjects)[decoded.object_ID] = object;
 
 			}		
-			break;
+			return GameClientState::event_processed;
 		case protocol_Gameplay_ObjectCreatePlayer:
 			{
 				Protocol_ObjectCreatePlayer decoded(data);
 				this->InitiatePlayer( decoded.object_ID, decoded.meshName, decoded.position, decoded.rotationQ, decoded.scale, decoded.owner );				
 			}
-			break;
+			return GameClientState::event_processed;
 		case protocol_Gameplay_ObjectJoinTeam:			break; /** @todo TODO: implement */
 		case protocol_Gameplay_ObjectLeaveTeam:			break; /** @todo TODO: implement */
 		case protocol_Gameplay_ObjectWeaponCooldown:	break; /** @todo TODO: implement */
@@ -479,4 +490,6 @@ void GameState::DataRecieved( NetEvent<NetworkClient*, NetworkClient::ClientEven
 		default: break;
 		}
 	}
+
+	return message;
 }

Code/Game/GameClient/GameClientState/GameState.h

@@ -26,7 +26,7 @@ namespace DanBias { namespace Client
 		bool Release()override;
 		void ChangeState( ClientState next );
 
-		void DataRecieved( ::Oyster::Network::NetEvent<::Oyster::Network::NetworkClient*, ::Oyster::Network::NetworkClient::ClientEventArgs> e );
+		const NetEvent & DataRecieved( const NetEvent &message );
 
 	private:
 		struct MyData;

Code/Game/GameClient/GameClientState/LanMenuState.cpp

@@ -61,6 +61,7 @@ bool LanMenuState::Init( SharedStateContent &shared )
 	this->privData->connectIP = new TextField<LanMenuState*>( L"color_white.png", Float4(1.0f), Float4(0.0f), this, Float3(0.5f, 0.3f, 0.5f), Float2(0.8f, 0.09f), ResizeAspectRatio_None );
 	this->privData->connectIP->ReserveLines( 1 );
 	this->privData->connectIP->AppendText( L"127.0.0.1" );
+	//this->privData->connectIP->AppendText( L"194.47.150.206" ); // HACK: connecting to Dennis's server
 	this->privData->connectIP->SetFontHeight( 0.08f );
 	this->privData->connectIP->SetLineSpacing( 0.005f );
 	this->privData->connectIP->SetTopAligned();

Code/Game/GameClient/GameClientState/LevelLoader/LevelParser.cpp

@@ -33,184 +33,187 @@ std::vector<SmartPointer<ObjectTypeHeader>> LevelParser::Parse(std::string filen
 	Loader loader;
 	char* buffer = (char*)loader.LoadFile(filename.c_str(), bufferSize);
 
-	//Read format version
+	if(buffer)
-	LevelLoaderInternal::FormatVersion levelFormatVersion;
-	ParseObject(&buffer[counter], &levelFormatVersion, sizeof(levelFormatVersion));
-	counter += sizeof(levelFormatVersion);
-	if(this->formatVersion != levelFormatVersion)
 	{
-		//Returns an empty vector, because it will most likely fail to read the level format.
+		//Read format version
-		return objects;
+		LevelLoaderInternal::FormatVersion levelFormatVersion;
-	}
+		ParseObject(&buffer[counter], &levelFormatVersion, sizeof(levelFormatVersion));
-
+		counter += sizeof(levelFormatVersion);
-  	while(counter < bufferSize)
+		if(this->formatVersion != levelFormatVersion)
-	{
-		loadCgf = true;
-		//Get typeID
-		ObjectType typeID;
-		ParseObject(&buffer[counter], &typeID, sizeof(typeID));
-		switch((int)typeID)
 		{
-			case ObjectType_LevelMetaData:
+			//Returns an empty vector, because it will most likely fail to read the level format.
+			return objects;
+		}
+
+  		while(counter < bufferSize)
+		{
+			loadCgf = true;
+			//Get typeID
+			ObjectType typeID;
+			ParseObject(&buffer[counter], &typeID, sizeof(typeID));
+			switch((int)typeID)
 			{
-				SmartPointer<ObjectTypeHeader> header = new LevelMetaData;
+				case ObjectType_LevelMetaData:
-				ParseLevelMetaData(&buffer[counter], *(LevelMetaData*)header.Get(), counter);
-				objects.push_back(header);
-				break;
-			}
-
-			case ObjectType_SpawnPoint:
-			{
-				loadCgf = false;
-				ObjectHeader* header = new ObjectHeader;
-				ParseObject(&buffer[counter], *header, counter, loadCgf);
-
-				SpawnPointAttributes* spawn = new SpawnPointAttributes;
-
-				spawn->typeID = header->typeID;
-
-				for(int i = 0; i < 3; i++)
 				{
-					spawn->position[i] = header->position[i];
+					SmartPointer<ObjectTypeHeader> header = new LevelMetaData;
+					ParseLevelMetaData(&buffer[counter], *(LevelMetaData*)header.Get(), counter);
+					objects.push_back(header);
+					break;
 				}
 
-				delete header;
+				case ObjectType_SpawnPoint:
-				//objects.push_back(header);
-				objects.push_back(spawn);
-				break;
-			}
-
-			//This is by design, static and dynamic is using the same converter. Do not add anything inbetween them. 
-			//Unless they are changed to not be the same.
-			case ObjectType_Static: case ObjectType_Dynamic:
-			{
-				//Get specialType.
-				ObjectSpecialType specialType;
-				ParseObject(&buffer[counter+4], &specialType, sizeof(typeID));
-
-				switch(specialType)
 				{
-					//there is no difference when parsing these specialTypes.
+					loadCgf = false;
-					case ObjectSpecialType_CrystalShard:
+					ObjectHeader* header = new ObjectHeader;
-					case ObjectSpecialType_CrystalFormation:
+					ParseObject(&buffer[counter], *header, counter, loadCgf);
-					case ObjectSpecialType_Spike:
-					case ObjectSpecialType_SpikeBox:
-					case ObjectSpecialType_RedExplosiveBox:
-					case ObjectSpecialType_StandarsBox:
-					case ObjectSpecialType_Stone:
-					case ObjectSpecialType_Building:
-					{
-						ObjectHeader* header = new ObjectHeader;
-						ParseObject(&buffer[counter], *header, counter, loadCgf);
-						objects.push_back(header);
 
-						break;
+					SpawnPointAttributes* spawn = new SpawnPointAttributes;
+
+					spawn->typeID = header->typeID;
+
+					for(int i = 0; i < 3; i++)
+					{
+						spawn->position[i] = header->position[i];
 					}
 
-					case ObjectSpecialType_JumpPad:
+					delete header;
+					//objects.push_back(header);
+					objects.push_back(spawn);
+					break;
+				}
+
+				//This is by design, static and dynamic is using the same converter. Do not add anything inbetween them. 
+				//Unless they are changed to not be the same.
+				case ObjectType_Static: case ObjectType_Dynamic:
+				{
+					//Get specialType.
+					ObjectSpecialType specialType;
+					ParseObject(&buffer[counter+4], &specialType, sizeof(typeID));
+
+					switch(specialType)
 					{
-						JumpPadAttributes* header = new JumpPadAttributes;
+						//there is no difference when parsing these specialTypes.
-						ParseObject(&buffer[counter], *header, counter, loadCgf);
+						case ObjectSpecialType_CrystalShard:
+						case ObjectSpecialType_CrystalFormation:
+						case ObjectSpecialType_Spike:
+						case ObjectSpecialType_SpikeBox:
+						case ObjectSpecialType_RedExplosiveBox:
+						case ObjectSpecialType_StandarsBox:
+						case ObjectSpecialType_Stone:
+						case ObjectSpecialType_Building:
+						{
+							ObjectHeader* header = new ObjectHeader;
+							ParseObject(&buffer[counter], *header, counter, loadCgf);
+							objects.push_back(header);
 
-						//Read the spec
+							break;
-						ParseObject(&buffer[counter], header->direction, 16);
+						}
-						counter += 16;
-						objects.push_back(header);
 
-						break;
+						case ObjectSpecialType_JumpPad:
+						{
+							JumpPadAttributes* header = new JumpPadAttributes;
+							ParseObject(&buffer[counter], *header, counter, loadCgf);
+
+							//Read the spec
+							ParseObject(&buffer[counter], header->direction, 16);
+							counter += 16;
+							objects.push_back(header);
+
+							break;
+						}
+		
+						case ObjectSpecialType_Portal:
+						{
+							PortalAttributes* header = new PortalAttributes;
+							ParseObject(&buffer[counter], *header, counter, loadCgf);
+
+							ParseObject(&buffer[counter], header->destination, 12);
+							counter += 12;
+							objects.push_back(header);
+
+							break;
+						}
+					
+						case ObjectSpecialType_World:
+						{
+							WorldAttributes* header = new WorldAttributes;
+							ParseObject(&buffer[counter], *header, counter, loadCgf);
+
+							ParseObject(&buffer[counter], &header->worldSize, 8);
+							counter += 8;
+							objects.push_back(header);
+							break;
+						}
+
+						case ObjectSpecialType_Sky:
+						{
+							loadCgf = false; 
+							SkyAttributes* header = new SkyAttributes;
+							ParseObject(&buffer[counter], *header, counter, loadCgf);
+
+							ParseObject(&buffer[counter], &header->skySize, 4);
+							counter += 4;
+							objects.push_back(header);
+							break;
+						}
+						//this is a hotfix, fix so you only load the relevant data when the file is updated
+					
+
+						default:
+							//Couldn't find specialType
+							break;
 					}
+					break;
+				}
 			
-					case ObjectSpecialType_Portal:
+				case ObjectType_Light:
+				{
+					LightType lightType;
+
+					//Get Light type
+					ParseObject(&buffer[counter+4], &lightType, sizeof(lightType));
+
+					//We only support PointLight for now.
+					BasicLight* header = new BasicLight;
+					ParseObject(&buffer[counter], header, sizeof(*header));
+					counter += sizeof(*header);
+					objects.push_back(header);
+					/*switch(lightType)
 					{
-						PortalAttributes* header = new PortalAttributes;
+					case LightType_PointLight:
-						ParseObject(&buffer[counter], *header, counter, loadCgf);
-
-						ParseObject(&buffer[counter], header->destination, 12);
-						counter += 12;
-						objects.push_back(header);
-
-						break;
-					}
-					
-					case ObjectSpecialType_World:
 					{
-						WorldAttributes* header = new WorldAttributes;
+						PointLight* header = new PointLight;
-						ParseObject(&buffer[counter], *header, counter, loadCgf);
+						ParseObject(&buffer[counter], header, sizeof(*header));
-
+						counter += sizeof(*header);
-						ParseObject(&buffer[counter], &header->worldSize, 8);
-						counter += 8;
 						objects.push_back(header);
 						break;
 					}
-
+					case LightType_DirectionalLight:
-					case ObjectSpecialType_Sky:
 					{
-						loadCgf = false; 
+						DirectionalLight* header = new DirectionalLight;
-						SkyAttributes* header = new SkyAttributes;
+						ParseObject(&buffer[counter], header, sizeof(*header));
-						ParseObject(&buffer[counter], *header, counter, loadCgf);
+						counter += sizeof(*header);
-
+						objects.push_back(header);
-						ParseObject(&buffer[counter], &header->skySize, 4);
+						break;
-						counter += 4;
+					}
+					case LightType_SpotLight:
+					{
+						SpotLight* header = new SpotLight;
+						ParseObject(&buffer[counter], header, sizeof(*header));
+						counter += sizeof(*header);
 						objects.push_back(header);
 						break;
 					}
-					//this is a hotfix, fix so you only load the relevant data when the file is updated
-					
-
 					default:
-						//Couldn't find specialType
+						//Undefined LightType.
 						break;
-				}
+					}
-				break;
+					break;*/
-			}
-			
-			case ObjectType_Light:
-			{
-				LightType lightType;
-
-				//Get Light type
-				ParseObject(&buffer[counter+4], &lightType, sizeof(lightType));
-
-				//We only support PointLight for now.
-				BasicLight* header = new BasicLight;
-				ParseObject(&buffer[counter], header, sizeof(*header));
-				counter += sizeof(*header);
-				objects.push_back(header);
-				/*switch(lightType)
-				{
-				case LightType_PointLight:
-				{
-					PointLight* header = new PointLight;
-					ParseObject(&buffer[counter], header, sizeof(*header));
-					counter += sizeof(*header);
-					objects.push_back(header);
-					break;
-				}
-				case LightType_DirectionalLight:
-				{
-					DirectionalLight* header = new DirectionalLight;
-					ParseObject(&buffer[counter], header, sizeof(*header));
-					counter += sizeof(*header);
-					objects.push_back(header);
-					break;
-				}
-				case LightType_SpotLight:
-				{
-					SpotLight* header = new SpotLight;
-					ParseObject(&buffer[counter], header, sizeof(*header));
-					counter += sizeof(*header);
-					objects.push_back(header);
-					break;
 				}
 				default:
-					//Undefined LightType.
+					//Couldn't find typeID. FAIL!!!!!!
 					break;
-				}
-				break;*/
 			}
-			default:
-				//Couldn't find typeID. FAIL!!!!!!
-				break;
 		}
 	}
 

Code/Game/GameClient/GameClientState/LobbyAdminState.cpp

@@ -112,10 +112,10 @@ void LobbyAdminState::ChangeState( ClientState next )
 
 using namespace ::Oyster::Network;
 
-void LobbyAdminState::DataRecieved( NetEvent<NetworkClient*, NetworkClient::ClientEventArgs> e )
+const GameClientState::NetEvent & LobbyAdminState::DataRecieved( const GameClientState::NetEvent &message )
 {
-	CustomNetProtocol data = e.args.data.protocol;
+	// fetching the id data.
-	short ID = data[0].value.netShort; // fetching the id data.
+	short ID = message.args.data.protocol[0].value.netShort;
 	
 	// Block irrelevant messages.
 	if( ProtocolIsLobby(ID) )
@@ -141,6 +141,7 @@ void LobbyAdminState::DataRecieved( NetEvent<NetworkClient*, NetworkClient::Clie
 		default: break;
 		}
 	}
+	return message;
 }
 
 void OnButtonInteract_Ready( Oyster::Event::ButtonEvent<LobbyAdminState*>& e )

Code/Game/GameClient/GameClientState/LobbyAdminState.h

@@ -29,7 +29,7 @@ namespace DanBias
 			bool Render();
 			bool Release();
 			void ChangeState( ClientState next );
-			void DataRecieved( ::Oyster::Network::NetEvent<::Oyster::Network::NetworkClient*, ::Oyster::Network::NetworkClient::ClientEventArgs> e );
+			const NetEvent & DataRecieved( const NetEvent &message );
 			
 		private:
 			struct MyData;

Code/Game/GameClient/GameClientState/LobbyState.cpp

@@ -112,10 +112,10 @@ void LobbyState::ChangeState( ClientState next )
 
 using namespace ::Oyster::Network;
 
-void LobbyState::DataRecieved( NetEvent<NetworkClient*, NetworkClient::ClientEventArgs> e )
+const GameClientState::NetEvent & LobbyState::DataRecieved( const GameClientState::NetEvent &message )
 {
-	CustomNetProtocol data = e.args.data.protocol;
+	// fetching the id data.
-	short ID = data[0].value.netShort; // fetching the id data.
+	short ID = message.args.data.protocol[0].value.netShort;
 	
 	// Block irrelevant messages.
 	if( ProtocolIsLobby(ID) )
@@ -141,6 +141,8 @@ void LobbyState::DataRecieved( NetEvent<NetworkClient*, NetworkClient::ClientEve
 		default: break;
 		}
 	}
+
+	return message;
 }
 
 void OnButtonInteract_Ready( Oyster::Event::ButtonEvent<LobbyState*>& e )

Code/Game/GameClient/GameClientState/LobbyState.h

@@ -31,7 +31,7 @@ namespace DanBias
 			bool Render();
 			bool Release();
 			void ChangeState( ClientState next );
-			void DataRecieved( ::Oyster::Network::NetEvent<::Oyster::Network::NetworkClient*, ::Oyster::Network::NetworkClient::ClientEventArgs> e );
+			const NetEvent & DataRecieved( const NetEvent &message );
 
 		private:
 			struct MyData;

Code/Game/GameClient/GameClientState/NetLoadState.cpp

@@ -54,11 +54,8 @@ bool NetLoadState::Init( SharedStateContent &shared )
 
 	// we may assume that nwClient is properly connected to the server
 	// signals querry to server for loading instructions
-	//this->privData->nwClient->Send( Protocol_QuerryGameType() );
+	this->privData->nwClient->Send( Protocol_QuerryGameType() );
 
-	// debugg
-	this->LoadGame( "..//Content//Worlds//2ofAll_updated.bias");
-	this->ChangeState( ClientState_Game );
 	return true;
 }
 
@@ -93,16 +90,25 @@ void NetLoadState::ChangeState( ClientState next )
 	this->privData->nextState = next;
 }
 
-void NetLoadState::DataRecieved( NetEvent<NetworkClient*, NetworkClient::ClientEventArgs> e )
+const GameClientState::NetEvent & NetLoadState::DataRecieved( const GameClientState::NetEvent &message )
 {
 	// fetching the id data.
-	short ID = e.args.data.protocol[0].value.netShort;
+	short ID = message.args.data.protocol[0].value.netShort;
 	
-	if( ID == protocol_Lobby_CreateGame && !this->privData->loading )
+	if( ID == protocol_Lobby_CreateGame )
 	{
-		this->LoadGame( Protocol_LobbyCreateGame(e.args.data.protocol).modelName );
+		if( !this->privData->loading )
-		this->ChangeState( ClientState_Game );
+		{
-		this->privData->loading = false;
+			this->LoadGame( Protocol_LobbyCreateGame(message.args.data.protocol).mapName );
+			this->ChangeState( ClientState_Game );
+			this->privData->loading = false;
+		}
+		return GameClientState::event_processed;
+	}
+	else
+	{ // HACK: Debug trap
+		const char *breakPoint = "Being greedy.";
+		return message;
 	}
 }
 
@@ -110,7 +116,7 @@ void NetLoadState::LoadGame( const ::std::string &fileName )
 {
 	this->privData->loading = true;
 
-	LevelLoader loader;
+	LevelLoader loader( "..\\Content\\Worlds\\" );
 	auto objects = loader.LoadLevel( fileName );
 	auto object = objects.begin();
 	ObjectTypeHeader *oth;
@@ -135,6 +141,17 @@ void NetLoadState::LoadGame( const ::std::string &fileName )
 				desc.scale		= oh->scale;
 				desc.visible	= true; 
 
+<<<<<<< HEAD
+=======
+				// HACK: untill the world is right in lvl format
+				if( oh->specialTypeID == ObjectSpecialType_World)
+				{
+					desc.position	= Float3(0,0,0); 
+					desc.rotation	= Quaternion::identity;
+					desc.scale		= Float3(300,300,300);
+				}
+
+>>>>>>> ed6825a40888474eb1b4a803085fbe4e073812f2
 				C_StaticObj *staticObject = new C_StaticObj();
 				if( staticObject->Init( desc ) )
 				{

Code/Game/GameClient/GameClientState/NetLoadState.h

@@ -21,7 +21,7 @@ namespace DanBias
 			bool Release();
 			void ChangeState( ClientState next );
 
-			void DataRecieved( ::Oyster::Network::NetEvent<::Oyster::Network::NetworkClient*, ::Oyster::Network::NetworkClient::ClientEventArgs> e );
+			const NetEvent & DataRecieved( const NetEvent &message );
 		
 		private:
 			struct MyData;

Code/Game/GameLogic/CollisionManager.cpp

@@ -170,12 +170,12 @@ using namespace GameLogic;
 	
 	void PlayerVLethalObject(Player &player, Object &obj, Oyster::Math::Float kineticEnergyLoss, Oyster::Math::Float ExtraDamage)
 	{
-		int damageDone = 0;
+		Oyster::Math::Float damageDone = 0;
-		int forceThreashHold = 200000;
+		Oyster::Math::Float forceThreashHold = 200000;
 
 		if(kineticEnergyLoss > forceThreashHold) //should only take damage if the force is high enough
 		{
-			damageDone = (int)(kineticEnergyLoss * 0.10f);
+			damageDone = (kineticEnergyLoss * 0.10f);
 			damageDone += ExtraDamage;
 			//player.DamageLife(damageDone);
 		}

Code/Game/GameLogic/Game.cpp

@@ -76,14 +76,12 @@ Game::PlayerData* Game::CreatePlayer()
 	return this->players[i];
 }
 
-Game::LevelData* Game::CreateLevel()
+Game::LevelData* Game::CreateLevel(const wchar_t mapName[255])
 {
 	if(this->level) return this->level;
 
 	this->level = new LevelData();
-	//this->level->level->InitiateLevel(1000);
+	this->level->level->InitiateLevel(mapName);
-	this->level->level->InitiateLevel("../Content/Worlds/ccc.bias");
-
 
 	return this->level;
 }

Code/Game/GameLogic/Game.h

@@ -58,9 +58,11 @@ namespace GameLogic
 			Oyster::Math::Float3 GetScale()							override;
 			Oyster::Math::Float4x4 GetOrientation()					override; 
 			int GetID() const										override;
-			ObjectSpecialType GetObjectType()	const						override;
+			ObjectSpecialType GetObjectType()	const				override;
 			int getNrOfDynamicObj()const							override;
 			IObjectData* GetObjectAt(int ID) const					override;
+			void GetAllDynamicObjects(Utility::DynamicMemory::DynamicArray<IObjectData*>& mem) const override;
+
 			Level *level;
 		};
 
@@ -70,7 +72,7 @@ namespace GameLogic
 
 		void GetAllPlayerPositions() const																				override;
 		PlayerData* CreatePlayer()																						override;
-		LevelData* CreateLevel()																						override;
+		LevelData* CreateLevel(const wchar_t mapName[255] )																override;
 		void CreateTeam()																								override;
 		bool NewFrame()																									override;
 		void SetFPS( int FPS )																							override;

Code/Game/GameLogic/GameAPI.h

@@ -13,6 +13,7 @@
 #include "GameLogicStates.h"
 #include <OysterMath.h>
 #include "LevelLoader\ObjectDefines.h"
+#include "DynamicArray.h"
 
 
 namespace GameLogic
@@ -107,6 +108,7 @@ namespace GameLogic
 		public:
 			virtual int getNrOfDynamicObj()const						= 0;
 			virtual IObjectData* GetObjectAt(int ID) const				= 0;
+			virtual void GetAllDynamicObjects(Utility::DynamicMemory::DynamicArray<IObjectData*>& destMem) const = 0;
 		};
 
 	class DANBIAS_GAMELOGIC_DLL GameAPI
@@ -137,7 +139,7 @@ namespace GameLogic
 		/**	Creates a level 
 		*	@return Returns a ILevelData container to use for level manipulation
 		*/
-		virtual ILevelData* CreateLevel( void ) = 0;
+		virtual ILevelData* CreateLevel( const wchar_t mapName[255] ) = 0;
 
 		/** Creates a team
 		*	@return ?

Code/Game/GameLogic/Game_LevelData.cpp

@@ -51,3 +51,12 @@ IObjectData* Game::LevelData::GetObjectAt(int ID) const
 {	
 	return this->level->GetObj(ID);
 }
+
+void Game::LevelData::GetAllDynamicObjects(Utility::DynamicMemory::DynamicArray<IObjectData*>& mem) const
+{
+	mem.Resize(level->dynamicObjects.Size());
+	for(int i = 0; i < (int)level->dynamicObjects.Size(); i++)
+	{
+		mem[i] = level->dynamicObjects[i];
+	}
+}

Code/Game/GameLogic/Game_PlayerData.cpp

@@ -7,7 +7,7 @@ Game::PlayerData::PlayerData()
 {	
 	//set some stats that are appropriate to a player
 
-	Oyster::Math::Float3 centerPosition = Oyster::Math::Float3(50,130,0);
+	Oyster::Math::Float3 centerPosition = Oyster::Math::Float3(-50,180,0);
 
 	Oyster::Math::Float3 size = Oyster::Math::Float3(0.25f,2.0f,0.5f);
 	Oyster::Math::Float mass = 60;
@@ -27,9 +27,7 @@ Game::PlayerData::PlayerData()
 }
 Game::PlayerData::PlayerData(int playerID,int teamID)
 {
-	Oyster::Physics::ICustomBody* rigidBody;
 	this->player = new Player();
-
 }
 Game::PlayerData::~PlayerData()
 {

Code/Game/GameLogic/Level.cpp

@@ -26,14 +26,14 @@ Object* Level::createGameObj(ObjectHeader* obj, ICustomBody* rigidBody)
 	{
 	case ObjectSpecialType_None: 
 		{
-			gameObj = new StaticObject(rigidBody, Object::DefaultCollisionAfter, (ObjectSpecialType)obj->specialTypeID, objID++); 
+			gameObj = new StaticObject(rigidBody, Object::DefaultCollisionAfter, (ObjectSpecialType)obj->specialTypeID, objID); 
 
 		}
 		break;
 	case ObjectSpecialType_Sky: 
 		{
 			float skySize = ((SkyAttributes*)obj)->skySize; 
-			//gameObj = new StaticObject(rigidBody, Object::DefaultCollisionAfter, (ObjectSpecialType)obj->specialTypeID, objID++); 
+			//gameObj = new StaticObject(rigidBody, Object::DefaultCollisionAfter, (ObjectSpecialType)obj->specialTypeID, objID); 
 		}
 		break;
 	case ObjectSpecialType_World: 
@@ -44,28 +44,28 @@ Object* Level::createGameObj(ObjectHeader* obj, ICustomBody* rigidBody)
 			float worldSize = ((WorldAttributes*)obj)->worldSize; 
 			float atmosphereSize = ((WorldAttributes*)obj)->atmoSphereSize; 
 
-			gameObj = new StaticObject(rigidBody, Object::DefaultCollisionAfter, (ObjectSpecialType)obj->specialTypeID, objID++); 
+			gameObj = new StaticObject(rigidBody, Object::DefaultCollisionAfter, (ObjectSpecialType)obj->specialTypeID, objID); 
 		}
 		break;
 	case ObjectSpecialType_Building: 
 		{
-			gameObj = new StaticObject(rigidBody, Object::DefaultCollisionAfter, (ObjectSpecialType)obj->specialTypeID, objID++); 
+			gameObj = new StaticObject(rigidBody, Object::DefaultCollisionAfter, (ObjectSpecialType)obj->specialTypeID, objID); 
 		}
 	case ObjectSpecialType_Stone: 
 		{
-			gameObj = new DynamicObject(rigidBody, Object::DefaultCollisionAfter, (ObjectSpecialType)obj->specialTypeID, objID++);
+			gameObj = new DynamicObject(rigidBody, Object::DefaultCollisionAfter, (ObjectSpecialType)obj->specialTypeID, objID);
 		}
 		break;
 	case ObjectSpecialType_StandardBox: 
 		{
-			gameObj = new DynamicObject(rigidBody, Object::DefaultCollisionAfter, (ObjectSpecialType)obj->specialTypeID, objID++);
+			gameObj = new DynamicObject(rigidBody, Object::DefaultCollisionAfter, (ObjectSpecialType)obj->specialTypeID, objID);
 		}
 		break;
 	case ObjectSpecialType_RedExplosiveBox: 
 		{
-			int dmg = 50; 
+			Oyster::Math::Float dmg = 50; 
 			Oyster::Math::Float force = 50; 
-			int radie = 50; 
+			Oyster::Math::Float radie = 50; 
 			gameObj = new ExplosiveCrate(rigidBody, (ObjectSpecialType)obj->specialTypeID, objID++, dmg, force, radie);
 		}
 		break;
@@ -75,24 +75,24 @@ Object* Level::createGameObj(ObjectHeader* obj, ICustomBody* rigidBody)
 	//	break;
 	case ObjectSpecialType_SpikeBox: 
 		{
-			gameObj = new DynamicObject(rigidBody, Object::DefaultCollisionAfter, (ObjectSpecialType)obj->specialTypeID, objID++);
+			gameObj = new DynamicObject(rigidBody, Object::DefaultCollisionAfter, (ObjectSpecialType)obj->specialTypeID, objID);
 		}
 		break;
 	case ObjectSpecialType_Spike: 
 		{
-			gameObj = new DynamicObject(rigidBody, Object::DefaultCollisionAfter, (ObjectSpecialType)obj->specialTypeID, objID++);
+			gameObj = new DynamicObject(rigidBody, Object::DefaultCollisionAfter, (ObjectSpecialType)obj->specialTypeID, objID);
 		}
 		break;
 	case ObjectSpecialType_CrystalFormation: 
 		{
 			int dmg = 50; 
 			//gameObj = new Crystal(rigidBody);
-			gameObj = new StaticObject(rigidBody, Object::DefaultCollisionAfter, (ObjectSpecialType)obj->specialTypeID, objID++); 
+			gameObj = new StaticObject(rigidBody, Object::DefaultCollisionAfter, (ObjectSpecialType)obj->specialTypeID, objID); 
 		}
 		break;
 	case ObjectSpecialType_CrystalShard: 
 		{
-			gameObj = new DynamicObject(rigidBody, Object::DefaultCollisionAfter, (ObjectSpecialType)obj->specialTypeID, objID++);
+			gameObj = new DynamicObject(rigidBody, Object::DefaultCollisionAfter, (ObjectSpecialType)obj->specialTypeID, objID);
 		}
 		break;
 	case ObjectSpecialType_JumpPad: 
@@ -100,13 +100,13 @@ Object* Level::createGameObj(ObjectHeader* obj, ICustomBody* rigidBody)
 			float power = 500; //((JumpPadAttributes*)obj)->power; 
 			Oyster::Math::Float3 dir = ((JumpPadAttributes*)obj)->direction; 
 			Oyster::Math::Float3 pushForce = dir * power; 
-			gameObj = new JumpPad(rigidBody, (ObjectSpecialType)obj->specialTypeID, objID++ , pushForce);
+			gameObj = new JumpPad(rigidBody, (ObjectSpecialType)obj->specialTypeID, objID , pushForce);
 		}
 		break;
 	case ObjectSpecialType_Portal: 
 		{
 			Oyster::Math::Float3 destination = ((PortalAttributes*)obj)->destination; 
-			gameObj = new Portal(rigidBody, (ObjectSpecialType)obj->specialTypeID, objID++, destination);
+			gameObj = new Portal(rigidBody, (ObjectSpecialType)obj->specialTypeID, objID, destination);
 		}
 		break;
 	//case ObjectSpecialType_SpawnPoint: 
@@ -122,12 +122,12 @@ Object* Level::createGameObj(ObjectHeader* obj, ICustomBody* rigidBody)
 		break;
 	case ObjectSpecialType_Generic:
 		{
-			gameObj = new StaticObject(rigidBody, Object::DefaultCollisionAfter, (ObjectSpecialType)obj->specialTypeID, objID++); 
+			gameObj = new StaticObject(rigidBody, Object::DefaultCollisionAfter, (ObjectSpecialType)obj->specialTypeID, objID); 
 		}
 		break;
 	default:
 		{
-			gameObj = new StaticObject(rigidBody, Object::DefaultCollisionAfter, (ObjectSpecialType)obj->specialTypeID, objID++); 
+			gameObj = new StaticObject(rigidBody, Object::DefaultCollisionAfter, (ObjectSpecialType)obj->specialTypeID, objID); 
 		}
 		break;
 	}
@@ -197,18 +197,23 @@ ICustomBody* Level::InitRigidBodySphere( const ObjectHeader* obj)
 	rigidBody = API::Instance().AddCollisionSphere( rigidBodyRadius , rigidWorldRotation , rigidWorldPos , rigidBodyMass, obj->boundingVolume.sphere.restitutionCoeff , obj->boundingVolume.sphere.frictionCoeffStatic , obj->boundingVolume.sphere.frictionCoeffDynamic);
 	return rigidBody;
 }
-void Level::InitiateLevel(std::string levelPath)
+bool Level::InitiateLevel(std::wstring levelPath)
 {
 	LevelLoader ll; 
+	ll.SetFolderPath(L"..\\Content\\Worlds\\");
 	std::vector<Utility::DynamicMemory::SmartPointer<ObjectTypeHeader>> objects; 
 	objects = ll.LoadLevel(levelPath);
 
+	if(objects.size() == 0)
+		return false;
+
 	API::Instance().SetGravityPoint(Oyster::Math3D::Float3(0,0,0));
 	API::Instance().SetGravity(200);
 	int objCount = objects.size();
 
 	for (int i = 0; i < objCount; i++)
 	{
+		++this->objID;
 		ObjectTypeHeader* obj = objects.at(i);
 		switch (obj->typeID)
 		{
@@ -225,13 +230,10 @@ void Level::InitiateLevel(std::string levelPath)
 				staticObjData->ModelFile;
 
 				ICustomBody* rigidBody_Static = NULL;	
-				if((ObjectSpecialType)staticObjData->specialTypeID == ObjectSpecialType_Sky)
-				{
 
-				}
+				// HACK: untill the world is right in lvl format
 				if((ObjectSpecialType)staticObjData->specialTypeID == ObjectSpecialType_World)
 				{
-				
 					Oyster::Math::Float3 rigidWorldPos;
 					Oyster::Math::Float4 rigidWorldRotation;
 					float rigidBodyMass;
@@ -245,9 +247,8 @@ void Level::InitiateLevel(std::string levelPath)
 					
 					rigidWorldRotation = Oyster::Math::Float4(0,0,0,1); 
 
-
 					//mass scaled
-					rigidBodyMass = 100;
+					rigidBodyMass = 0;
 
 					//Radius scaled
 					rigidBodyRadius = 150;
@@ -332,8 +333,9 @@ void Level::InitiateLevel(std::string levelPath)
 			break;
 		}
 	}
+	return true;
 }
-void Level::InitiateLevel(float radius)
+bool Level::InitiateLevel(float radius)
 {
 	API::Instance().SetGravityPoint(Oyster::Math3D::Float3(0,0,0));
 	API::Instance().SetGravity(200);
@@ -353,7 +355,7 @@ void Level::InitiateLevel(float radius)
 	int offset = 0;
 	for(int i =0; i< nrOfBoxex; i ++)
 	{
-		rigidBody_TestBox = API::Instance().AddCollisionBox(Oyster::Math::Float3(0.5f, 0.5f, 0.5f), Oyster::Math::Float4(0, 0, 0, 1), Oyster::Math::Float3(0, 605 + i*5, 10), 5, 0.5f, 0.8f, 0.6f);
+		rigidBody_TestBox = API::Instance().AddCollisionBox(Oyster::Math::Float3(0.5f, 0.5f, 0.5f), Oyster::Math::Float4(0.0f, 0.0f, 0.0f, 1.0f), Oyster::Math::Float3(0.0f, 605.0f + i*5.0f, 10.0f), 5.0f, 0.5f, 0.8f, 0.6f);
 
 		this->dynamicObjects.Push(new DynamicObject(rigidBody_TestBox, Object::DefaultCollisionAfter, ObjectSpecialType_StandardBox, idCount++));
 	}
@@ -385,17 +387,18 @@ void Level::InitiateLevel(float radius)
 	}*/
 	
 	// add crystal
-	ICustomBody* rigidBody_Crystal = API::Instance().AddCollisionBox(Oyster::Math::Float3(0.5f, 0.5f, 0.5f), Oyster::Math::Float4(0, 0, 0, 1), Oyster::Math::Float3(10, 605, 0), 5, 0.5f, 0.8f, 0.6f);
+	ICustomBody* rigidBody_Crystal = API::Instance().AddCollisionBox(Oyster::Math::Float3(0.5f, 0.5f, 0.5f), Oyster::Math::Float4(0.0f, 0.0f, 0.0f, 1.0f), Oyster::Math::Float3(10.0f, 605.0f, 0.0f), 5.0f, 0.5f, 0.8f, 0.6f);
 	this->dynamicObjects.Push(new DynamicObject(rigidBody_Crystal, Object::DefaultCollisionAfter, ObjectSpecialType_StandardBox, idCount++));
 
 	// add house
-	ICustomBody* rigidBody_House =API::Instance().AddCollisionBox(Oyster::Math::Float3(20, 20, 20), Oyster::Math::Float4(0, 0, 0, 1), Oyster::Math::Float3(-50, 590, 0), 0, 0.5f, 0.8f, 0.6f);
+	ICustomBody* rigidBody_House =API::Instance().AddCollisionBox(Oyster::Math::Float3(20.0f, 20.0f, 20.0f), Oyster::Math::Float4(0.0f, 0.0f, 0.0f, 1.0f), Oyster::Math::Float3(-50.0f, 590.0f, 0.0f), 0.0f, 0.5f, 0.8f, 0.6f);
 	this->staticObjects.Push(new StaticObject(rigidBody_House, Object::DefaultCollisionAfter, ObjectSpecialType_Generic, idCount++));
 
 	// add jumppad
 
-	ICustomBody* rigidBody_Jumppad = API::Instance().AddCollisionBox(Oyster::Math::Float3(1, 1, 1), Oyster::Math::Float4(0, 0, 0, 1), Oyster::Math::Float3(4, 600.3, 0), 5, 0.5f, 0.8f, 0.6f);
+	ICustomBody* rigidBody_Jumppad = API::Instance().AddCollisionBox(Oyster::Math::Float3(1.0f, 1.0f, 1.0f), Oyster::Math::Float4(0.0f, 0.0f, 0.0f, 1.0f), Oyster::Math::Float3(4.0f, 600.3f, 0.0f), 5.0f, 0.5f, 0.8f, 0.6f);
 	this->staticObjects.Push(new JumpPad(rigidBody_Jumppad, ObjectSpecialType_JumpPad,idCount++ ,Oyster::Math::Float3(0,2000,0)));
+	return true;
 }
 
 void Level::AddPlayerToTeam(Player *player, int teamID)
@@ -419,7 +422,7 @@ int Level::getNrOfDynamicObj()
 }
 Object* Level::GetObj( int ID) const
 {
-	for (int i = 0; i < this->dynamicObjects.Size(); i++)
+	for (int i = 0; i < (int)this->dynamicObjects.Size(); i++)
 	{
 		if(this->dynamicObjects[i]->GetID() == ID)
 			return this->dynamicObjects[i];

Code/Game/GameLogic/Level.h

@@ -30,8 +30,8 @@ namespace GameLogic
 		* Initiates a level for players to play on
 		* @param levelPath: Path to a file that contains all information on the level
 		********************************************************/
-		void InitiateLevel(std::string levelPath);
+		bool InitiateLevel(std::wstring levelPath);
-		void InitiateLevel(float radius);
+		bool InitiateLevel(float radius);
 		Oyster::Physics::ICustomBody* InitRigidBodyCube( const ObjectHeader* obj);
 		Oyster::Physics::ICustomBody* InitRigidBodySphere( const ObjectHeader* obj);
 

Code/Game/GameLogic/LevelLoader/LevelLoader.cpp

@@ -11,17 +11,17 @@ using namespace GameLogic::LevelFileLoader;
 struct LevelLoader::PrivData
 {
 	LevelParser parser;
-	std::string folderPath;
+	std::wstring folderPath;
 };
 
 LevelLoader::LevelLoader()
 	: pData(new PrivData)
 {
 	//standard path
-	pData->folderPath = "";
+	pData->folderPath = L"";
 }
 
-LevelLoader::LevelLoader(std::string folderPath)
+LevelLoader::LevelLoader(std::wstring folderPath)
 	: pData(new PrivData)
 {
 	pData->folderPath = folderPath;
@@ -31,22 +31,22 @@ LevelLoader::~LevelLoader()
 {
 }
 
-std::vector<Utility::DynamicMemory::SmartPointer<ObjectTypeHeader>> LevelLoader::LoadLevel(std::string fileName)
+std::vector<Utility::DynamicMemory::SmartPointer<ObjectTypeHeader>> LevelLoader::LoadLevel(std::wstring fileName)
 {
 	return pData->parser.Parse(pData->folderPath + fileName);
 }
 
-LevelMetaData LevelLoader::LoadLevelHeader(std::string fileName)
+LevelMetaData LevelLoader::LoadLevelHeader(std::wstring fileName)
 {
 	return pData->parser.ParseHeader(pData->folderPath + fileName);
 }
 
-std::string LevelLoader::GetFolderPath()
+std::wstring LevelLoader::GetFolderPath()
 {
 	return this->pData->folderPath;
 }
 
-void LevelLoader::SetFolderPath(std::string folderPath)
+void LevelLoader::SetFolderPath(std::wstring folderPath)
 {
-
+	this->pData->folderPath = folderPath;
 }

Code/Game/GameLogic/LevelLoader/LevelLoader.h

@@ -20,7 +20,7 @@ namespace GameLogic
 		/***********************************************************
 			* Lets you set the standard folderpath for the levels
 			********************************************************/
-		LevelLoader(std::string folderPath);
+		LevelLoader(std::wstring folderPath);
 		~LevelLoader();
 
 		/********************************************************
@@ -28,24 +28,24 @@ namespace GameLogic
 			* @param fileName: Path/name to the level-file that you want to load.
 			* @return: Returns all structs with objects and information about the level.
 			********************************************************/
-		std::vector<Utility::DynamicMemory::SmartPointer<ObjectTypeHeader>> LoadLevel(std::string fileName);
+		std::vector<Utility::DynamicMemory::SmartPointer<ObjectTypeHeader>> LoadLevel(std::wstring fileName);
 
 		/********************************************************
 			* Just for fast access for the meta information about the level.
 			* @param fileName: Path to the level-file that you want to load.
 			* @return: Returns the meta information about the level.
 			********************************************************/
-		LevelMetaData LoadLevelHeader(std::string fileName); //.
+		LevelMetaData LoadLevelHeader(std::wstring fileName); //.
 
 		/***********************************************************
 			* @return: Returns the current standard folder path
 			********************************************************/
-		std::string GetFolderPath();
+		std::wstring GetFolderPath();
 
 		/***********************************************************
 			* Sets the standard folder path
 			********************************************************/
-		void SetFolderPath(std::string folderPath);
+		void SetFolderPath(std::wstring folderPath);
 
 	private:
 		struct PrivData;

Code/Game/GameLogic/LevelLoader/LevelParser.cpp

@@ -20,7 +20,7 @@ LevelParser::~LevelParser()
 {
 }
 
-std::vector<SmartPointer<ObjectTypeHeader>> LevelParser::Parse(std::string filename)
+std::vector<SmartPointer<ObjectTypeHeader>> LevelParser::Parse(std::wstring filename)
 {
 	int bufferSize = 0;
 	int counter = 0;
@@ -32,6 +32,12 @@ std::vector<SmartPointer<ObjectTypeHeader>> LevelParser::Parse(std::string filen
 	Loader loader;
 	char* buffer = (char*)loader.LoadFile(filename.c_str(), bufferSize);
 
+	// Check if file was loaded, else return empty vector
+	if(!buffer)
+	{
+		return std::vector<SmartPointer<ObjectTypeHeader>>();
+	}
+
 	//Read format version
 	LevelLoaderInternal::FormatVersion levelFormatVersion;
 	ParseObject(&buffer[counter], &levelFormatVersion, sizeof(levelFormatVersion));
@@ -215,7 +221,7 @@ std::vector<SmartPointer<ObjectTypeHeader>> LevelParser::Parse(std::string filen
 }
 
 //för meta information om leveln.
-LevelMetaData LevelParser::ParseHeader(std::string filename)
+LevelMetaData LevelParser::ParseHeader(std::wstring filename)
 {
 	int bufferSize = 0;
 	int counter = 0;

Code/Game/GameLogic/LevelLoader/LevelParser.h

@@ -17,10 +17,10 @@ namespace GameLogic
 			~LevelParser();
 
 			//
-			std::vector<Utility::DynamicMemory::SmartPointer<ObjectTypeHeader>> Parse(std::string filename);
+			std::vector<Utility::DynamicMemory::SmartPointer<ObjectTypeHeader>> Parse(std::wstring filename);
 
 			//
-			LevelMetaData ParseHeader(std::string filename);
+			LevelMetaData ParseHeader(std::wstring filename);
 
 		private:
 			LevelLoaderInternal::FormatVersion formatVersion;

Code/Game/GameLogic/LevelLoader/Loader.cpp

@@ -9,13 +9,13 @@ using namespace GameLogic::LevelFileLoader;
 using namespace Oyster::Resource;
 using namespace std;
 
-char* Loader::LoadFile(std::string fileName, int &size)
+char* Loader::LoadFile(std::wstring fileName, int &size)
 {
 	//convert from string to wstring
-	std::wstring temp(fileName.begin(), fileName.end());
+	//std::wstring temp(fileName.begin(), fileName.end());
 
 	//convert from wstring to wchar then loads the file
-	char* buffer = (char*)OysterResource::LoadResource(temp.c_str(), Oyster::Resource::ResourceType::ResourceType_Byte_Raw, -1 , false);
+	char* buffer = (char*)OysterResource::LoadResource(fileName.c_str(), Oyster::Resource::ResourceType::ResourceType_Byte_Raw, -1 , false);
 
 	size = OysterResource::GetResourceSize(buffer);
 	return buffer;

Code/Game/GameLogic/LevelLoader/Loader.h

@@ -17,7 +17,7 @@ namespace GameLogic
 		public:
 			Loader (){};
 			~Loader(){};
-			char* LoadFile(std::string fileName, int &size); 
+			char* LoadFile(std::wstring fileName, int &size); 
 
 			//TODO:
 			//Add functionality to load physicsObjects (hitboxes)

Code/Game/GameLogic/LevelLoader/ObjectDefines.h

@@ -52,6 +52,7 @@ namespace GameLogic
 		CollisionGeometryType_Box,
 		CollisionGeometryType_Sphere,
 		CollisionGeometryType_Cylinder,
+		CollisionGeometryType_TriangleMesh,
 
 		CollisionGeometryType_Count,
 		CollisionGeometryType_Unknown = -1
@@ -161,6 +162,12 @@ namespace GameLogic
 			float radius;
 		};
 
+		struct BoundingVolumeTriangleMesh : public BoundingVolumeBase
+		{
+			//Null terminated
+			wchar_t* filename;
+		};
+
 		struct BoundingVolume
 		{
 			CollisionGeometryType geoType;
@@ -169,7 +176,16 @@ namespace GameLogic
 				LevelLoaderInternal::BoundingVolumeBox box;
 				LevelLoaderInternal::BoundingVolumeSphere sphere;
 				LevelLoaderInternal::BoundingVolumeCylinder cylinder;
+				LevelLoaderInternal::BoundingVolumeTriangleMesh triangleMesh;
 			};
+
+			virtual ~BoundingVolume()
+			{
+				if(geoType == CollisionGeometryType_TriangleMesh)
+				{
+					delete[] triangleMesh.filename;
+				}
+			}
 		};
 
 	}

Code/Game/GameLogic/LevelLoader/ParseFunctions.cpp

@@ -5,6 +5,7 @@
 #include "ParseFunctions.h"
 #include "Packing/Packing.h"
 #include "Loader.h"
+#include "Utilities.h"
 #include <string>
 
 using namespace Oyster::Packing;
@@ -119,7 +120,7 @@ namespace GameLogic
 
 			int temp;
 
-			for(int i = 0; i < tempSize; i++)
+			for(int i = 0; i < (int)tempSize; i++)
 			{
 				memcpy(&temp, &buffer[start], 4);
 				start += 4;
@@ -149,7 +150,7 @@ namespace GameLogic
 			//Läs in filen.
 			int fileLength = 0;
 			Loader loader;
-			char* buf = loader.LoadFile("../Content/Worlds/cgf/"+ fileName, fileLength);
+			char* buf = loader.LoadFile(L"../Content/Worlds/cgf/" + Utility::String::StringToWstring(fileName, wstring()), fileLength);
 
 			start = 0;
 			LevelLoaderInternal::FormatVersion version;
@@ -175,6 +176,17 @@ namespace GameLogic
 				start += sizeof(volume.cylinder);
 				break;
 
+			case CollisionGeometryType_TriangleMesh:
+				//Get string size
+				memcpy(&tempSize, &buf[start], sizeof(tempSize));
+				start += sizeof(tempSize);
+
+				//Get actual string
+				volume.triangleMesh.filename = new wchar_t[tempSize+1];
+				memcpy(volume.triangleMesh.filename, &buf[start], tempSize);
+				volume.triangleMesh.filename[tempSize] = '\0';
+				break;
+
 			default:
 				break;
 			}

Code/Game/GameLogic/Player.cpp

@@ -90,7 +90,7 @@ void Player::BeginFrame()
 	forwardDir.Normalize();
 	rightDir.Normalize();
 	Oyster::Math::Float3 walkDirection = Oyster::Math::Float3(0.0, 0.0, 0.0);
-	Oyster::Math::Float walkSpeed = this->moveSpeed*0.2;
+	Oyster::Math::Float walkSpeed = this->moveSpeed*0.2f;
 
 	if (key_forward > 0.001)
 	{
@@ -122,7 +122,7 @@ void Player::BeginFrame()
 	if (key_forward <= 0.001 && key_backward <= 0.001 && key_strafeRight <= 0.001 && key_strafeLeft <= 0.001 && key_jump <= 0.001 && this->rigidBody->GetLambda() < 0.7f)
 	{
 		/* Dampen when on the ground and not being moved by the player */
-		linearVelocity *= 0.2;
+		linearVelocity *= 0.2f;
 		this->rigidBody->SetLinearVelocity (linearVelocity);
 	} 
 	else 

Code/Game/GameProtocols/LobbyProtocols.h

@@ -41,61 +41,41 @@ namespace GameLogic
 
 	struct Protocol_LobbyCreateGame :public Oyster::Network::CustomProtocolObject
 	{
-		short clientID; // The unuiqe id reprsenting a specific client
+		char majorVersion;
-		std::string modelName;
+		char minorVersion;
-		float worldMatrix[16];
+		std::string mapName;
 		
 		Protocol_LobbyCreateGame()
 		{
-			int c = 0;
+			this->protocol[0].value = protocol_Lobby_CreateGame;
-			this->protocol[c].value = protocol_Lobby_CreateGame;
+			this->protocol[0].type = Oyster::Network::NetAttributeType_Short;
-			this->protocol[c++].type = Oyster::Network::NetAttributeType_Short;
+			this->protocol[1].type = Oyster::Network::NetAttributeType_Char;
-
+			this->protocol[2].type = Oyster::Network::NetAttributeType_Char;
-			this->protocol[c++].type = Oyster::Network::NetAttributeType_Short;
+			this->protocol[3].type = Oyster::Network::NetAttributeType_CharArray;
-			for (int i = 0; i <= 16; i++)
-			{
-				this->protocol[c++].type = Oyster::Network::NetAttributeType_Float;
-			}
-			this->protocol[c++].type = Oyster::Network::NetAttributeType_CharArray;
 		}
-		Protocol_LobbyCreateGame(short _clientID, std::string name, float world[16])
+		Protocol_LobbyCreateGame(char majorVersion, char minorVersion, std::string name)
 		{
-			int c = 0;
+			this->protocol[0].value = protocol_Lobby_CreateGame;
-			this->protocol[c].value = protocol_Lobby_CreateGame;
+			this->protocol[0].type = Oyster::Network::NetAttributeType_Short;
-			this->protocol[c++].type = Oyster::Network::NetAttributeType_Short;
+			this->protocol[1].type = Oyster::Network::NetAttributeType_Char;
+			this->protocol[2].type = Oyster::Network::NetAttributeType_Char;
+			this->protocol[3].type = Oyster::Network::NetAttributeType_CharArray;
 
-			this->protocol[c++].type = Oyster::Network::NetAttributeType_Short;
+			this->majorVersion = majorVersion;
-			for (int i = 0; i <= 16; i++)
+			this->minorVersion = minorVersion;
-			{
+			this->mapName = name;
-				this->protocol[c++].type = Oyster::Network::NetAttributeType_Float;
-			}
-
-			this->protocol[c++].type = Oyster::Network::NetAttributeType_CharArray;
-
-			clientID = _clientID;
-			modelName = name;
-			memcpy(&worldMatrix[0], &world[0], sizeof(float) * 16);
 		}
 		Protocol_LobbyCreateGame(Oyster::Network::CustomNetProtocol o)
 		{
-			int c = 1;
+			this->majorVersion = o[1].value.netChar;
-			clientID = o[c++].value.netInt;
+			this->minorVersion = o[2].value.netChar;
-			for (int i = 0; i <= 16; i++)
+			this->mapName.assign(o[3].value.netCharPtr);
-			{
-				this->worldMatrix[i] = o[c++].value.netFloat;
-			}
-			modelName.assign(o[c++].value.netCharPtr);
 		}
 		Oyster::Network::CustomNetProtocol GetProtocol() override
 		{
-			int c = 1;
+			protocol[1].value = this->majorVersion;
-			protocol[c++].value = clientID;
+			protocol[2].value = this->minorVersion;
-			
+			protocol.Set(3, this->mapName);
-			for (int i = 0; i <= 16; i++)
-			{
-				this->protocol[c++].value = this->worldMatrix[i];
-			}
-			protocol.Set(c++, this->modelName);
 			return protocol;
 		}
 		

Code/Game/GameServer/GameClient.h

@@ -5,6 +5,7 @@
 #define DANBIASSERVER_CLIENT_OBJECT_H
 
 #include <NetworkClient.h>
+#include <NetworkSession.h>
 #include <PostBox\PostBox.h>
 #include <GameAPI.h>
 #include <Utilities.h>
@@ -17,27 +18,59 @@ namespace DanBias
 	class GameClient
 	{
 	public:
-		GameClient(Utility::DynamicMemory::SmartPointer<Oyster::Network::NetworkClient> client, GameLogic::IPlayerData* player);
+		enum ClientState
+		{
+			ClientState_CreatingGame,
+			ClientState_Ready,
+		};
+
+	public:
+		GameClient(Utility::DynamicMemory::SmartPointer<Oyster::Network::NetworkClient> nwClient);
 		virtual~GameClient();
 
-		GameLogic::IPlayerData* GetPlayer();
+		inline bool operator==(const GameLogic::IPlayerData* c)				{ return (this->player) ? (c->GetID() == this->player->GetID()) : false ; }
-		GameLogic::IPlayerData* ReleasePlayer();
+		inline bool operator==(const Oyster::Network::NetworkClient* c)		{ return (c->GetID() == this->client->GetID()); }
-		Utility::DynamicMemory::SmartPointer<Oyster::Network::NetworkClient> GetClient();
-		Utility::DynamicMemory::SmartPointer<Oyster::Network::NetworkClient> ReleaseClient();
 
-		float GetSinceLastResponse() const;
+		inline bool Equals(const GameLogic::IPlayerData* c)					{ return (this->player) ? (c->GetID() == this->player->GetID()) : false ; }
-		bool IsReady() const;
+		inline bool Equals(const Oyster::Network::NetworkClient* c)			{ return (c->GetID() == this->client->GetID()); }
-		bool Equals(const Oyster::Network::NetworkClient* c);
 
+		inline float					GetSinceLastResponse()		const { return this->secondsSinceLastResponse; }
+		inline std::wstring				GetAlias()					const { return this->alias; }
+		inline std::wstring				GetCharacter()				const { return this->character; }
+		inline bool						IsReady()					const { return this->isReady; }
+		inline GameLogic::IPlayerData*	GetPlayer()					const { return this->player; }
+		Oyster::Network::NetClient		GetClient()					const { return this->client; }
+		ClientState						GetState()					const { return this->state; }
+
+
+		void SetPlayer(GameLogic::IPlayerData* player);
 		void SetReadyState(bool isReady);
+		void SetAlias(std::wstring alias);
+		void SetCharacter(std::wstring character);
 		void SetSinceLastResponse(float seconds);
+		void SetState(ClientState state);
+
+		GameLogic::IPlayerData* ReleasePlayer();
+		Oyster::Network::NetClient ReleaseClient();
+
+		//NetworkSpecific
+		void SetOwner(Oyster::Network::NetworkSession* owner);
+		void UpdateClient();
 
 	private:
 		GameLogic::IPlayerData* player;
-		Utility::DynamicMemory::SmartPointer<Oyster::Network::NetworkClient> client;
+		Oyster::Network::NetClient client;
+		
 		bool isReady;
 		float secondsSinceLastResponse;
-	};
 
+		std::wstring alias;
+		std::wstring character;
+
+		ClientState state;
+	};
 }//End namespace DanBias
+
+typedef Utility::DynamicMemory::SmartPointer<DanBias::GameClient> gClient;
+
 #endif // !DANBIASSERVER_CLIENT_OBJECT_H

Code/Game/GameServer/GameLobby.h

@@ -15,11 +15,18 @@ namespace DanBias
 {
 	struct LobbyLevelData
 	{
-		int mapNumber;
 		int maxClients;
-		int gameMode;
+		int gameTimeInMinutes;
-		int gameTime;
+		std::wstring gameMode;
-		std::string gameName;
+		std::wstring mapName;
+		std::wstring gameName;
+		LobbyLevelData()
+			:	maxClients(10)
+			,	gameTimeInMinutes(10)
+			,	gameMode(L"unknown")
+			,	mapName(L"unknown")
+			,	gameName(L"unknown")
+		{ }
 	};
 	class GameLobby	:public Oyster::Network::NetworkSession
 	{
@@ -31,35 +38,44 @@ namespace DanBias
 
 		void SetGameDesc(const LobbyLevelData& desc);
 		void GetGameDesc(LobbyLevelData& desc);
-		bool StartGameSession();
+		/**
+		*	If param is true, the server will start a game session regardless of clients connected.
+		*/
+		bool StartGameSession( bool forceStart );
+
+		int GetGameSessionClientCount();
 
 	private:
 		void ParseProtocol(Oyster::Network::CustomNetProtocol& p, Oyster::Network::NetworkClient* c);
 
-		void GeneralStatus(GameLogic::Protocol_General_Status& p, Oyster::Network::NetworkClient* c);		//id = protocol_General_Status:
+		void GeneralStatus(GameLogic::Protocol_General_Status& p, Oyster::Network::NetworkClient* c);			//id = protocol_General_Status:
-		void GeneralText(GameLogic::Protocol_General_Text& p, Oyster::Network::NetworkClient* c);			//id = protocol_General_Text:
+		void GeneralText(GameLogic::Protocol_General_Text& p, Oyster::Network::NetworkClient* c);				//id = protocol_General_Text:
-		//void LobbyCreateGame(GameLogic::Protocol_LobbyCreateGame& p, Oyster::Network::NetworkClient* c);	//id = protocol_Lobby_Create:
+		void LobbyStartGame(GameLogic::Protocol_LobbyStartGame& p, Oyster::Network::NetworkClient* c);			//id = protocol_Lobby_Start:
-		void LobbyStartGame(GameLogic::Protocol_LobbyStartGame& p, Oyster::Network::NetworkClient* c);		//id = protocol_Lobby_Start:
+		void LobbyJoin(GameLogic::Protocol_LobbyJoinGame& p, Oyster::Network::NetworkClient* c);				//id = protocol_Lobby_Login:
-		//void LobbyJoin(GameLogic::Protocol_LobbyJoin& p, Oyster::Network::NetworkClient* c);				//id = protocol_Lobby_Join:				
+		void LobbyRefresh(GameLogic::Protocol_LobbyRefresh& p, Oyster::Network::NetworkClient* c);				//id = protocol_Lobby_Refresh:
-		void LobbyLogin(GameLogic::Protocol_LobbyJoinGame& p, Oyster::Network::NetworkClient* c);			//id = protocol_Lobby_Login:
+		void LobbyGameData(GameLogic::Protocol_LobbyGameData& p, Oyster::Network::NetworkClient* c);			//id = protocol_Lobby_GameData:
-		void LobbyRefresh(GameLogic::Protocol_LobbyRefresh& p, Oyster::Network::NetworkClient* c);			//id = protocol_Lobby_Refresh:
+		void LobbyMainData(GameLogic::Protocol_LobbyClientData& p, Oyster::Network::NetworkClient* c);			//id = protocol_Lobby_MainData:
-		void LobbyGameData(GameLogic::Protocol_LobbyGameData& p, Oyster::Network::NetworkClient* c);		//id = protocol_Lobby_GameData:
+		void LobbyReady(GameLogic::Protocol_LobbyClientReadyState& p, Oyster::Network::NetworkClient* c);		//id = protocol_Lobby_ClientReadyState:
-		void LobbyMainData(GameLogic::Protocol_LobbyClientData& p, Oyster::Network::NetworkClient* c);		//id = protocol_Lobby_MainData:
+		void LobbyQuerryGameData(GameLogic::Protocol_QuerryGameType& p, Oyster::Network::NetworkClient* c);		//id = protocol_Lobby_QuerryGameType:
-		void LobbyReady(GameLogic::Protocol_LobbyClientReadyState& p, Oyster::Network::NetworkClient* c);	//id = protocol_Lobby_ClientReadyState:
+
-		void LobbyQuerryGameData(GameLogic::Protocol_QuerryGameType& p, Oyster::Network::NetworkClient* c);	//id = protocol_Lobby_QuerryGameType:
+	private:
+		int FindClient(Oyster::Network::NetworkClient* c);
 
 	private:
 		void ClientEventCallback(Oyster::Network::NetEvent<Oyster::Network::NetworkClient*, Oyster::Network::NetworkClient::ClientEventArgs> e) override;
 		void ClientConnectedEvent(Utility::DynamicMemory::SmartPointer<Oyster::Network::NetworkClient> client) override;
+		void ProcessClients() override;
+		bool Attach(Utility::DynamicMemory::SmartPointer<Oyster::Network::NetworkClient> client) override;
 
 	private:
-		Utility::WinTimer timer;
+		//Utility::WinTimer timer;
-		float refreshFrequency;
+		//float refreshFrequency;
+
 		Utility::DynamicMemory::LinkedList<Oyster::Network::NetworkClient*> readyList;
 		GameSession gameSession;
 		LobbyLevelData description;
 		Utility::DynamicMemory::SmartPointer<DanBias::GameClient> sessionOwner;
-		
+		Utility::DynamicMemory::DynamicArray<Utility::DynamicMemory::SmartPointer<GameClient>> gClients;
 	};
 }//End namespace DanBias
 #endif // !DANBIASGAME_GAMELOBBY_H

Code/Game/GameServer/GameServerAPI.h

@@ -55,16 +55,24 @@ namespace DanBias
 			static void					NotifyWhenClientConnect(ClientConnectedNotify func);
 			static void					NotifyWhenClientDisconnect(ClientDisconnectedNotify func);
 
-			static void					GameSetMapName(const wchar_t* val);
-			static void					GameSetMaxClients(const int& val);
-			static void					GameSetGameMode(const wchar_t* val);
 			static void					GameSetGameTime(const int& val);
-			static int					GameGetMapId();
+			static void					GameSetMaxClients(const int& val);
-			static int					GameGetMaxClients();
+			static void					GameSetGameName(const wchar_t* val);
-			static int					GameGetGameMode();
+			static void					GameSetMapName(const wchar_t* val);
+			static void					GameSetGameMode(const wchar_t* val);
+			
 			static int					GameGetGameTime();
-			static const char*			GameGetGameName();
+			static int					GameGetMaxClients();
-			static bool					GameStart();
+			static const wchar_t*		GameGetGameMode();
+			static const wchar_t*		GameGetGameName();
+			static const wchar_t*		GameGetMapName();
+			static int					GetConnectedClientCount();
+	
+			/*	Starts a game 
+			*	@param forceStart	If forceStart is true, server will start with or without clients. 
+			*	If there are clients not "ready" the will be stareted anyways.
+			*/
+			static bool					GameStart(bool forceStart);
 
 
 		};//End class DanBiasServer

Code/Game/GameServer/GameSession.h

@@ -31,12 +31,12 @@ namespace DanBias
 		*/
 		struct GameDescription
 		{
-			int maxClients;
+			unsigned int maxClients;
-			int mapNumber;
+			std::wstring mapName;
-			int gameMode;
+			std::wstring gameMode;
-			int gameTime;
+			int gameTimeMinutes;
 			Oyster::Network::NetworkSession* owner;
-			Utility::DynamicMemory::DynamicArray<Oyster::Network::NetClient> clients;
+			Utility::DynamicMemory::DynamicArray<Utility::DynamicMemory::SmartPointer<GameClient>> clients;
 		};
 
 	public:
@@ -44,7 +44,7 @@ namespace DanBias
 		virtual~GameSession();
 
 		/** Initiates and creates a game session. */
-		bool Create(GameDescription& desc);
+		bool Create(GameDescription& desc, bool forceStart);
 
 		/** Runs the game session (ie starts the game loop). */
 		void Run();
@@ -52,23 +52,27 @@ namespace DanBias
 		/** Join an existing/running game session 
 		*	@param client The client to attach to the session
 		*/
-		bool Attach(Oyster::Network::NetClient client) override;
+		bool Join(gClient client);
-		void CloseSession( bool dissconnectClients ) override; 
+
+		//void CloseSession( bool dissconnectClients ) override; 
 		
 		inline bool IsCreated() const	{ return this->isCreated; }
 		inline bool IsRunning() const	{ return this->isRunning; }
-		operator bool() { return (this->isCreated && this->isCreated); }
+		operator bool()					{ return (this->isCreated && this->isRunning); }
 
 		//Private member functions
 	private:
-		// TODO: find out what this method does..
+		// Client event callback function
 		void ClientEventCallback(Oyster::Network::NetEvent<Oyster::Network::NetworkClient*, Oyster::Network::NetworkClient::ClientEventArgs> e) override;
+		void ProcessClients() override;
+		bool Send(Oyster::Network::CustomNetProtocol& message) override;
+		bool Send(Oyster::Network::CustomNetProtocol& protocol, int ID) override;
 		
-		//Sends a client to the owner, if obj is NULL then all clients is sent
+		//Sends a client to the owner, if param is NULL then all clients is sent
 		void SendToOwner(DanBias::GameClient* obj);
 		
 		//Derived from IThreadObject
-		void ThreadEntry() override;
+		void ThreadEntry( ) override;
 		bool DoWork	( ) override;
 
 
@@ -98,8 +102,8 @@ namespace DanBias
 
 		//Private member variables
 	private:
-		Utility::DynamicMemory::DynamicArray<Utility::DynamicMemory::SmartPointer<GameClient>> clients;
+		Utility::DynamicMemory::DynamicArray<gClient> gClients;
-		Utility::DynamicMemory::SmartPointer<DanBias::GameClient> sessionOwner;
+		gClient sessionOwner;
 		Oyster::Thread::OysterThread worker;
 		GameLogic::GameAPI& gameInstance;
 		GameLogic::ILevelData *levelData;
@@ -115,6 +119,7 @@ namespace DanBias
 		//TODO: Remove this uggly hax
 		static GameSession* gameSession;
 
+
 	};//End GameSession
 }//End namespace DanBias
 #endif // !DANBIASSERVER_GAME_SESSION_H

Code/Game/GameServer/Implementation/GameClient.cpp

@@ -12,51 +12,27 @@ using namespace DanBias;
 using namespace GameLogic;
 
 
-GameClient::GameClient(SmartPointer<NetworkClient> client, GameLogic::IPlayerData* player)
+GameClient::GameClient(Utility::DynamicMemory::SmartPointer<Oyster::Network::NetworkClient> nwClient)
 {
-	this->client = client;
+	this->client = nwClient;
-	this->player = player;
+	this->player = 0;
 	isReady = false;
+	this->character = L"Unknown";
+	this->alias = L"Unknown";
+	this->secondsSinceLastResponse = 0.0f;
 }
 GameClient::~GameClient()
 {
-	this->client->Disconnect();
 	this->player = 0;
-	isReady = false;
+	this->isReady = false;
+	this->character = L"Unknown";
+	this->alias = L"Unknown";
+	this->secondsSinceLastResponse = 0.0f;
 }
 
-GameLogic::IPlayerData* GameClient::GetPlayer()
+void GameClient::SetPlayer(GameLogic::IPlayerData* player)
 {
-	return this->player;
+	this->player = player;
-}
-GameLogic::IPlayerData* GameClient::ReleasePlayer()
-{
-	GameLogic::IPlayerData *temp = this->player;
-	this->player =  0;
-	return temp;
-}
-SmartPointer<Oyster::Network::NetworkClient> GameClient::GetClient()
-{
-	return this->client;
-}
-SmartPointer<Oyster::Network::NetworkClient> GameClient::ReleaseClient()
-{
-	SmartPointer<Oyster::Network::NetworkClient> temp = this->client;
-	this->client = 0;
-	return temp;
-}
-
-float GameClient::GetSinceLastResponse() const
-{
-	return this->secondsSinceLastResponse;
-}
-bool GameClient::IsReady() const
-{
-	return this->isReady;
-}
-bool GameClient::Equals(const NetworkClient* c)
-{
-	return (c->GetID() == this->client->GetID());
 }
 void GameClient::SetReadyState(bool r)
 {
@@ -66,5 +42,44 @@ void GameClient::SetSinceLastResponse(float s)
 {
 	this->secondsSinceLastResponse = s;
 }
+void GameClient::SetAlias(std::wstring alias)
+{
+	this->alias = alias;
+}
+void GameClient::SetCharacter(std::wstring character)
+{
+	this->character = character;
+}
+void GameClient::SetState(ClientState state)
+{
+	this->state = state;
+}
 
 
+void GameClient::SetOwner(Oyster::Network::NetworkSession* owner)
+{
+	this->client->SetOwner(owner);
+}
+void GameClient::UpdateClient()
+{
+	switch (this->state)
+	{
+		case ClientState_Ready:
+			this->client->Update();
+		break;
+	}
+}
+
+
+IPlayerData* GameClient::ReleasePlayer()
+{
+	IPlayerData* temp = this->player;
+	this->player = 0;
+	return temp;
+}
+NetClient GameClient::ReleaseClient()
+{
+	NetClient temp = this->client;
+	this->client = 0;
+	return temp;
+}

Code/Game/GameServer/Implementation/GameLobby.cpp

@@ -14,10 +14,10 @@ using namespace GameLogic;
 using namespace DanBias;
 
 GameLobby::GameLobby()
-{   }
+{  }
 GameLobby::~GameLobby()
 {  
-	this->clients.Clear();
+	this->gClients.Clear();
 }
 void GameLobby::Release()
 {  
@@ -26,62 +26,86 @@ void GameLobby::Release()
 }
 void GameLobby::Update()
 {
-	for (unsigned int i = 0; i < this->clients.Size(); i++)
+	for (unsigned int i = 0; i < this->gClients.Size(); i++)
 	{
-		if(this->clients[i])
+		if(this->gClients[i])
 		{
-			this->clients[i]->Update();
+			this->gClients[i]->GetClient()->Update();
 		}
 	}
 }
 void GameLobby::SetGameDesc(const LobbyLevelData& desc)
 {
 	this->description.gameMode = desc.gameMode;
-	this->description.gameTime = desc.gameTime;
+	this->description.gameName = desc.gameName;
-	this->description.mapNumber = desc.mapNumber;
+	this->description.mapName = desc.mapName;
+	this->description.gameTimeInMinutes = desc.gameTimeInMinutes;
 	this->description.maxClients = desc.maxClients;
+	
+	if(this->gClients.Size() > (unsigned int)desc.maxClients)
+	{
+		//Kick overflow
+		for (unsigned int i = (unsigned int)desc.maxClients - 1; i < this->gClients.Size(); i++)
+		{
+			if(this->gClients[i])
+			{
+				this->gClients[i]->GetClient()->Disconnect();
+			}
+		}
+	}
+	this->gClients.Resize((unsigned int)desc.maxClients);
+
 }
 void GameLobby::GetGameDesc(LobbyLevelData& desc)
 {
-	desc.gameMode = this->description.gameMode;
+	desc.gameTimeInMinutes = this->description.gameTimeInMinutes;		
-	desc.gameTime = this->description.gameTime;		
-	desc.mapNumber = this->description.mapNumber;		
 	desc.maxClients = this->description.maxClients;	
+	desc.mapName = this->description.mapName;		
+	desc.gameName = this->description.gameName;	
+	desc.gameMode = this->description.gameMode;
+	
 }
-bool GameLobby::StartGameSession(  )
+bool GameLobby::StartGameSession( bool forceStart )
 {
-//Check if all clients is ready
+//Check if all clients is ready, in not force start
-	if(this->GetClientCount() && this->GetClientCount() == this->readyList.Size())
+	if(!forceStart)
 	{
-		GameSession::GameDescription desc;
+		if(!this->GetClientCount())
-			desc.maxClients = this->description.maxClients;
+		{ /*None connected*/ return false;}
-			desc.gameMode = this->description.gameMode;
+		else if( this->GetClientCount() != this->readyList.Size() )
-			desc.gameTime = this->description.gameTime;
+		{ /*Not enough connected*/ return false; }
-			desc.mapNumber = this->description.mapNumber;
-			desc.owner = this;
-			desc.clients = this->clients;
-
-		if(desc.gameTime == 0.0f)
-			desc.gameTime = (int)(60.0f * 10.0f); //note: should be fetched from somewhere.
-
-		if(desc.maxClients == 0)
-			desc.maxClients = 10; //note: should be fetched somewhere else..
-
-		this->clients.Clear();	//Remove clients from lobby list
-		
-		if(this->gameSession.Create(desc))
-		{
-			this->gameSession.Run();
-
-			return true;
-		}
 	}
-	else
+
+	GameSession::GameDescription desc;
+		desc.maxClients = this->description.maxClients;
+		desc.gameMode = this->description.gameMode;
+		desc.gameTimeMinutes = this->description.gameTimeInMinutes;
+		desc.mapName = this->description.mapName;
+		desc.owner = this;
+		desc.clients = this->gClients;
+
+	if(desc.gameTimeMinutes == 0)
+		desc.gameTimeMinutes = 10; //note: should be fetched from somewhere.
+
+	if(desc.maxClients == 0)
+		desc.maxClients = 10; //note: should be fetched somewhere else..
+
+	this->gClients.Clear();	//Remove clients from lobby list
+		
+	if(this->gameSession.Create(desc, forceStart))
 	{
-		//?
+		this->gameSession.Run();
+
+		return true;
 	}
+	
+	
 	return false;
 }
+int GameLobby::GetGameSessionClientCount()
+{
+	return this->gameSession.GetClientCount();
+}
 
 void GameLobby::ClientEventCallback(NetEvent<NetworkClient*, NetworkClient::ClientEventArgs> e)
 {
@@ -95,9 +119,9 @@ void GameLobby::ClientEventCallback(NetEvent<NetworkClient*, NetworkClient::Clie
 		break;
 		case NetworkClient::ClientEventArgs::EventType_ProtocolFailedToSend:
 			printf("\t(%i : %s) - EventType_ProtocolFailedToSend\n", e.sender->GetID(), e.sender->GetIpAddress().c_str());	
-			e.sender->Disconnect();
+			//e.sender->Disconnect();
-			this->readyList.Remove(e.sender);
+			//this->readyList.Remove(e.sender);
-			this->clients.Remove(e.sender);
+			//this->gClients.Remove(e.sender);
 		break;
 		case NetworkClient::ClientEventArgs::EventType_ProtocolRecieved:
 			printf("\t(%i : %s) - EventType_ProtocolRecieved\n", e.sender->GetID(), e.sender->GetIpAddress().c_str());	
@@ -111,21 +135,30 @@ void GameLobby::ClientConnectedEvent(Utility::DynamicMemory::SmartPointer<Oyster
 
 	if(this->gameSession)
 	{
-		Attach(client);
+		if(!this->Attach(client))
+		{
+			client->Disconnect();
+		}
 	}
 	else
 	{
-		Attach(client);
+		if(!this->Attach(client))
+		{
+			//Send message that lobby full
+			client->Disconnect();
+			return;
+		}
+
 		Protocol_LobbyClientData p1;
 		Protocol_LobbyGameData p2;
 		
-		for (unsigned int i = 0; i < this->clients.Size(); i++)
+		for (unsigned int i = 0; i < this->gClients.Size(); i++)
 		{
-			if(this->clients[i])
+			if(this->gClients[i])
 			{
 				Protocol_LobbyClientData::PlayerData t;
-				t.id = this->clients[i]->GetID();
+				t.id = client->GetID();
-				t.ip = this->clients[i]->GetIpAddress();
+				t.ip = client->GetIpAddress();
 				t.team = 0;
 				t.name = "Dennis är kung tycker Erik!";
 				p1.list.Push(t);
@@ -139,4 +172,44 @@ void GameLobby::ClientConnectedEvent(Utility::DynamicMemory::SmartPointer<Oyster
 		client->Send(p2.GetProtocol());
 	}
 }
+void GameLobby::ProcessClients()
+{
+	for (unsigned int i = 0; i < this->gClients.Size(); i++)
+	{
+		if(this->gClients[i])
+		{
+			this->gClients[i]->UpdateClient();
+		}
+	}
+}
+bool GameLobby::Attach(Utility::DynamicMemory::SmartPointer<Oyster::Network::NetworkClient> client) 
+{
+	if(this->clientCount == this->description.maxClients) return false;
+
+	client->SetOwner(this);
+
+	bool added = false;
+	for (unsigned int i = 0; i < this->gClients.Size(); i++)
+	{
+		if(!this->gClients[i])
+		{
+			added = true;
+			this->gClients[i] = new GameClient(client);
+		}
+	}
+
+	if(!added)
+	{
+		this->gClients.Push(new GameClient(client));
+	}
+	return true;
+}
+
+
+
+
+
+
+
+
 

Code/Game/GameServer/Implementation/GameLobby_ProtocolParser.cpp

@@ -12,27 +12,23 @@ void GameLobby::ParseProtocol(Oyster::Network::CustomNetProtocol& p, NetworkClie
 {
 	switch (p[0].value.netShort)
 	{
-		case protocol_General_Status:			this->GeneralStatus		(Protocol_General_Status			(p), c);
+		case protocol_General_Status:			this->GeneralStatus			(Protocol_General_Status			(p), c);
 		break;
-		case protocol_General_Text:				this->GeneralText		(Protocol_General_Text				(p), c);
+		case protocol_General_Text:				this->GeneralText			(Protocol_General_Text				(p), c);
 		break;
-		//case protocol_Lobby_Create:				this->LobbyCreateGame	(Protocol_LobbyCreateGame			(p), c);
+		case protocol_Lobby_StartGame:			this->LobbyStartGame		(Protocol_LobbyStartGame			(p), c);
-		//break;
-		case protocol_Lobby_StartGame:			this->LobbyStartGame	(Protocol_LobbyStartGame	(p), c);
 		break;
-		//case protocol_Lobby_Join:				this->LobbyJoin			(Protocol_LobbyJoin					(p), c);
+		case protocol_Lobby_JoinGame:			this->LobbyJoin				(Protocol_LobbyJoinGame				(p), c);
-		//break;
-		case protocol_Lobby_Login:				this->LobbyLogin		(Protocol_LobbyJoinGame		(p), c);
 		break;
-		case protocol_Lobby_Refresh:			this->LobbyRefresh		(Protocol_LobbyRefresh				(p), c);
+		case protocol_Lobby_Refresh:			this->LobbyRefresh			(Protocol_LobbyRefresh				(p), c);
 		break;
-		case protocol_Lobby_GameData:			this->LobbyGameData		(Protocol_LobbyGameData				(p), c);
+		case protocol_Lobby_GameData:			this->LobbyGameData			(Protocol_LobbyGameData				(p), c);
 		break;
-		case protocol_Lobby_ClientData:			this->LobbyMainData		(Protocol_LobbyClientData			(p), c);
+		case protocol_Lobby_ClientData:			this->LobbyMainData			(Protocol_LobbyClientData			(p), c);
 		break;
-		case protocol_Lobby_ClientReadyState:	this->LobbyReady		(Protocol_LobbyClientReadyState		(p), c);
+		case protocol_Lobby_ClientReadyState:	this->LobbyReady			(Protocol_LobbyClientReadyState		(p), c);
 		break;
-		case protocol_Lobby_QuerryGameType:		this->LobbyReady		(Protocol_LobbyClientReadyState		(p), c);
+		case protocol_Lobby_QuerryGameType:		this->LobbyQuerryGameData	(Protocol_QuerryGameType			(), c);
 		break;
 	}
 }
@@ -44,52 +40,75 @@ void GameLobby::GeneralStatus(GameLogic::Protocol_General_Status& p, Oyster::Net
 	{
 		case Protocol_General_Status::States_ready:
 		{
-
+			int temp = FindClient(c);
+			if(temp != -1 )
+			{
+				switch (this->gClients[temp]->GetState())
+				{
+					case GameClient::ClientState_CreatingGame:
+					{
+						this->gameSession.Join(this->gClients[temp]);
+						this->gClients[temp] = 0;
+					}
+					break;
+				}
+			}
+			else
+			{
+				c->Disconnect();
+			}
 		}
+		break;
 		case Protocol_General_Status::States_idle:
 		{
 
 		}
+		break;
 		case Protocol_General_Status::States_leave:
+		break;
 		case Protocol_General_Status::States_disconected:
 		{
 			Detach(c)->Disconnect();
 		}
+		break;
 	}
 }
 void GameLobby::GeneralText(GameLogic::Protocol_General_Text& p, Oyster::Network::NetworkClient* c)
 {
+	for (unsigned int i = 0; i < this->gClients.Size(); i++)
+	{
+		if(this->gClients[i])
+		{
+			this->gClients[i]->GetClient()->Send(p);
+		}
+	}
 	printf(p.text.c_str());
 }
-//void GameLobby::LobbyCreateGame(GameLogic::Protocol_LobbyCreateGame& p, Oyster::Network::NetworkClient* c)
-//{
-//	
-//}
 void GameLobby::LobbyStartGame(GameLogic::Protocol_LobbyStartGame& p, Oyster::Network::NetworkClient* c)
 {
 	if(this->sessionOwner->GetClient()->GetID() == c->GetID())
 	{
-		
+		//Send countdown timer before lobby shuts down
+		for (unsigned int i = 0; i < this->gClients.Size(); i++)
+		{
+			this->gClients[i]->GetClient()->Send(Protocol_LobbyStartGame(3.0f));
+		}
 	}
 	else
 	{
 		//Someone else tried to start the server..
 	}
 }
-//void GameLobby::LobbyJoin(GameLogic::Protocol_LobbyJoin& p, Oyster::Network::NetworkClient* c)
+void GameLobby::LobbyJoin(GameLogic::Protocol_LobbyJoinGame& p, Oyster::Network::NetworkClient* c)
-//{
-//	//for (unsigned int i = 0; i < this->gameLobby.Size(); i++)
-//	//{
-//	//	if (this->gameLobby[i]->GetID() == p.value)
-//	//	{
-//	//		this->gameLobby[i]->Attach(Detach(c));
-//	//		return;
-//	//	}
-//	//}
-//}
-void GameLobby::LobbyLogin(GameLogic::Protocol_LobbyJoinGame& p, Oyster::Network::NetworkClient* c)
 {
-
+	//for (unsigned int i = 0; i < this->gameLobby.Size(); i++)
+	//{
+	//	if (this->gameLobby[i]->GetID() == p.value)
+	//	{
+	//		this->gameLobby[i]->Attach(Detach(c));
+	//		return;
+	//	}
+	//}
 }
 void GameLobby::LobbyRefresh(GameLogic::Protocol_LobbyRefresh& p, Oyster::Network::NetworkClient* c)
 {
@@ -112,31 +131,48 @@ void GameLobby::LobbyReady(GameLogic::Protocol_LobbyClientReadyState& p, Oyster:
 	else
 	{
 		this->readyList.Remove(c);
+		
 	}
 }
 void GameLobby::LobbyQuerryGameData(GameLogic::Protocol_QuerryGameType& p, Oyster::Network::NetworkClient* c)
 {
-	NetClient temp;
+	if(this->gameSession)
-	bool found = false;
-
-	//find client in waiting list
-	for (unsigned int i = 0; !found && i < this->clients.Size(); i++)
 	{
-		if(this->clients[i]->GetID() == c->GetID())
+		int temp = FindClient(c);
+
+		//Something is wrong
+		if(temp == -1)
 		{
-			temp = this->clients[i];
+			c->Disconnect();
-			found = true;
+		}
+		else
+		{
+			//Send game data
+			Protocol_LobbyCreateGame lcg((char)1, (char)0, Utility::String::WStringToString(this->description.mapName, std::string()));
+			c->Send(lcg);
+			this->gClients[temp]->SetState(GameClient::ClientState_CreatingGame);
 		}
-	}
-
-	//Something is wrong
-	if(!found)
-	{
-		c->Disconnect();
 	}
 	else
 	{
-		//Send game data
+		// Nothing.-
-		this->gameSession.Attach(temp);
 	}
 }
+
+
+int GameLobby::FindClient(Oyster::Network::NetworkClient* c)
+{
+	int temp = -1;
+	
+	//find client in waiting list
+	for (unsigned int i = 0; i < this->gClients.Size(); i++)
+	{
+		if(this->gClients[i]->GetClient()->GetID() == c->GetID())
+		{
+			temp = i;
+			break;
+		}
+	}
+
+	return temp;
+}

Code/Game/GameServer/Implementation/GameServer.cpp

@@ -118,69 +118,81 @@ void GameServerAPI::NotifyWhenClientDisconnect(ClientDisconnectedNotify func)
 	else		clientDisconnectedCallback = func;
 }
 
-void		GameServerAPI::GameSetMapName(const wchar_t* val)
+void			GameServerAPI::GameSetMapName(const wchar_t* val)
 {
 	LobbyLevelData d;
 	lobby.GetGameDesc(d);
-	//d.mapNumber = val; //TODO: implement
+	d.mapName = val;
 	lobby.SetGameDesc(d);
 }
-void		GameServerAPI::GameSetMaxClients(const int& val)
+void			GameServerAPI::GameSetGameMode(const wchar_t* val)
+{
+	LobbyLevelData d;
+	lobby.GetGameDesc(d);
+	d.gameMode = val;
+	lobby.SetGameDesc(d);
+}
+void			GameServerAPI::GameSetGameName(const wchar_t* val)
+{
+	LobbyLevelData d;
+	lobby.GetGameDesc(d);
+	d.gameName = val;
+	lobby.SetGameDesc(d);
+}
+void			GameServerAPI::GameSetMaxClients(const int& val)
 {
 	LobbyLevelData d;
 	lobby.GetGameDesc(d);
 	d.maxClients = val;
 	lobby.SetGameDesc(d);
 }
-void		GameServerAPI::GameSetGameMode(const wchar_t* val)
+void			GameServerAPI::GameSetGameTime(const int& val)
 {
 	LobbyLevelData d;
 	lobby.GetGameDesc(d);
-	//d.gameMode = val;	//TODO: implement
+	d.gameTimeInMinutes = val;
 	lobby.SetGameDesc(d);
 }
-void		GameServerAPI::GameSetGameTime(const int& val)
+
+const wchar_t*	GameServerAPI::GameGetMapName()
 {
 	LobbyLevelData d;
 	lobby.GetGameDesc(d);
-	d.gameTime = val;
+	return d.mapName.c_str();
-	lobby.SetGameDesc(d);
 }
-int			GameServerAPI::GameGetMapId()
+int				GameServerAPI::GameGetMaxClients()
-{
-	LobbyLevelData d;
-	lobby.GetGameDesc(d);
-	return d.mapNumber;
-}
-int			GameServerAPI::GameGetMaxClients()
 {
 	LobbyLevelData d;
 	lobby.GetGameDesc(d);
 	return d.maxClients;
 }
-int			GameServerAPI::GameGetGameMode()
+const wchar_t*	GameServerAPI::GameGetGameMode()
 {
 	LobbyLevelData d;
 	lobby.GetGameDesc(d);
-	return d.gameMode;
+	return d.gameMode.c_str();
 }
-int			GameServerAPI::GameGetGameTime()
+int				GameServerAPI::GameGetGameTime()
 {
 	LobbyLevelData d;
 	lobby.GetGameDesc(d);
-	return d.gameTime;
+	return d.gameTimeInMinutes;
 }
-const char*	GameServerAPI::GameGetGameName()
+const wchar_t*	GameServerAPI::GameGetGameName()
 {
 	LobbyLevelData d;
 	lobby.GetGameDesc(d);
 	return d.gameName.c_str();
 }
-bool		GameServerAPI::GameStart()
+int				GameServerAPI::GetConnectedClientCount()
 {
-	if(lobby.StartGameSession())
+	return lobby.GetGameSessionClientCount();
-	{
+}
 
+bool			GameServerAPI::GameStart( bool forceStart )
+{
+	if(lobby.StartGameSession( forceStart ))
+	{
 		return true;
 	}
 	return false;

Code/Game/GameServer/Implementation/GameSession_Gameplay.cpp

@@ -19,11 +19,8 @@ using namespace Oyster;
 using namespace Oyster::Network;
 using namespace Oyster::Thread;
 using namespace GameLogic;
+using namespace DanBias;
 
-namespace DanBias
-{
-	Utility::WinTimer testTimer;
-	int testID = -1;
 
 	bool GameSession::DoWork(  )
 	{
@@ -46,9 +43,9 @@ namespace DanBias
 	{
 		int temp = -1;
 		//Find the idiot
-		for (unsigned int i = 0; i < this->clients.Size(); i++)
+		for (unsigned int i = 0; i < this->gClients.Size(); i++)
 		{
-			if(this->clients[i]->Equals(e.sender))
+			if(this->gClients[i] && this->gClients[i]->Equals(e.sender))
 			{
 				temp = i;
 			}
@@ -59,7 +56,7 @@ namespace DanBias
 			this->Detach(e.sender)->Disconnect();
 			return;
 		}
-		SmartPointer<GameClient> cl = this->clients[temp];
+		SmartPointer<GameClient> cl = this->gClients[temp];
 
 		switch (e.args.type)
 		{
@@ -73,15 +70,48 @@ namespace DanBias
 			break;
 			case NetworkClient::ClientEventArgs::EventType_ProtocolRecieved:
 				printf("\t(%i : %s) - EventType_ProtocolRecieved\n", cl->GetClient()->GetID(), e.sender->GetIpAddress().c_str());	
-				testID = 2;
-				if(cl->GetPlayer()->GetID() == testID)//TODO: TEST
-				{
-					testTimer.reset();
-				}
 				this->ParseProtocol(e.args.data.protocol, cl);
 			break;
 		}
 	}
+	void GameSession::ProcessClients()
+	{
+		for (unsigned int i = 0; i < this->gClients.Size(); i++)
+		{
+			if(this->gClients[i] )
+			{
+				this->gClients[i]->UpdateClient();
+			}
+		}
+	}
+	bool GameSession::Send(Oyster::Network::CustomNetProtocol& message)
+	{
+		bool returnValue = false;
+		for (unsigned int i = 0; i < this->gClients.Size(); i++)
+		{
+			if(this->gClients[i])
+			{
+				this->gClients[i]->GetClient()->Send(message);
+				returnValue = true;
+			}
+		}
+
+		return returnValue;
+
+	}
+	bool GameSession::Send(Oyster::Network::CustomNetProtocol& protocol, int ID)
+	{
+		for (unsigned int i = 0; i < this->gClients.Size(); i++)
+		{
+			if(this->gClients[i] && this->gClients[i]->GetClient()->GetID() == ID)
+			{
+				this->gClients[i]->GetClient()->Send(protocol);
+				return true;
+			}
+		}
+		return false;
+	}
+
 
 	void GameSession::ObjectMove(GameLogic::IObjectData* movedObject)
 	{
@@ -246,7 +276,6 @@ namespace DanBias
 		printf("Message recieved from (%i):\t %s\n", c->GetClient()->GetID(), p.text.c_str());
 	}
 
-}//End namespace DanBias
 
 
 

Code/Game/GameServer/Implementation/GameSession_General.cpp

@@ -3,6 +3,7 @@
 /////////////////////////////////////////////////////////////////////
 #include "..\GameSession.h"
 #include "..\GameClient.h"
+#include "..\GameLobby.h"
 #include <Protocols.h>
 #include <PostBox\PostBox.h>
 #include <GameLogicStates.h>
@@ -24,217 +25,253 @@ using namespace Oyster;
 using namespace Oyster::Network;
 using namespace Oyster::Thread;
 using namespace GameLogic;
+using namespace DanBias;
 
-namespace DanBias
+GameSession* GameSession::gameSession = nullptr;
+
+GameSession::GameSession()
+	:gameInstance(GameAPI::Instance())
 {
-	GameSession* GameSession::gameSession = nullptr;
+	this->owner = 0;
+	this->isCreated = false;
+	this->isRunning = false;
+	this->gameSession = this;
+	this->logicFrameTime = DELTA_TIME_20;
+	this->networkFrameTime = DELTA_TIME_20;
+	this->networkTimer.reset();
+	this->logicTimer.reset();
 
-	GameSession::GameSession()
+	memset(&this->description, 0, sizeof(GameDescription));
-		:gameInstance(GameAPI::Instance())
+}
+
+GameSession::~GameSession()
+{
+	this->worker.Terminate();
+	this->clients.Clear();
+	this->gameInstance;
+	this->owner = 0;
+	this->isCreated = false;
+	this->isRunning = false;
+}
+
+bool GameSession::Create(GameDescription& desc, bool forceStart)
+{
+	this->description = desc;
+/* Do some error checking */
+	if(!forceStart && desc.clients.Size() == 0)	return false;
+	if(!desc.owner)								return false;
+	if(this->isCreated)							return false;
+
+/* standard initialization of some data */
+	this->gClients.Resize((unsigned int)desc.maxClients);
+	for (unsigned int i = 0; i < desc.clients.Size(); i++)
 	{
-		this->owner = 0;
+		if(desc.clients[i])
-		this->isCreated = false;
-		this->isRunning = false;
-		this->gameSession = this;
-		this->logicFrameTime = DELTA_TIME_20;
-		this->networkFrameTime = DELTA_TIME_20;
-		this->networkTimer.reset();
-		this->logicTimer.reset();
-
-		memset(&this->description, 0, sizeof(GameDescription));
-	}
-
-	GameSession::~GameSession()
-	{
-		this->worker.Terminate();
-		this->clients.Clear();
-		this->gameInstance;
-		this->owner = 0;
-		this->isCreated = false;
-		this->isRunning = false;
-	}
-
-	bool GameSession::Create(GameDescription& desc)
-	{
-		this->description = desc;
-	/* Do some error checking */
-		if(desc.clients.Size() == 0)	return false;
-		if(!desc.owner)					return false;
-		if(this->isCreated)				return false;
-
-	/* standard initialization of some data */
-		NetworkSession::clients = desc.clients;
-		NetworkSession::clients.Resize((unsigned int)desc.maxClients);
-		this->clients.Resize((unsigned int)desc.maxClients);
-		this->owner = desc.owner;
-
-	/* Initiate the game instance */
-		if(!this->gameInstance.Initiate())
 		{
-			printf("Failed to initiate the game instance\n");
+			this->clientCount++;
+			this->gClients[i] = desc.clients[i];
+			this->gClients[i]->SetOwner(this);
 		}
+	}
+	this->owner = desc.owner;
 
-	/* Create the players in the game instance */
+/* Initiate the game instance */
-		GameLogic::IPlayerData* p = 0;
+	if(!this->gameInstance.Initiate())
-		for (unsigned int i = 0; i < desc.clients.Size(); i++)
+	{
+		printf("Failed to initiate the game instance\n");
+	}
+
+/* Create the players in the game instance */
+	GameLogic::IPlayerData* p = 0;
+	for (unsigned int i = 0; i < this->gClients.Size(); i++)
+	{
+		if(this->gClients[i])
 		{
-			if(desc.clients[i])
+			if( (p = this->gameInstance.CreatePlayer()) )
 			{
-				if( (p = this->gameInstance.CreatePlayer()) )
+				this->gClients[i]->SetPlayer(p);
-				{
+			}
-					desc.clients[i]->SetOwner(this);
+			else
-					this->clients[i] = (new GameClient(desc.clients[i], p));
+			{
-				}
+				printf("Failed to create player (%i)\n", i);
-				else
-				{
-					printf("Failed to create player (%i)\n", i);
-				}
 			}
 		}
-
-	/* Create the game level */
-		if(!(this->levelData = this->gameInstance.CreateLevel()))
-		{
-			printf("Level not created!");
-			return false;
-		}
-
-	/* Set some game instance data options */
-		this->gameInstance.SetSubscription(GameSession::ObjectMove);
-		this->gameInstance.SetSubscription(GameSession::ObjectDisabled);
-		this->gameInstance.SetFPS(60);
-
-		this->description.clients.Clear();
-
-		this->isCreated = true;
-
-		/* Create the worker thread */
-		if(this->worker.Create(this, false) != OYSTER_THREAD_ERROR_SUCCESS) 
-			return false;
-
-		return this->isCreated;
 	}
 
-	void GameSession::Run()
+/* Create the game level */
+	if(!(this->levelData = this->gameInstance.CreateLevel(this->description.mapName.c_str())))
 	{
-		if(this->isRunning) return;
+		printf("Level not created!");
+		return false;
+	}
 
-		if(this->clients.Size() > 0)
+/* Set some game instance data options */
+	this->gameInstance.SetSubscription(GameSession::ObjectMove);
+	this->gameInstance.SetSubscription(GameSession::ObjectDisabled);
+	this->gameInstance.SetFPS(60);
+
+	this->description.clients.Clear();
+
+	this->isCreated = true;
+
+	/* Create the worker thread */
+	if(this->worker.Create(this, false) != OYSTER_THREAD_ERROR_SUCCESS) 
+		return false;
+
+	return this->isCreated;
+}
+
+void GameSession::Run()
+{
+	if(this->isRunning) return;
+
+	this->worker.Start();
+	this->worker.SetPriority(OYSTER_THREAD_PRIORITY_1);
+	this->isRunning = true;
+	
+}
+
+void GameSession::ThreadEntry(  )
+{
+//List with clients that we are waiting on..
+	DynamicArray<gClient> readyList;// = this->clients;
+
+//First we need to clean invalid clients, if any, and tell them to start loading game data
+	for (unsigned int i = 0; i < this->gClients.Size(); i++)
+	{
+		if(this->gClients[i])
 		{
-			this->worker.Start();
+			readyList.Push(this->gClients[i]);
-			this->worker.SetPriority(OYSTER_THREAD_PRIORITY_1);
+			Protocol_LobbyCreateGame p((char)1, (char)0, Utility::String::WStringToString(this->description.mapName, std::string()));
-			this->isRunning = true;
+			readyList[readyList.Size() - 1]->GetClient()->Send(p);
 		}
 	}
 	
-	void GameSession::ThreadEntry(  )
+	unsigned int readyCounter = readyList.Size();
+
+//Sync with clients
+	while (readyCounter != 0)
 	{
-	//List with clients that we are waiting on..
+		this->ProcessClients();
-		DynamicArray<SmartPointer<GameClient>> readyList;// = this->clients;
+		for (unsigned int i = 0; i < readyList.Size(); i++)
-
-	//First we need to clean invalid clients, if any, and tell them to start loading game data
-		for (unsigned int i = 0; i < this->clients.Size(); i++)
 		{
-			if(this->clients[i]) 
+			if(readyList[i] && readyList[i]->IsReady())
 			{
-				if(this->clients[i]->IsReady())
+				//Need to send information about other players, to all players
+				for (unsigned int k = 0; k < this->gClients.Size(); k++)
 				{
-					readyList.Push(this->clients[i]);
+					if((this->gClients[k] && readyList[i]) && readyList[i]->GetClient()->GetID() != this->gClients[k]->GetClient()->GetID())
-					Protocol_LobbyCreateGame p(readyList[i]->GetPlayer()->GetID(), "char_white.dan", readyList[i]->GetPlayer()->GetOrientation());
-					readyList[readyList.Size() - 1]->GetClient()->Send(p);
-				}
-			}
-		}
-	
-		unsigned int readyCounter = readyList.Size();
-
-	//Sync with clients
-		while (readyCounter != 0)
-		{
-			this->ProcessClients();
-			for (unsigned int i = 0; i < readyList.Size(); i++)
-			{
-				if(readyList[i] && readyList[i]->IsReady())
-				{
-					//Need to send information about other players, to all players
-					for (unsigned int k = 0; k < this->clients.Size(); k++)
 					{
-						if((this->clients[k] && readyList[i]) && readyList[i]->GetClient()->GetID() != this->clients[k]->GetClient()->GetID())
+						IPlayerData* pl = this->gClients[k]->GetPlayer();
-						{
+						Protocol_ObjectCreatePlayer p(	pl->GetPosition(), pl->GetRotation(), pl->GetScale(),
-							//Protocol_ObjectCreatePlayer
+														pl->GetID(), true, this->gClients[k]->GetPlayer()->GetTeamID(),
-							Protocol_ObjectCreate p( this->clients[k]->GetPlayer()->GetPosition(),
+														/*nwClient->GetAlias()*/"", /*playerData->GetMesh()*/"char_white.dan");
-													 this->clients[k]->GetPlayer()->GetRotation(),
+						readyList[i]->GetClient()->Send(p);
-													 this->clients[k]->GetPlayer()->GetScale(),
-													 this->clients[k]->GetPlayer()->GetID(), "char_white.dan"); //The model name will be custom later..
-							readyList[i]->GetClient()->Send(p);
-						}
 					}
-					
-					readyCounter-- ;
-					readyList[i] = 0;
 				}
-			}
-			Sleep(5); //TODO: This might not be needed here.
-		}
 					
-		for (unsigned int i = 0; i < this->clients.Size(); i++)
+				readyCounter-- ;
-		{
+				readyList[i] = 0;
-			if(this->clients[i])
-			{
-				this->clients[i]->GetClient()->Send(GameLogic::Protocol_LobbyStartGame(5));
 			}
 		}
+		Sleep(5); //TODO: This might not be needed here.
 	}
 
-	bool GameSession::Attach(Utility::DynamicMemory::SmartPointer<NetworkClient> client)
+//Sync with clients before starting countdown
+	for (unsigned int i = 0; i < this->gClients.Size(); i++)
 	{
-		if(!this->isCreated)									return false;
+		if(this->gClients[i])
-		if(this->GetClientCount() == this->clients.Capacity())	return false;
-
-		client->SetOwner(this);
-
-		IPlayerData* player = this->gameInstance.CreatePlayer();
-		if(!player) return false;
-
-		SmartPointer<GameClient> obj = new GameClient(client, player);
-
-	// Send the chosen mesh name
-		Protocol_LobbyCreateGame lcg(obj->GetPlayer()->GetID(), "char_white.dan", obj->GetPlayer()->GetOrientation());
-		obj->GetClient()->Send(lcg);
-
-	// Send the player data only
-		for (unsigned int i = 0; i < this->clients.Capacity(); i++)
 		{
-			if(this->clients[i])
+			this->gClients[i]->GetClient()->Send(GameLogic::Protocol_LobbyStartGame(5.0f));
-			{
-				IPlayerData* p = this->clients[i]->GetPlayer();
-				Protocol_ObjectCreate oc(p->GetPosition(), p->GetRotation(), p->GetScale(), p->GetID(), "char_white.dan");
-				//Protocol_ObjectCreatePlayer oc(p->GetPosition(), p->GetRotation(), p->GetScale(), p->GetID(), "char_white.dan");
-				this->clients[i]->GetClient()->Send(oc);
-			}
 		}
-
-		obj->GetClient()->Send(GameLogic::Protocol_LobbyStartGame(0));
-
-		for (unsigned int i = 0; i < this->clients.Size(); i++)
-		{
-			if(!clients[i])
-			{
-				NetworkSession::clients[i] = client;
-				clients[i] = obj;
-				return true;
-			}
-		}
-			
-		return true;
 	}
+}
 
-	void GameSession::CloseSession( bool dissconnectClients )
+bool GameSession::Join(gClient gameClient)
+{
+	if(!this->isCreated)									return false;
+	if(this->GetClientCount() == this->gClients.Capacity())	return false;
+
+	gameClient->SetOwner(this);
+
+	IPlayerData* playerData = this->gameInstance.CreatePlayer();
+	if(!playerData) return false;
+
+	gameClient->SetPlayer(playerData);
+	NetworkClient* nwClient = gameClient->GetClient();
+
+// Send the player data only
 	{
-		this->worker.Terminate();
+		Protocol_ObjectCreatePlayer oc(	playerData->GetPosition(), playerData->GetRotation(), playerData->GetScale(), 
-		NetworkSession::CloseSession(true);
+										playerData->GetID(), true, playerData->GetTeamID(), 
-		this->clients.Clear();
+										/*nwClient->GetAlias()*/"Unknown", /*playerData->GetMesh()*/"char_white.dan");
+		nwClient->Send(oc);
 	}
 
-}//End namespace DanBias
+// Send information about other clients
+	{
+		for (unsigned int i = 0; i < this->gClients.Size(); i++)
+		{
+			if(this->gClients[i])
+			{
+				IPlayerData* temp = this->gClients[i]->GetPlayer();
+				Protocol_ObjectCreatePlayer oc(	temp->GetPosition(), temp->GetRotation(), temp->GetScale(), 
+												temp->GetID(), false, temp->GetTeamID(), 
+												/*nwClient->GetAlias()*/"Unknown", /*playerData->GetMesh()*/"char_white.dan");
+				nwClient->Send(oc);
+			}
+		}
+	}
+
+//TODO: Need to be able to get the current gameplay data from the logic, to sync it with the client
+	{
+		DynamicArray<IObjectData*> objects;
+		this->levelData->GetAllDynamicObjects(objects);
+		for (unsigned int i = 0; i < objects.Size(); i++)
+		{
+			//Protocol_ObjectPosition p(movedObject->GetPosition(), id);
+			Protocol_ObjectPositionRotation p(objects[i]->GetPosition(), objects[i]->GetRotation(), objects[i]->GetID());
+			GameSession::gameSession->Send(p.GetProtocol());
+		}
+	}
+
+// Insert the new client to the update list
+	bool added = false;
+	{
+		for (unsigned int i = 0; !added && i < this->gClients.Size(); i++)
+		{
+			if(!this->gClients[i])
+			{
+				this->gClients[i] = gameClient;
+				// Send the start signal
+				{
+					nwClient->Send(GameLogic::Protocol_LobbyStartGame(0));
+				}
+				added = true;
+				this->clientCount++;
+			}
+		}
+	}
+
+	gameClient->SetState(GameClient::ClientState_Ready);
+
+	return added;
+}
+
+//DynamicArray<gClient> GameSession::CloseSession( bool dissconnectClients )
+//{
+//	this->worker.Terminate();
+//	//TODO: Send clients to lobby
+//
+//	//for (unsigned int i = 0; i < this->gClients.Size(); i++)
+//	//{
+//	//	if(this->gClients[i])
+//	//	{
+//	//		((GameLobby*)this->owner)-> this->gClients[i]
+//	//	}
+//	//}
+//
+//	this->gClients.Clear();
+//}
+
 

Code/Game/LanServer/CLIStandaloneServer/StandaloneGameServerCLI.cpp

@@ -72,26 +72,32 @@ void StandaloneGameServerCLI::GameSetMapName(String^ value)
 	pin_ptr<const wchar_t> wch = PtrToStringChars(value);
 	DanBias::GameServerAPI::GameSetMapName(wch);
 }
+void StandaloneGameServerCLI::GameSetGameMode(String^ value)
+{
+	pin_ptr<const wchar_t> wch = PtrToStringChars(value);
+	DanBias::GameServerAPI::GameSetGameMode(wch);
+}
+void StandaloneGameServerCLI::GameSetGameName(String^ value)
+{
+	pin_ptr<const wchar_t> wch = PtrToStringChars(value);
+	DanBias::GameServerAPI::GameSetGameName(wch);
+}
 
 void StandaloneGameServerCLI::GameSetMaxClients(const int val)
 {
 	DanBias::GameServerAPI::GameSetMaxClients(val);
 }
 
-void StandaloneGameServerCLI::GameSetGameMode(String^ value)
+
-{
-	pin_ptr<const wchar_t> wch = PtrToStringChars(value);
-	DanBias::GameServerAPI::GameSetGameMode(wch);
-}
 
 void StandaloneGameServerCLI::GameSetGameTime(const int val)
 {
 	DanBias::GameServerAPI::GameSetGameTime(val);
 }
 
-int StandaloneGameServerCLI::GameGetMapId()
+String^  StandaloneGameServerCLI::GameGetMapName()
 {
-	return DanBias::GameServerAPI::GameGetMapId();
+	return gcnew String( DanBias::GameServerAPI::GameGetMapName());
 }
 
 int StandaloneGameServerCLI::GameGetMaxClients()
@@ -99,9 +105,9 @@ int StandaloneGameServerCLI::GameGetMaxClients()
 	return DanBias::GameServerAPI::GameGetMaxClients();
 }
 
-int StandaloneGameServerCLI::GameGetGameMode()
+String^ StandaloneGameServerCLI::GameGetGameMode()
 {
-	return DanBias::GameServerAPI::GameGetGameMode();
+	return gcnew String( DanBias::GameServerAPI::GameGetGameMode());
 }
 
 int StandaloneGameServerCLI::GameGetGameTime()
@@ -111,10 +117,17 @@ int StandaloneGameServerCLI::GameGetGameTime()
 
 String^ StandaloneGameServerCLI::GameGetGameName()
 {
-	return gcnew String(DanBias::GameServerAPI::GameGetGameName());
+	return gcnew String( DanBias::GameServerAPI::GameGetGameName());
 }
 
-bool StandaloneGameServerCLI::GameStart()
+bool StandaloneGameServerCLI::GameStart(bool f)
 {
-	return DanBias::GameServerAPI::GameStart();
+	return DanBias::GameServerAPI::GameStart(f);
 }
+int StandaloneGameServerCLI::GetClientsConnectedCount()
+{
+	return DanBias::GameServerAPI::GetConnectedClientCount();
+}
+
+
+

Code/Game/LanServer/CLIStandaloneServer/StandaloneGameServerCLI.h

@@ -47,15 +47,18 @@ namespace System { namespace Windows { namespace Interop
 		bool ServerIsRunning();
 
 		void GameSetMapName(String^ val);
-		void GameSetMaxClients(const int val);
 		void GameSetGameMode(String^ val);
+		void GameSetGameName(String^ val);
+		void GameSetMaxClients(const int val);
 		void GameSetGameTime(const int val);
-		int GameGetMapId();
+
 		int GameGetMaxClients();
-		int GameGetGameMode();
 		int GameGetGameTime();
+		System::String^ GameGetMapName();
+		System::String^ GameGetGameMode();
 		System::String^ GameGetGameName();
-		bool GameStart();
+		bool GameStart( bool forceStart );
+		int GetClientsConnectedCount();
 	};
 
 } } }

Code/Game/LanServer/StandAloneLauncher/App.config

@@ -1,5 +1,10 @@
 <?xml version="1.0" encoding="utf-8" ?>
 <configuration>
+    <configSections>
+        <sectionGroup name="userSettings" type="System.Configuration.UserSettingsGroup, System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" >
+            <section name="StandAloneLauncher.Properties.Settings" type="System.Configuration.ClientSettingsSection, System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" allowExeDefinition="MachineToLocalUser" requirePermission="false" />
+        </sectionGroup>
+    </configSections>
     <startup> 
         <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5" />
     </startup>
@@ -8,4 +13,11 @@
         <probing privatePath="..\..\Bin\DLL\" />
       </assemblyBinding>
     </runtime>
+    <userSettings>
+        <StandAloneLauncher.Properties.Settings>
+            <setting name="Dennis" serializeAs="String">
+                <value>.\..\Content\</value>
+            </setting>
+        </StandAloneLauncher.Properties.Settings>
+    </userSettings>
 </configuration>

Code/Game/LanServer/StandAloneLauncher/Form1.Designer.cs

@@ -36,32 +36,58 @@
             this.label_listenPort = new System.Windows.Forms.Label();
             this.panel_serverOptions = new System.Windows.Forms.Panel();
             this.panel_commands = new System.Windows.Forms.Panel();
+            this.timeLimit = new System.Windows.Forms.NumericUpDown();
+            this.gameModes = new System.Windows.Forms.ComboBox();
+            this.label3 = new System.Windows.Forms.Label();
+            this.forceStart = new System.Windows.Forms.CheckBox();
+            this.label2 = new System.Windows.Forms.Label();
+            this.label4 = new System.Windows.Forms.Label();
+            this.labelClientsConnected = new System.Windows.Forms.Label();
+            this.label1 = new System.Windows.Forms.Label();
+            this.nrOfClients = new System.Windows.Forms.NumericUpDown();
+            this.buttonStartGame = new System.Windows.Forms.Button();
             this.panel_clientArea = new System.Windows.Forms.Panel();
             this.ServerInfoTextArea = new System.Windows.Forms.RichTextBox();
             this.splitter1 = new System.Windows.Forms.Splitter();
             this.clientInfoBox = new System.Windows.Forms.ListBox();
-            this.buttonStartGame = new System.Windows.Forms.Button();
+            this.panel_CommanArea = new System.Windows.Forms.Panel();
-            this.nrOfClients = new System.Windows.Forms.NumericUpDown();
+            this.label5 = new System.Windows.Forms.Label();
-            this.label1 = new System.Windows.Forms.Label();
+            this.mapName = new System.Windows.Forms.ComboBox();
-            this.label2 = new System.Windows.Forms.Label();
+            this.panelServerCommands = new System.Windows.Forms.Panel();
-            this.gameModes = new System.Windows.Forms.ComboBox();
+            this.buttonExecuteSend = new System.Windows.Forms.Button();
-            this.timeLimit = new System.Windows.Forms.NumericUpDown();
+            this.panel2 = new System.Windows.Forms.Panel();
-            this.label3 = new System.Windows.Forms.Label();
+            this.comboBox1 = new System.Windows.Forms.ComboBox();
-            this.label4 = new System.Windows.Forms.Label();
+            this.numericUpDown1 = new System.Windows.Forms.NumericUpDown();
-            this.mapName = new System.Windows.Forms.TextBox();
+            this.textBox1 = new System.Windows.Forms.TextBox();
+            this.tableLayoutPanel1 = new System.Windows.Forms.TableLayoutPanel();
+            this.label6 = new System.Windows.Forms.Label();
+            this.label7 = new System.Windows.Forms.Label();
+            this.label8 = new System.Windows.Forms.Label();
+            this.dataProtocolFields = new System.Windows.Forms.TableLayoutPanel();
+            this.buttonAddNewDataField = new System.Windows.Forms.Button();
+            this.button2 = new System.Windows.Forms.Button();
+            this.buttonsAtBottom = new System.Windows.Forms.TableLayoutPanel();
             ((System.ComponentModel.ISupportInitialize)(this.listenPort)).BeginInit();
             this.panel_serverOptions.SuspendLayout();
             this.panel_commands.SuspendLayout();
-            this.panel_clientArea.SuspendLayout();
-            ((System.ComponentModel.ISupportInitialize)(this.nrOfClients)).BeginInit();
             ((System.ComponentModel.ISupportInitialize)(this.timeLimit)).BeginInit();
+            ((System.ComponentModel.ISupportInitialize)(this.nrOfClients)).BeginInit();
+            this.panel_clientArea.SuspendLayout();
+            this.panel_CommanArea.SuspendLayout();
+            this.panelServerCommands.SuspendLayout();
+            this.panel2.SuspendLayout();
+            ((System.ComponentModel.ISupportInitialize)(this.numericUpDown1)).BeginInit();
+            this.tableLayoutPanel1.SuspendLayout();
+            this.dataProtocolFields.SuspendLayout();
+            this.buttonsAtBottom.SuspendLayout();
             this.SuspendLayout();
             // 
             // serverToggle
             // 
-            this.serverToggle.Location = new System.Drawing.Point(9, 81);
+            this.serverToggle.Dock = System.Windows.Forms.DockStyle.Bottom;
+            this.serverToggle.Location = new System.Drawing.Point(0, 83);
             this.serverToggle.Name = "serverToggle";
-            this.serverToggle.Size = new System.Drawing.Size(75, 23);
+            this.serverToggle.Size = new System.Drawing.Size(241, 20);
             this.serverToggle.TabIndex = 0;
             this.serverToggle.Text = "Start server";
             this.serverToggle.UseVisualStyleBackColor = true;
@@ -111,7 +137,7 @@
             this.listenPort.Size = new System.Drawing.Size(95, 20);
             this.listenPort.TabIndex = 5;
             this.listenPort.Value = new decimal(new int[] {
-            2048,
+            15151,
             0,
             0,
             0});
@@ -133,83 +159,123 @@
             this.panel_serverOptions.Controls.Add(this.label_listenPort);
             this.panel_serverOptions.Controls.Add(this.lanBroadcast);
             this.panel_serverOptions.Controls.Add(this.label_serverName);
-            this.panel_serverOptions.Location = new System.Drawing.Point(12, 12);
+            this.panel_serverOptions.Dock = System.Windows.Forms.DockStyle.Top;
+            this.panel_serverOptions.Location = new System.Drawing.Point(0, 0);
             this.panel_serverOptions.Name = "panel_serverOptions";
-            this.panel_serverOptions.Size = new System.Drawing.Size(183, 113);
+            this.panel_serverOptions.Size = new System.Drawing.Size(241, 103);
             this.panel_serverOptions.TabIndex = 6;
             // 
             // panel_commands
             // 
-            this.panel_commands.Controls.Add(this.mapName);
             this.panel_commands.Controls.Add(this.timeLimit);
+            this.panel_commands.Controls.Add(this.mapName);
             this.panel_commands.Controls.Add(this.gameModes);
             this.panel_commands.Controls.Add(this.label3);
+            this.panel_commands.Controls.Add(this.forceStart);
             this.panel_commands.Controls.Add(this.label2);
             this.panel_commands.Controls.Add(this.label4);
+            this.panel_commands.Controls.Add(this.label5);
+            this.panel_commands.Controls.Add(this.labelClientsConnected);
             this.panel_commands.Controls.Add(this.label1);
             this.panel_commands.Controls.Add(this.nrOfClients);
             this.panel_commands.Controls.Add(this.buttonStartGame);
-            this.panel_commands.Location = new System.Drawing.Point(12, 131);
+            this.panel_commands.Dock = System.Windows.Forms.DockStyle.Top;
+            this.panel_commands.Location = new System.Drawing.Point(0, 103);
             this.panel_commands.Name = "panel_commands";
-            this.panel_commands.Size = new System.Drawing.Size(183, 230);
+            this.panel_commands.Size = new System.Drawing.Size(241, 188);
             this.panel_commands.TabIndex = 7;
             this.panel_commands.Visible = false;
             // 
-            // panel_clientArea
+            // timeLimit
             // 
-            this.panel_clientArea.Controls.Add(this.ServerInfoTextArea);
+            this.timeLimit.Location = new System.Drawing.Point(112, 89);
-            this.panel_clientArea.Controls.Add(this.splitter1);
+            this.timeLimit.Minimum = new decimal(new int[] {
-            this.panel_clientArea.Controls.Add(this.clientInfoBox);
+            5,
-            this.panel_clientArea.Location = new System.Drawing.Point(202, 12);
+            0,
-            this.panel_clientArea.Name = "panel_clientArea";
+            0,
-            this.panel_clientArea.Size = new System.Drawing.Size(303, 349);
+            0});
-            this.panel_clientArea.TabIndex = 8;
+            this.timeLimit.Name = "timeLimit";
+            this.timeLimit.Size = new System.Drawing.Size(123, 20);
+            this.timeLimit.TabIndex = 11;
+            this.timeLimit.ThousandsSeparator = true;
+            this.timeLimit.Value = new decimal(new int[] {
+            15,
+            0,
+            0,
+            0});
             // 
-            // ServerInfoTextArea
+            // gameModes
             // 
-            this.ServerInfoTextArea.BackColor = System.Drawing.SystemColors.ActiveCaptionText;
+            this.gameModes.DropDownStyle = System.Windows.Forms.ComboBoxStyle.DropDownList;
-            this.ServerInfoTextArea.BorderStyle = System.Windows.Forms.BorderStyle.None;
+            this.gameModes.FormattingEnabled = true;
-            this.ServerInfoTextArea.Dock = System.Windows.Forms.DockStyle.Fill;
+            this.gameModes.Items.AddRange(new object[] {
-            this.ServerInfoTextArea.Font = new System.Drawing.Font("GulimChe", 8.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
+            "Free-for-all",
-            this.ServerInfoTextArea.ForeColor = System.Drawing.SystemColors.Info;
+            "Team death-match"});
-            this.ServerInfoTextArea.Location = new System.Drawing.Point(0, 152);
+            this.gameModes.Location = new System.Drawing.Point(77, 61);
-            this.ServerInfoTextArea.Name = "ServerInfoTextArea";
+            this.gameModes.Name = "gameModes";
-            this.ServerInfoTextArea.ReadOnly = true;
+            this.gameModes.Size = new System.Drawing.Size(158, 21);
-            this.ServerInfoTextArea.Size = new System.Drawing.Size(303, 197);
+            this.gameModes.TabIndex = 10;
-            this.ServerInfoTextArea.TabIndex = 1;
-            this.ServerInfoTextArea.Text = "";
             // 
-            // splitter1
+            // label3
             // 
-            this.splitter1.Dock = System.Windows.Forms.DockStyle.Top;
+            this.label3.AutoSize = true;
-            this.splitter1.Location = new System.Drawing.Point(0, 147);
+            this.label3.Location = new System.Drawing.Point(8, 96);
-            this.splitter1.Name = "splitter1";
+            this.label3.Name = "label3";
-            this.splitter1.Size = new System.Drawing.Size(303, 5);
+            this.label3.Size = new System.Drawing.Size(95, 13);
-            this.splitter1.TabIndex = 2;
+            this.label3.TabIndex = 9;
-            this.splitter1.TabStop = false;
+            this.label3.Text = "Time limit (minutes)";
             // 
-            // clientInfoBox
+            // forceStart
             // 
-            this.clientInfoBox.Dock = System.Windows.Forms.DockStyle.Top;
+            this.forceStart.AutoSize = true;
-            this.clientInfoBox.FormattingEnabled = true;
+            this.forceStart.Checked = true;
-            this.clientInfoBox.Location = new System.Drawing.Point(0, 0);
+            this.forceStart.CheckState = System.Windows.Forms.CheckState.Checked;
-            this.clientInfoBox.Name = "clientInfoBox";
+            this.forceStart.Location = new System.Drawing.Point(12, 120);
-            this.clientInfoBox.Size = new System.Drawing.Size(303, 147);
+            this.forceStart.Name = "forceStart";
-            this.clientInfoBox.TabIndex = 0;
+            this.forceStart.Size = new System.Drawing.Size(115, 17);
+            this.forceStart.TabIndex = 1;
+            this.forceStart.Text = "Ignore empty lobby";
+            this.forceStart.UseVisualStyleBackColor = true;
             // 
-            // buttonStartGame
+            // label2
             // 
-            this.buttonStartGame.Location = new System.Drawing.Point(53, 195);
+            this.label2.AutoSize = true;
-            this.buttonStartGame.Name = "buttonStartGame";
+            this.label2.Location = new System.Drawing.Point(8, 69);
-            this.buttonStartGame.Size = new System.Drawing.Size(75, 23);
+            this.label2.Name = "label2";
-            this.buttonStartGame.TabIndex = 6;
+            this.label2.Size = new System.Drawing.Size(64, 13);
-            this.buttonStartGame.Text = "Start game";
+            this.label2.TabIndex = 9;
-            this.buttonStartGame.UseVisualStyleBackColor = true;
+            this.label2.Text = "Game mode";
-            this.buttonStartGame.Click += new System.EventHandler(this.buttonStartGame_Click);
+            // 
+            // label4
+            // 
+            this.label4.AutoSize = true;
+            this.label4.Location = new System.Drawing.Point(9, 15);
+            this.label4.Name = "label4";
+            this.label4.Size = new System.Drawing.Size(57, 13);
+            this.label4.TabIndex = 8;
+            this.label4.Text = "Map name";
+            // 
+            // labelClientsConnected
+            // 
+            this.labelClientsConnected.AutoSize = true;
+            this.labelClientsConnected.Location = new System.Drawing.Point(131, 147);
+            this.labelClientsConnected.Name = "labelClientsConnected";
+            this.labelClientsConnected.Size = new System.Drawing.Size(80, 13);
+            this.labelClientsConnected.TabIndex = 8;
+            this.labelClientsConnected.Text = "Game clients: 0";
+            // 
+            // label1
+            // 
+            this.label1.AutoSize = true;
+            this.label1.Location = new System.Drawing.Point(8, 38);
+            this.label1.Name = "label1";
+            this.label1.Size = new System.Drawing.Size(53, 13);
+            this.label1.TabIndex = 8;
+            this.label1.Text = "Client limit";
             // 
             // nrOfClients
             // 
-            this.nrOfClients.Location = new System.Drawing.Point(78, 36);
+            this.nrOfClients.Location = new System.Drawing.Point(72, 34);
             this.nrOfClients.Maximum = new decimal(new int[] {
             20,
             0,
@@ -221,105 +287,307 @@
             0,
             0});
             this.nrOfClients.Name = "nrOfClients";
-            this.nrOfClients.Size = new System.Drawing.Size(39, 20);
+            this.nrOfClients.Size = new System.Drawing.Size(163, 20);
             this.nrOfClients.TabIndex = 7;
             this.nrOfClients.Value = new decimal(new int[] {
-            2,
+            10,
             0,
             0,
             0});
             // 
-            // label1
+            // buttonStartGame
             // 
-            this.label1.AutoSize = true;
+            this.buttonStartGame.Dock = System.Windows.Forms.DockStyle.Bottom;
-            this.label1.Location = new System.Drawing.Point(8, 38);
+            this.buttonStartGame.Location = new System.Drawing.Point(0, 166);
-            this.label1.Name = "label1";
+            this.buttonStartGame.Name = "buttonStartGame";
-            this.label1.Size = new System.Drawing.Size(53, 13);
+            this.buttonStartGame.Size = new System.Drawing.Size(241, 22);
-            this.label1.TabIndex = 8;
+            this.buttonStartGame.TabIndex = 6;
-            this.label1.Text = "Client limit";
+            this.buttonStartGame.Text = "Start game";
+            this.buttonStartGame.UseVisualStyleBackColor = true;
+            this.buttonStartGame.Click += new System.EventHandler(this.buttonStartGame_Click);
             // 
-            // label2
+            // panel_clientArea
             // 
-            this.label2.AutoSize = true;
+            this.panel_clientArea.Controls.Add(this.ServerInfoTextArea);
-            this.label2.Location = new System.Drawing.Point(8, 69);
+            this.panel_clientArea.Controls.Add(this.splitter1);
-            this.label2.Name = "label2";
+            this.panel_clientArea.Controls.Add(this.clientInfoBox);
-            this.label2.Size = new System.Drawing.Size(64, 13);
+            this.panel_clientArea.Dock = System.Windows.Forms.DockStyle.Fill;
-            this.label2.TabIndex = 9;
+            this.panel_clientArea.Location = new System.Drawing.Point(241, 0);
-            this.label2.Text = "Game mode";
+            this.panel_clientArea.Name = "panel_clientArea";
+            this.panel_clientArea.Size = new System.Drawing.Size(494, 616);
+            this.panel_clientArea.TabIndex = 8;
             // 
-            // gameModes
+            // ServerInfoTextArea
             // 
-            this.gameModes.DropDownStyle = System.Windows.Forms.ComboBoxStyle.DropDownList;
+            this.ServerInfoTextArea.BackColor = System.Drawing.SystemColors.ActiveCaptionText;
-            this.gameModes.FormattingEnabled = true;
+            this.ServerInfoTextArea.BorderStyle = System.Windows.Forms.BorderStyle.None;
-            this.gameModes.Items.AddRange(new object[] {
+            this.ServerInfoTextArea.Dock = System.Windows.Forms.DockStyle.Fill;
-            "Free-for-all",
+            this.ServerInfoTextArea.Font = new System.Drawing.Font("GulimChe", 8.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
-            "Team death-match"});
+            this.ServerInfoTextArea.ForeColor = System.Drawing.SystemColors.Info;
-            this.gameModes.Location = new System.Drawing.Point(78, 66);
+            this.ServerInfoTextArea.Location = new System.Drawing.Point(0, 269);
-            this.gameModes.Name = "gameModes";
+            this.ServerInfoTextArea.Name = "ServerInfoTextArea";
-            this.gameModes.Size = new System.Drawing.Size(99, 21);
+            this.ServerInfoTextArea.ReadOnly = true;
-            this.gameModes.TabIndex = 10;
+            this.ServerInfoTextArea.Size = new System.Drawing.Size(494, 347);
+            this.ServerInfoTextArea.TabIndex = 1;
+            this.ServerInfoTextArea.Text = "";
             // 
-            // timeLimit
+            // splitter1
             // 
-            this.timeLimit.Location = new System.Drawing.Point(109, 94);
+            this.splitter1.Dock = System.Windows.Forms.DockStyle.Top;
-            this.timeLimit.Minimum = new decimal(new int[] {
+            this.splitter1.Location = new System.Drawing.Point(0, 264);
-            5,
+            this.splitter1.Name = "splitter1";
-            0,
+            this.splitter1.Size = new System.Drawing.Size(494, 5);
-            0,
+            this.splitter1.TabIndex = 2;
-            0});
+            this.splitter1.TabStop = false;
-            this.timeLimit.Name = "timeLimit";
-            this.timeLimit.Size = new System.Drawing.Size(68, 20);
-            this.timeLimit.TabIndex = 11;
-            this.timeLimit.ThousandsSeparator = true;
-            this.timeLimit.Value = new decimal(new int[] {
-            5,
-            0,
-            0,
-            0});
             // 
-            // label3
+            // clientInfoBox
             // 
-            this.label3.AutoSize = true;
+            this.clientInfoBox.Dock = System.Windows.Forms.DockStyle.Top;
-            this.label3.Location = new System.Drawing.Point(8, 96);
+            this.clientInfoBox.FormattingEnabled = true;
-            this.label3.Name = "label3";
+            this.clientInfoBox.Location = new System.Drawing.Point(0, 0);
-            this.label3.Size = new System.Drawing.Size(95, 13);
+            this.clientInfoBox.Name = "clientInfoBox";
-            this.label3.TabIndex = 9;
+            this.clientInfoBox.Size = new System.Drawing.Size(494, 264);
-            this.label3.Text = "Time limit (minutes)";
+            this.clientInfoBox.TabIndex = 0;
             // 
-            // label4
+            // panel_CommanArea
             // 
-            this.label4.AutoSize = true;
+            this.panel_CommanArea.Controls.Add(this.panelServerCommands);
-            this.label4.Location = new System.Drawing.Point(9, 15);
+            this.panel_CommanArea.Controls.Add(this.panel_commands);
-            this.label4.Name = "label4";
+            this.panel_CommanArea.Controls.Add(this.panel_serverOptions);
-            this.label4.Size = new System.Drawing.Size(57, 13);
+            this.panel_CommanArea.Dock = System.Windows.Forms.DockStyle.Left;
-            this.label4.TabIndex = 8;
+            this.panel_CommanArea.Location = new System.Drawing.Point(0, 0);
-            this.label4.Text = "Map name";
+            this.panel_CommanArea.Name = "panel_CommanArea";
+            this.panel_CommanArea.Size = new System.Drawing.Size(241, 616);
+            this.panel_CommanArea.TabIndex = 9;
+            // 
+            // label5
+            // 
+            this.label5.AutoSize = true;
+            this.label5.Location = new System.Drawing.Point(23, 147);
+            this.label5.Name = "label5";
+            this.label5.Size = new System.Drawing.Size(81, 13);
+            this.label5.TabIndex = 8;
+            this.label5.Text = "Lobby clients: 0";
             // 
             // mapName
             // 
-            this.mapName.Location = new System.Drawing.Point(78, 7);
+            this.mapName.DropDownStyle = System.Windows.Forms.ComboBoxStyle.DropDownList;
+            this.mapName.FormattingEnabled = true;
+            this.mapName.IntegralHeight = false;
+            this.mapName.Items.AddRange(new object[] {
+            "Set default"});
+            this.mapName.Location = new System.Drawing.Point(72, 7);
             this.mapName.Name = "mapName";
-            this.mapName.Size = new System.Drawing.Size(98, 20);
+            this.mapName.Size = new System.Drawing.Size(163, 21);
-            this.mapName.TabIndex = 12;
+            this.mapName.TabIndex = 10;
+            // 
+            // panelServerCommands
+            // 
+            this.panelServerCommands.Controls.Add(this.dataProtocolFields);
+            this.panelServerCommands.Dock = System.Windows.Forms.DockStyle.Top;
+            this.panelServerCommands.Location = new System.Drawing.Point(0, 291);
+            this.panelServerCommands.Name = "panelServerCommands";
+            this.panelServerCommands.Size = new System.Drawing.Size(241, 85);
+            this.panelServerCommands.TabIndex = 8;
+            this.panelServerCommands.Visible = false;
+            // 
+            // buttonExecuteSend
+            // 
+            this.buttonExecuteSend.Dock = System.Windows.Forms.DockStyle.Fill;
+            this.buttonExecuteSend.FlatStyle = System.Windows.Forms.FlatStyle.Flat;
+            this.buttonExecuteSend.Location = new System.Drawing.Point(116, 0);
+            this.buttonExecuteSend.Margin = new System.Windows.Forms.Padding(0);
+            this.buttonExecuteSend.Name = "buttonExecuteSend";
+            this.buttonExecuteSend.Size = new System.Drawing.Size(117, 21);
+            this.buttonExecuteSend.TabIndex = 0;
+            this.buttonExecuteSend.Text = "Send";
+            this.buttonExecuteSend.UseVisualStyleBackColor = true;
+            // 
+            // panel2
+            // 
+            this.panel2.Controls.Add(this.button2);
+            this.panel2.Controls.Add(this.textBox1);
+            this.panel2.Controls.Add(this.comboBox1);
+            this.panel2.Controls.Add(this.numericUpDown1);
+            this.panel2.Dock = System.Windows.Forms.DockStyle.Fill;
+            this.panel2.Location = new System.Drawing.Point(4, 32);
+            this.panel2.Name = "panel2";
+            this.panel2.Size = new System.Drawing.Size(233, 21);
+            this.panel2.TabIndex = 0;
+            // 
+            // comboBox1
+            // 
+            this.comboBox1.Dock = System.Windows.Forms.DockStyle.Left;
+            this.comboBox1.DropDownStyle = System.Windows.Forms.ComboBoxStyle.DropDownList;
+            this.comboBox1.FormattingEnabled = true;
+            this.comboBox1.IntegralHeight = false;
+            this.comboBox1.Items.AddRange(new object[] {
+            "netBool;",
+            "netChar;",
+            "netUChar;",
+            "netShort;",
+            "netUShort;",
+            "netInt;",
+            "netUInt;",
+            "netInt64;",
+            "netUInt64;",
+            "netFloat;",
+            "netDouble;",
+            "netCharPtr;"});
+            this.comboBox1.Location = new System.Drawing.Point(42, 0);
+            this.comboBox1.Name = "comboBox1";
+            this.comboBox1.Size = new System.Drawing.Size(78, 21);
+            this.comboBox1.TabIndex = 10;
+            // 
+            // numericUpDown1
+            // 
+            this.numericUpDown1.Dock = System.Windows.Forms.DockStyle.Left;
+            this.numericUpDown1.Location = new System.Drawing.Point(0, 0);
+            this.numericUpDown1.Name = "numericUpDown1";
+            this.numericUpDown1.Size = new System.Drawing.Size(42, 20);
+            this.numericUpDown1.TabIndex = 11;
+            // 
+            // textBox1
+            // 
+            this.textBox1.Dock = System.Windows.Forms.DockStyle.Left;
+            this.textBox1.Location = new System.Drawing.Point(120, 0);
+            this.textBox1.Name = "textBox1";
+            this.textBox1.Size = new System.Drawing.Size(64, 20);
+            this.textBox1.TabIndex = 12;
+            // 
+            // tableLayoutPanel1
+            // 
+            this.tableLayoutPanel1.CellBorderStyle = System.Windows.Forms.TableLayoutPanelCellBorderStyle.Single;
+            this.tableLayoutPanel1.ColumnCount = 3;
+            this.tableLayoutPanel1.ColumnStyles.Add(new System.Windows.Forms.ColumnStyle(System.Windows.Forms.SizeType.Percent, 35.29412F));
+            this.tableLayoutPanel1.ColumnStyles.Add(new System.Windows.Forms.ColumnStyle(System.Windows.Forms.SizeType.Percent, 64.70588F));
+            this.tableLayoutPanel1.ColumnStyles.Add(new System.Windows.Forms.ColumnStyle(System.Windows.Forms.SizeType.Absolute, 110F));
+            this.tableLayoutPanel1.Controls.Add(this.label6, 0, 0);
+            this.tableLayoutPanel1.Controls.Add(this.label7, 1, 0);
+            this.tableLayoutPanel1.Controls.Add(this.label8, 2, 0);
+            this.tableLayoutPanel1.Dock = System.Windows.Forms.DockStyle.Fill;
+            this.tableLayoutPanel1.Location = new System.Drawing.Point(4, 4);
+            this.tableLayoutPanel1.Name = "tableLayoutPanel1";
+            this.tableLayoutPanel1.RowCount = 1;
+            this.tableLayoutPanel1.RowStyles.Add(new System.Windows.Forms.RowStyle(System.Windows.Forms.SizeType.Percent, 27.05882F));
+            this.tableLayoutPanel1.Size = new System.Drawing.Size(233, 21);
+            this.tableLayoutPanel1.TabIndex = 9;
+            // 
+            // label6
+            // 
+            this.label6.AutoSize = true;
+            this.label6.Location = new System.Drawing.Point(4, 1);
+            this.label6.Name = "label6";
+            this.label6.Size = new System.Drawing.Size(18, 13);
+            this.label6.TabIndex = 8;
+            this.label6.Text = "ID";
+            this.label6.TextAlign = System.Drawing.ContentAlignment.MiddleCenter;
+            // 
+            // label7
+            // 
+            this.label7.AutoSize = true;
+            this.label7.Location = new System.Drawing.Point(46, 1);
+            this.label7.Name = "label7";
+            this.label7.Size = new System.Drawing.Size(31, 13);
+            this.label7.TabIndex = 8;
+            this.label7.Text = "Type";
+            // 
+            // label8
+            // 
+            this.label8.AutoSize = true;
+            this.label8.Location = new System.Drawing.Point(123, 1);
+            this.label8.Name = "label8";
+            this.label8.Size = new System.Drawing.Size(34, 13);
+            this.label8.TabIndex = 8;
+            this.label8.Text = "Value";
+            // 
+            // dataProtocolFields
+            // 
+            this.dataProtocolFields.CellBorderStyle = System.Windows.Forms.TableLayoutPanelCellBorderStyle.Single;
+            this.dataProtocolFields.ColumnCount = 1;
+            this.dataProtocolFields.ColumnStyles.Add(new System.Windows.Forms.ColumnStyle(System.Windows.Forms.SizeType.Absolute, 21F));
+            this.dataProtocolFields.Controls.Add(this.panel2, 0, 1);
+            this.dataProtocolFields.Controls.Add(this.tableLayoutPanel1, 0, 0);
+            this.dataProtocolFields.Controls.Add(this.buttonsAtBottom, 0, 2);
+            this.dataProtocolFields.Dock = System.Windows.Forms.DockStyle.Fill;
+            this.dataProtocolFields.Location = new System.Drawing.Point(0, 0);
+            this.dataProtocolFields.Margin = new System.Windows.Forms.Padding(0);
+            this.dataProtocolFields.Name = "dataProtocolFields";
+            this.dataProtocolFields.RowCount = 3;
+            this.dataProtocolFields.RowStyles.Add(new System.Windows.Forms.RowStyle(System.Windows.Forms.SizeType.Absolute, 27F));
+            this.dataProtocolFields.RowStyles.Add(new System.Windows.Forms.RowStyle(System.Windows.Forms.SizeType.Absolute, 27F));
+            this.dataProtocolFields.RowStyles.Add(new System.Windows.Forms.RowStyle(System.Windows.Forms.SizeType.Absolute, 20F));
+            this.dataProtocolFields.Size = new System.Drawing.Size(241, 85);
+            this.dataProtocolFields.TabIndex = 9;
+            // 
+            // buttonAddNewDataField
+            // 
+            this.buttonAddNewDataField.Dock = System.Windows.Forms.DockStyle.Fill;
+            this.buttonAddNewDataField.FlatStyle = System.Windows.Forms.FlatStyle.Flat;
+            this.buttonAddNewDataField.Location = new System.Drawing.Point(0, 0);
+            this.buttonAddNewDataField.Margin = new System.Windows.Forms.Padding(0);
+            this.buttonAddNewDataField.Name = "buttonAddNewDataField";
+            this.buttonAddNewDataField.Size = new System.Drawing.Size(116, 21);
+            this.buttonAddNewDataField.TabIndex = 1;
+            this.buttonAddNewDataField.Text = "Add field";
+            this.buttonAddNewDataField.UseVisualStyleBackColor = true;
+            this.buttonAddNewDataField.Click += new System.EventHandler(this.buttonAddNewDataField_Click);
+            // 
+            // button2
+            // 
+            this.button2.Dock = System.Windows.Forms.DockStyle.Fill;
+            this.button2.FlatAppearance.BorderColor = System.Drawing.Color.Black;
+            this.button2.FlatStyle = System.Windows.Forms.FlatStyle.Flat;
+            this.button2.Location = new System.Drawing.Point(184, 0);
+            this.button2.Margin = new System.Windows.Forms.Padding(0);
+            this.button2.Name = "button2";
+            this.button2.Size = new System.Drawing.Size(49, 21);
+            this.button2.TabIndex = 0;
+            this.button2.Text = "remove";
+            this.button2.UseVisualStyleBackColor = true;
+            // 
+            // buttonsAtBottom
+            // 
+            this.buttonsAtBottom.ColumnCount = 2;
+            this.buttonsAtBottom.ColumnStyles.Add(new System.Windows.Forms.ColumnStyle(System.Windows.Forms.SizeType.Percent, 50F));
+            this.buttonsAtBottom.ColumnStyles.Add(new System.Windows.Forms.ColumnStyle(System.Windows.Forms.SizeType.Percent, 50F));
+            this.buttonsAtBottom.Controls.Add(this.buttonAddNewDataField, 0, 0);
+            this.buttonsAtBottom.Controls.Add(this.buttonExecuteSend, 1, 0);
+            this.buttonsAtBottom.Dock = System.Windows.Forms.DockStyle.Fill;
+            this.buttonsAtBottom.Location = new System.Drawing.Point(4, 60);
+            this.buttonsAtBottom.Name = "buttonsAtBottom";
+            this.buttonsAtBottom.RowCount = 1;
+            this.buttonsAtBottom.RowStyles.Add(new System.Windows.Forms.RowStyle(System.Windows.Forms.SizeType.Percent, 50F));
+            this.buttonsAtBottom.Size = new System.Drawing.Size(233, 21);
+            this.buttonsAtBottom.TabIndex = 10;
             // 
             // Form1
             // 
             this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
             this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
-            this.ClientSize = new System.Drawing.Size(517, 373);
+            this.ClientSize = new System.Drawing.Size(735, 616);
             this.Controls.Add(this.panel_clientArea);
-            this.Controls.Add(this.panel_commands);
+            this.Controls.Add(this.panel_CommanArea);
-            this.Controls.Add(this.panel_serverOptions);
             this.Name = "Form1";
             this.Text = "Form1";
+            this.FormClosing += new System.Windows.Forms.FormClosingEventHandler(this.FormClosingEvent);
             ((System.ComponentModel.ISupportInitialize)(this.listenPort)).EndInit();
             this.panel_serverOptions.ResumeLayout(false);
             this.panel_serverOptions.PerformLayout();
             this.panel_commands.ResumeLayout(false);
             this.panel_commands.PerformLayout();
-            this.panel_clientArea.ResumeLayout(false);
-            ((System.ComponentModel.ISupportInitialize)(this.nrOfClients)).EndInit();
             ((System.ComponentModel.ISupportInitialize)(this.timeLimit)).EndInit();
+            ((System.ComponentModel.ISupportInitialize)(this.nrOfClients)).EndInit();
+            this.panel_clientArea.ResumeLayout(false);
+            this.panel_CommanArea.ResumeLayout(false);
+            this.panelServerCommands.ResumeLayout(false);
+            this.panel2.ResumeLayout(false);
+            this.panel2.PerformLayout();
+            ((System.ComponentModel.ISupportInitialize)(this.numericUpDown1)).EndInit();
+            this.tableLayoutPanel1.ResumeLayout(false);
+            this.tableLayoutPanel1.PerformLayout();
+            this.dataProtocolFields.ResumeLayout(false);
+            this.buttonsAtBottom.ResumeLayout(false);
             this.ResumeLayout(false);
 
         }
@@ -346,7 +614,25 @@
         private System.Windows.Forms.NumericUpDown timeLimit;
         private System.Windows.Forms.Label label3;
         private System.Windows.Forms.Label label4;
-        private System.Windows.Forms.TextBox mapName;
+        private System.Windows.Forms.CheckBox forceStart;
+        private System.Windows.Forms.Label labelClientsConnected;
+        private System.Windows.Forms.Panel panel_CommanArea;
+        private System.Windows.Forms.Label label5;
+        private System.Windows.Forms.ComboBox mapName;
+        private System.Windows.Forms.Panel panelServerCommands;
+        private System.Windows.Forms.Button buttonExecuteSend;
+        private System.Windows.Forms.Panel panel2;
+        private System.Windows.Forms.ComboBox comboBox1;
+        private System.Windows.Forms.TextBox textBox1;
+        private System.Windows.Forms.NumericUpDown numericUpDown1;
+        private System.Windows.Forms.TableLayoutPanel dataProtocolFields;
+        private System.Windows.Forms.TableLayoutPanel tableLayoutPanel1;
+        private System.Windows.Forms.Label label6;
+        private System.Windows.Forms.Label label7;
+        private System.Windows.Forms.Label label8;
+        private System.Windows.Forms.Button buttonAddNewDataField;
+        private System.Windows.Forms.Button button2;
+        private System.Windows.Forms.TableLayoutPanel buttonsAtBottom;
     }
 }
 

Code/Game/LanServer/StandAloneLauncher/Form1.cs

@@ -9,6 +9,9 @@ using System.Threading.Tasks;
 using System.Windows.Forms;
 using System.Windows.Interop;
 using System.Runtime.InteropServices;
+using System.Threading;
+using System.Timers;
+using System.IO;
 
 namespace StandAloneLauncher
 {
@@ -16,12 +19,22 @@ namespace StandAloneLauncher
     {
         System.Windows.Interop.StandaloneGameServerCLI gameServer;
         bool serverIsRunning = false;
+        bool gameIsStarted = false;
 
         public Form1()
         {
             InitializeComponent();
 
+            string[] maps = Directory.GetFiles("..\\Content\\Worlds\\");
 
+            for (int i = 0; i < maps.Length; i++)
+            {
+                string temp = maps[i].Split('\\').Last() ;
+                this.mapName.Items.Add(temp);
+            }
+
+            this.gameModes.SelectedIndex = 0;
+            this.mapName.SelectedIndex = 0;
         }
 
         public bool Initiate()
@@ -30,14 +43,14 @@ namespace StandAloneLauncher
 
             return true;
         }
+     
         public void Run()
         {
             while (this.Created)
             {
                 Application.DoEvents();
-
-                //Do some stuff
                 this.gameServer.ServerUpdate();
+                this.labelClientsConnected.Text = "Clients connected: " + this.gameServer.GetClientsConnectedCount().ToString();
             }
         }
         
@@ -53,6 +66,7 @@ namespace StandAloneLauncher
                 this.serverToggle.Text = "Start server";
                 this.ServerInfoTextArea.AppendText(DateTime.Now.ToUniversalTime() + "\n\t" + "Server terminated!\n");
                 this.panel_commands.Visible = false;
+                this.panelServerCommands.Visible = false;
             }
             else
             {
@@ -75,6 +89,7 @@ namespace StandAloneLauncher
                     this.gameServer.ServerStart();
                     this.panel_commands.Visible = true;
                     this.ServerInfoTextArea.AppendText(DateTime.Now.ToUniversalTime() + "\n\t" + "Server initiated!\n\tListening on port " + this.listenPort.Value.ToString() + "\n\tLocal IP: " + info.serverIp + "\n");
+                    this.panelServerCommands.Visible = true;
                 }
                 else
                 {
@@ -85,18 +100,59 @@ namespace StandAloneLauncher
 
         private void buttonStartGame_Click(object sender, EventArgs e)
         {
-            //this.gameServer.GameSetGameMode(this.gameModes.SelectedText);
+            if (!gameIsStarted)
-            this.gameServer.GameSetGameTime((int)this.timeLimit.Value);
-            //this.gameServer.GameSetMapId(0);
-            this.gameServer.GameSetMaxClients((int)this.nrOfClients.Value);
-            if (!this.gameServer.GameStart())
             {
-                this.ServerInfoTextArea.AppendText(DateTime.Now.ToUniversalTime() + "\n\t" + "Failed to start the game session!\n");
+                //this.gameServer.GameSetGameMode(this.gameModes.SelectedText);
+                this.gameServer.GameSetGameTime((int)this.timeLimit.Value);
+                this.gameServer.GameSetMapName(this.mapName.Text);
+                this.gameServer.GameSetMaxClients((int)this.nrOfClients.Value);
+
+                if (!(gameIsStarted = this.gameServer.GameStart(this.forceStart.Checked)))
+                {
+                    this.ServerInfoTextArea.AppendText(DateTime.Now.ToUniversalTime() + "\n\t" + "Failed to start the game session!\n");
+                }
+                else
+                {
+                    this.ServerInfoTextArea.AppendText(DateTime.Now.ToUniversalTime() + "\n\t" + "Game session started!\n");
+                    this.buttonStartGame.Text = "Stop Game";
+
+                    this.mapName.Enabled = false;
+                    this.nrOfClients.Enabled = false;
+                    this.gameModes.Enabled = false;
+                    this.timeLimit.Enabled = false;
+                    this.forceStart.Enabled = false;
+                }
             }
             else
             {
-                this.ServerInfoTextArea.AppendText(DateTime.Now.ToUniversalTime() + "\n\t" + "Game session started!\n");
+                this.gameIsStarted = false;
+                this.buttonStartGame.Text = "Start Game";
+                this.mapName.Enabled        = true;
+                this.nrOfClients.Enabled    = true;
+                this.gameModes.Enabled      = true;
+                this.timeLimit.Enabled      = true;
+                this.forceStart.Enabled     = true;
             }
         }
+
+        private void FormClosingEvent(object sender, FormClosingEventArgs e)
+        {
+            if (serverIsRunning)
+            {
+                this.gameServer.ServerStop();
+            }
+        }
+
+        private void buttonAddNewDataField_Click(object sender, EventArgs e)
+        {
+            this.dataProtocolFields.RowCount++;
+            this.dataProtocolFields.SetRow(this.buttonsAtBottom, this.dataProtocolFields.RowCount - 1);
+
+            Panel p = new Panel();
+            p = this.panel2;
+
+            this.dataProtocolFields.RowStyles.Add(new RowStyle(SizeType.Absolute, 27));
+            
+        }
     }
 }

Code/Game/LanServer/StandAloneLauncher/Properties/Settings.Designer.cs

@@ -8,23 +8,31 @@
 // </auto-generated>
 //------------------------------------------------------------------------------
 
-namespace StandAloneLauncher.Properties
+namespace StandAloneLauncher.Properties {
-{
     
     
     [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
     [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "11.0.0.0")]
-    internal sealed partial class Settings : global::System.Configuration.ApplicationSettingsBase
+    internal sealed partial class Settings : global::System.Configuration.ApplicationSettingsBase {
-    {
         
         private static Settings defaultInstance = ((Settings)(global::System.Configuration.ApplicationSettingsBase.Synchronized(new Settings())));
         
-        public static Settings Default
+        public static Settings Default {
-        {
+            get {
-            get
-            {
                 return defaultInstance;
             }
         }
+        
+        [global::System.Configuration.UserScopedSettingAttribute()]
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+        [global::System.Configuration.DefaultSettingValueAttribute(".\\..\\Content\\")]
+        public string Dennis {
+            get {
+                return ((string)(this["Dennis"]));
+            }
+            set {
+                this["Dennis"] = value;
+            }
+        }
     }
 }

Code/Game/LanServer/StandAloneLauncher/Properties/Settings.settings

@@ -1,7 +1,9 @@
 <?xml version='1.0' encoding='utf-8'?>
-<SettingsFile xmlns="http://schemas.microsoft.com/VisualStudio/2004/01/settings" CurrentProfile="(Default)">
+<SettingsFile xmlns="http://schemas.microsoft.com/VisualStudio/2004/01/settings" CurrentProfile="(Default)" GeneratedClassNamespace="StandAloneLauncher.Properties" GeneratedClassName="Settings">
-  <Profiles>
+  <Profiles />
-    <Profile Name="(Default)" />
+  <Settings>
-  </Profiles>
+    <Setting Name="Dennis" Type="System.String" Scope="User">
-  <Settings />
+      <Value Profile="(Default)">.\..\Content\</Value>
+    </Setting>
+  </Settings>
 </SettingsFile>

Code/Game/LanServer/StandAloneLauncher/StandAloneLauncher.csproj

@@ -80,6 +80,7 @@
   <ItemGroup>
     <Reference Include="System" />
     <Reference Include="System.Core" />
+    <Reference Include="System.DirectoryServices" />
     <Reference Include="System.Xml.Linq" />
     <Reference Include="System.Data.DataSetExtensions" />
     <Reference Include="Microsoft.CSharp" />

Code/Misc/OysterMath/Quaternion.h

@@ -36,6 +36,7 @@ namespace LinearAlgebra
 		const ScalarType & operator [] ( int i ) const;
 
 		Quaternion<ScalarType> & operator  = ( const Quaternion<ScalarType> &quaternion );
+		Quaternion<ScalarType> & operator *= ( const Quaternion<ScalarType> &quaternion );
 		Quaternion<ScalarType> & operator *= ( const ScalarType &scalar );
 		Quaternion<ScalarType> & operator /= ( const ScalarType &scalar );
 		Quaternion<ScalarType> & operator += ( const Quaternion<ScalarType> &quaternion );
@@ -112,6 +113,12 @@ namespace LinearAlgebra
 		return *this;
 	}
 	
+	template<typename ScalarType>
+	Quaternion<ScalarType> & Quaternion<ScalarType>::operator *= ( const Quaternion<ScalarType> &quaternion )
+	{
+		return *this = *this * quaternion;
+	}
+
 	template<typename ScalarType>
 	Quaternion<ScalarType> & Quaternion<ScalarType>::operator *= ( const ScalarType &scalar )
 	{

Code/Misc/Utilities/Resource/OResourceHandler.cpp

@@ -52,6 +52,8 @@ OHRESOURCE OysterResource::LoadResource(const wchar_t* filename, ResourceType ty
 		}
 	}
 
+	if(!resourceData) return 0;
+
 	return resourceData->GetResourceHandle();
 }
 OHRESOURCE OysterResource::LoadResource(const wchar_t filename[], CustomLoadFunction loadFnc, int customId, bool force)

Code/Network/NetworkAPI/CustomNetProtocol.cpp

@@ -40,12 +40,13 @@ CustomNetProtocol::CustomNetProtocol()
 {
 	this->privateData = new PrivateData();
 }
-CustomNetProtocol::CustomNetProtocol(CustomNetProtocol& o)
+CustomNetProtocol::CustomNetProtocol(const CustomNetProtocol& o)
 {
 	this->privateData = new PrivateData();
 	this->privateData->attributes = o.privateData->attributes;
 }
-const CustomNetProtocol& CustomNetProtocol::operator=(CustomNetProtocol& o)
+
+CustomNetProtocol& CustomNetProtocol::operator=(const CustomNetProtocol& o)
 {
 	if(this->privateData) 
 	{
@@ -56,11 +57,29 @@ const CustomNetProtocol& CustomNetProtocol::operator=(CustomNetProtocol& o)
 	this->privateData->attributes = o.privateData->attributes;
 	return *this;
 }
+
 CustomNetProtocol::~CustomNetProtocol()
 {
 	delete this->privateData;
 	this->privateData = 0;
 }
+
+const NetAttributeContainer& CustomNetProtocol::operator[](int ID) const
+{
+	//if(!this->privateData) this->privateData = new PrivateData();
+	if((unsigned int)ID >= this->privateData->attributes.Size())
+	{
+		NetAttributeContainer temp;
+		
+		temp.type = NetAttributeType_UNKNOWN;
+		memset(&temp.value, 0, sizeof(NetAttributeValue));
+
+		this->privateData->attributes.Push(ID, temp);
+	}
+
+	return this->privateData->attributes[ID];
+}
+
 NetAttributeContainer& CustomNetProtocol::operator[](int ID)
 {
 	//if(!this->privateData) this->privateData = new PrivateData();

Code/Network/NetworkAPI/CustomNetProtocol.h

@@ -130,10 +130,12 @@ namespace Oyster
 			public:
 				CustomNetProtocol();
 				~CustomNetProtocol();
-				CustomNetProtocol(CustomNetProtocol& o);
+				CustomNetProtocol( const CustomNetProtocol& o);
-				const CustomNetProtocol& operator=(CustomNetProtocol& o);
+				CustomNetProtocol& operator=(const CustomNetProtocol& o);
+
+				const NetAttributeContainer& operator[](int ID) const;
+					  NetAttributeContainer& operator[](int ID);
 
-				NetAttributeContainer& operator[](int ID);
 				void Set(int id, Oyster::Network::NetAttributeValue val, Oyster::Network::NetAttributeType type);
 				void Set(int ID, std::string s);
 				const NetAttributeContainer& Get(int id);

Code/Network/NetworkAPI/NetworkClient.cpp

@@ -96,6 +96,10 @@ struct NetworkClient::PrivateData : public IThreadObject
 			//printf("\t(%i)\n", this->sendQueue.Size());
 			OysterByte temp;
 			CustomNetProtocol p = this->sendQueue.Pop();
+
+			if(p[0].value.netShort == 304) 
+				int i = 0;
+
 			this->translator.Pack(temp, p);
 			errorCode = this->connection.Send(temp);
 
@@ -313,6 +317,11 @@ bool NetworkClient::Connect(unsigned short port, std::wstring serverIP)
 	return this->Connect(port, ip.c_str());
 }
 
+bool NetworkClient::Reconnect()
+{
+	return this->privateData->connection.Reconnect();
+}
+
 void NetworkClient::Disconnect()
 {
 	if(!privateData) return;

Code/Network/NetworkAPI/NetworkClient.h

@@ -93,6 +93,11 @@ namespace Oyster
 				*/
 				bool Connect(unsigned short port, std::wstring serverIP);
 
+				/**Tries to connect with the same port and ip it earlier used for Connect.
+				*	
+				*/
+				bool Reconnect();
+
 				/**
 				*	
 				*/
@@ -133,13 +138,7 @@ namespace Oyster
 				*/
 				virtual void DataRecieved(NetEvent<NetworkClient*, ClientEventArgs> e);
 
-				/**	! Deprecate ! 
+				std::string GetIpAddress();
-				*	Do not use this furthermore, instead use void DataRecieved(NetEvent<NetworkClient*, ClientEventArgs> e);
-				*	@see DataRecieved
-				*/
-				//virtual void NetworkCallback(Oyster::Network::CustomNetProtocol& p);
-
-				virtual std::string GetIpAddress();
 
 			private:
 				NetworkClient(const NetworkClient& obj);

Code/Network/NetworkAPI/NetworkSession.h

@@ -98,9 +98,9 @@ namespace Oyster
 
 		protected:
 			NetClientList clients;
+			int clientCount;
 			
 		private:
-			int clientCount;
 			struct PrivateSessionData;
 			PrivateSessionData* data;
 		};

Code/Network/NetworkDependencies/Connection.cpp

@@ -58,6 +58,9 @@ int Connection::Connect(unsigned short port , const char serverName[], bool bloc
 {
 	if(this->socket == -1 || this->socket == 0) InitiateSocket();
 
+	lastConnectPort = port;
+	lastConnectAddr = serverName;
+
 	struct hostent *hostEnt;
 	if((hostEnt = gethostbyname(serverName)) == NULL)
 	{
@@ -83,6 +86,37 @@ int Connection::Connect(unsigned short port , const char serverName[], bool bloc
 	return 0;
 }
 
+int Connection::Reconnect()
+{
+	if(this->socket == -1 || this->socket == 0) InitiateSocket();
+
+	struct hostent *hostEnt;
+	if((hostEnt = gethostbyname(lastConnectAddr.c_str())) == NULL)
+	{
+		return WSAGetLastError();
+	}
+
+	struct sockaddr_in server;
+	server.sin_family = AF_INET;
+	server.sin_port = htons(lastConnectPort);
+	server.sin_addr.s_addr = *(unsigned long*) hostEnt->h_addr;
+
+	SetBlockingMode(true);
+
+	if(connect(this->socket, (sockaddr*)&server, sizeof(server)) == SOCKET_ERROR)
+	{
+		return WSAGetLastError();
+	}
+	
+	closed = false;
+	stillSending = true;
+
+	SetBlockingMode(blocking);
+
+	//connection succesfull!
+	return 0;
+}
+
 int Connection::InitiateServer(unsigned short port)
 {
 	int errorCode = 0;

Code/Network/NetworkDependencies/Connection.h

@@ -28,6 +28,7 @@ namespace Oyster
 			virtual int Disconnect();
 			virtual int Connect(ConnectionInfo info, bool blocking = false);
 			virtual int Connect(unsigned short port , const char serverName[], bool blocking = false);
+			virtual int Reconnect();
 			
 			virtual ConnectionInfo Listen();
 
@@ -47,6 +48,11 @@ namespace Oyster
 			bool stillSending;
 			bool closed;
 			std::string addr;
+
+			std::string lastConnectAddr;
+			unsigned short lastConnectPort;
+
+			bool blocking;
 		};
 	}
 }

Code/Network/NetworkDependencies/IConnection.h

@@ -39,6 +39,9 @@ namespace Oyster
 			//(servers uses Listen instead of connect)
 			virtual int Connect( unsigned short port, const char serverName[] ) { return false; };
 
+			//Tries to connect with the same port and ip used for Connect.
+			virtual int Reconnect() = 0;
+
 			//Disconnects the client or server TODO: optimize!
 			virtual int Disconnect() = 0;
 		};

Code/OysterGraphics/DllInterfaces/GFXAPI.cpp

@@ -197,6 +197,7 @@ namespace Oyster
 		void API::StartRenderWireFrame()
 		{
 			Core::deviceContext->RSSetState(wire);
+			Core::deviceContext->OMSetRenderTargets(Render::Resources::Gather::Pass.RTV.size(),&Render::Resources::Gather::Pass.RTV[0],NULL);
 		}
 
 		void API::RenderDebugCube(Math::Matrix world)

Code/OysterGraphics/Render/Resources.cpp

@@ -338,8 +338,8 @@ namespace Oyster
 					dTDesc.BindFlags = D3D11_BIND_DEPTH_STENCIL;
 					dTDesc.CPUAccessFlags=0;
 					dTDesc.MiscFlags=0;
-					dTDesc.Height = Core::resolution.y;
+					dTDesc.Height = (UINT)Core::resolution.y;
-					dTDesc.Width = Core::resolution.x;
+					dTDesc.Width = (UINT)Core::resolution.x;
 					dTDesc.SampleDesc.Count=1;
 					dTDesc.SampleDesc.Quality=0;
 

Code/Physics/Bullet Source/BulletFileLoader/CMakeLists.txt

@@ -0,0 +1,49 @@
+INCLUDE_DIRECTORIES( 
+	${BULLET_PHYSICS_SOURCE_DIR}/src  
+)
+
+SET(BulletFileLoader_SRCS
+bChunk.cpp
+bDNA.cpp
+bFile.cpp
+btBulletFile.cpp
+)
+
+SET(BulletFileLoader_HDRS
+bChunk.h
+bCommon.h
+bDefines.h
+bDNA.h
+bFile.h
+btBulletFile.h
+)
+
+ADD_LIBRARY(BulletFileLoader ${BulletFileLoader_SRCS} ${BulletFileLoader_HDRS})
+
+IF (BUILD_SHARED_LIBS)
+        TARGET_LINK_LIBRARIES(BulletFileLoader LinearMath)
+ENDIF (BUILD_SHARED_LIBS)
+
+SET_TARGET_PROPERTIES(BulletFileLoader PROPERTIES VERSION ${BULLET_VERSION}) 
+SET_TARGET_PROPERTIES(BulletFileLoader PROPERTIES SOVERSION ${BULLET_VERSION})
+
+IF (INSTALL_EXTRA_LIBS)
+        IF (NOT INTERNAL_CREATE_DISTRIBUTABLE_MSVC_PROJECTFILES)
+                #FILES_MATCHING requires CMake 2.6
+                IF (${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION} GREATER 2.5)
+                        IF (APPLE AND BUILD_SHARED_LIBS AND FRAMEWORK)
+                                INSTALL(TARGETS BulletFileLoader DESTINATION .)
+                        ELSE (APPLE AND BUILD_SHARED_LIBS AND FRAMEWORK)
+                                INSTALL(TARGETS BulletFileLoader DESTINATION lib${LIB_SUFFIX})
+                                INSTALL(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+DESTINATION ${INCLUDE_INSTALL_DIR} FILES_MATCHING PATTERN "*.h"  PATTERN
+".svn" EXCLUDE PATTERN "CMakeFiles" EXCLUDE)
+                        ENDIF (APPLE AND BUILD_SHARED_LIBS AND FRAMEWORK)
+                ENDIF (${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION} GREATER 2.5)
+
+                IF (APPLE AND BUILD_SHARED_LIBS AND FRAMEWORK)
+                        SET_TARGET_PROPERTIES(BulletFileLoader PROPERTIES FRAMEWORK true)
+                        SET_TARGET_PROPERTIES(BulletFileLoader PROPERTIES PUBLIC_HEADER "${BulletFileLoader_HDRS}")
+                ENDIF (APPLE AND BUILD_SHARED_LIBS AND FRAMEWORK)
+        ENDIF (NOT INTERNAL_CREATE_DISTRIBUTABLE_MSVC_PROJECTFILES)
+ENDIF (INSTALL_EXTRA_LIBS)

Code/Physics/Bullet Source/BulletFileLoader/bChunk.cpp

@@ -0,0 +1,75 @@
+/*
+bParse
+Copyright (c) 2006-2009 Charlie C & Erwin Coumans  http://gamekit.googlecode.com
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#include "bChunk.h"
+#include "bDefines.h"
+#include "bFile.h"
+
+#if !defined( __CELLOS_LV2__) && !defined(__MWERKS__)
+#include <memory.h>
+#endif
+#include <string.h>
+
+
+using namespace bParse;
+
+
+// ----------------------------------------------------- //
+short ChunkUtils::swapShort(short sht)
+{
+	SWITCH_SHORT(sht);
+	return sht;
+}
+
+// ----------------------------------------------------- //
+int ChunkUtils::swapInt(int inte)
+{
+	SWITCH_INT(inte);
+	return inte;
+}
+
+// ----------------------------------------------------- //
+long64 ChunkUtils::swapLong64(long64 lng)
+{
+	SWITCH_LONGINT(lng);
+	return lng;
+}
+
+// ----------------------------------------------------- //
+int ChunkUtils::getOffset(int flags)
+{
+	// if the file is saved in a
+	// different format, get the
+	// file's chunk size
+	int res = CHUNK_HEADER_LEN;
+
+	if (VOID_IS_8)
+	{
+		if (flags &FD_BITS_VARIES)
+			res = sizeof(bChunkPtr4);
+	}
+	else
+	{
+		if (flags &FD_BITS_VARIES)
+			res = sizeof(bChunkPtr8);
+	}
+	return res;
+}
+
+
+
+
+
+//eof

Code/Physics/Bullet Source/BulletFileLoader/bChunk.h

@@ -0,0 +1,92 @@
+/*
+bParse
+Copyright (c) 2006-2009 Charlie C & Erwin Coumans  http://gamekit.googlecode.com
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef __BCHUNK_H__
+#define __BCHUNK_H__
+
+#if defined (_WIN32) && ! defined (__MINGW32__)
+	#define long64 __int64
+#elif defined (__MINGW32__)	
+	#include <stdint.h>
+	#define long64 int64_t
+#else
+	#define long64 long long
+#endif
+
+
+namespace bParse {
+
+
+	// ----------------------------------------------------- //
+	class bChunkPtr4
+	{
+	public:
+		bChunkPtr4(){}
+		int code;
+		int len;
+		union
+		{
+			int m_uniqueInt;
+		};
+		int dna_nr;
+		int nr;
+	};
+
+	// ----------------------------------------------------- //
+	class bChunkPtr8
+	{
+	public:
+		bChunkPtr8(){}
+		int code,  len;
+		union
+		{
+			long64 oldPrev;
+			int	m_uniqueInts[2];
+		};
+		int dna_nr, nr;
+	};
+
+	// ----------------------------------------------------- //
+	class bChunkInd
+	{
+	public:
+		bChunkInd(){}
+		int code, len;
+		void *oldPtr;
+		int dna_nr, nr;
+	};
+
+
+	// ----------------------------------------------------- //
+	class ChunkUtils
+	{
+	public:
+		
+		// file chunk offset
+		static int getOffset(int flags);
+
+		// endian utils
+		static short swapShort(short sht);
+		static int swapInt(int inte);
+		static long64 swapLong64(long64 lng);
+
+	};
+
+
+	const int CHUNK_HEADER_LEN = ((sizeof(bChunkInd)));
+	const bool VOID_IS_8 = ((sizeof(void*)==8));
+}
+
+#endif//__BCHUNK_H__

Code/Physics/Bullet Source/BulletFileLoader/bCommon.h

@@ -0,0 +1,39 @@
+/*
+bParse
+Copyright (c) 2006-2009 Charlie C & Erwin Coumans  http://gamekit.googlecode.com
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef __BCOMMON_H__
+#define __BCOMMON_H__
+
+
+#include <assert.h>
+//#include "bLog.h"
+#include "LinearMath/btAlignedObjectArray.h"
+#include "LinearMath/btHashMap.h"
+
+namespace bParse {
+
+	class bMain;
+	class bFileData;
+	class bFile;
+	class bDNA;
+
+	// delete void* undefined
+	typedef struct bStructHandle {int unused;}bStructHandle;
+	typedef btAlignedObjectArray<bStructHandle*>	bListBasePtr;
+	typedef btHashMap<btHashPtr, bStructHandle*> bPtrMap;
+}
+
+
+#endif//__BCOMMON_H__

Code/Physics/Bullet Source/BulletFileLoader/bDNA.cpp

@@ -0,0 +1,644 @@
+/*
+bParse
+Copyright (c) 2006-2009 Charlie C & Erwin Coumans  http://gamekit.googlecode.com
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+#include <assert.h>
+
+#include "bDNA.h"
+#include "bChunk.h"
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+//this define will force traversal of structures, to check backward (and forward) compatibility
+//#define TEST_BACKWARD_FORWARD_COMPATIBILITY
+
+
+using namespace bParse;
+
+
+// ----------------------------------------------------- //
+bDNA::bDNA()
+	:	mPtrLen(0)
+{
+	// --
+}
+
+// ----------------------------------------------------- //
+bDNA::~bDNA()
+{
+	// --
+}
+
+// ----------------------------------------------------- //
+bool bDNA::lessThan(bDNA *file)
+{
+	return ( m_Names.size() < file->m_Names.size());
+}
+
+// ----------------------------------------------------- //
+char *bDNA::getName(int ind)
+{
+	assert(ind <= (int)m_Names.size());
+	return m_Names[ind].m_name;
+}
+
+
+// ----------------------------------------------------- //
+char *bDNA::getType(int ind)
+{
+	assert(ind<=  (int)mTypes.size());
+	return mTypes[ind];
+}
+
+
+// ----------------------------------------------------- //
+short *bDNA::getStruct(int ind)
+{
+	assert(ind <=  (int)mStructs.size());
+	return mStructs[ind];
+}
+
+
+// ----------------------------------------------------- //
+short bDNA::getLength(int ind)
+{
+	assert(ind <=  (int)mTlens.size());
+	return mTlens[ind];
+}
+
+
+// ----------------------------------------------------- //
+int bDNA::getReverseType(short type)
+{
+
+	int* intPtr = mStructReverse.find(type);
+	if (intPtr)
+		return *intPtr;
+
+	return -1;
+}
+
+// ----------------------------------------------------- //
+int bDNA::getReverseType(const char *type)
+{
+
+	btHashString key(type);
+	int* valuePtr = mTypeLookup.find(key);
+	if (valuePtr)
+		return *valuePtr;
+	
+	return -1;
+}
+
+// ----------------------------------------------------- //
+int bDNA::getNumStructs()
+{
+	return (int)mStructs.size();
+}
+
+// ----------------------------------------------------- //
+bool bDNA::flagNotEqual(int dna_nr)
+{
+	assert(dna_nr <=	(int)mCMPFlags.size());
+	return mCMPFlags[dna_nr] == FDF_STRUCT_NEQU;
+}
+
+// ----------------------------------------------------- //
+bool bDNA::flagEqual(int dna_nr)
+{
+	assert(dna_nr <=	(int)mCMPFlags.size());
+	int flag = mCMPFlags[dna_nr];
+	return  flag == FDF_STRUCT_EQU;
+}
+
+// ----------------------------------------------------- //
+bool bDNA::flagNone(int dna_nr)
+{
+	assert(dna_nr <=	(int)mCMPFlags.size());
+	return mCMPFlags[dna_nr] == FDF_NONE;
+}
+
+// ----------------------------------------------------- //
+int bDNA::getPointerSize()
+{
+	return mPtrLen;
+}
+
+// ----------------------------------------------------- //
+void bDNA::initRecurseCmpFlags(int iter)
+{
+	// iter is FDF_STRUCT_NEQU
+
+	short *oldStrc = mStructs[iter];
+	short type = oldStrc[0];
+
+	for (int i=0; i<(int)mStructs.size(); i++)
+	{
+		if (i != iter && mCMPFlags[i] == FDF_STRUCT_EQU )
+		{
+			short *curStruct = mStructs[i];
+			int eleLen = curStruct[1];
+			curStruct+=2;
+
+			for (int j=0; j<eleLen; j++, curStruct+=2)
+			{
+				if (curStruct[0] == type)
+				{
+					//char *name = m_Names[curStruct[1]].m_name;
+					//if (name[0] != '*')
+					if (m_Names[curStruct[1]].m_isPointer)
+					{
+						mCMPFlags[i] = FDF_STRUCT_NEQU;
+						initRecurseCmpFlags(i);
+					}
+				}
+			}
+		}
+	}
+}
+
+// ----------------------------------------------------- //
+void bDNA::initCmpFlags(bDNA *memDNA)
+{
+
+    // compare the file to memory
+	// this ptr should be the file data
+
+
+	assert(!m_Names.size() == 0 && "SDNA empty!");
+	mCMPFlags.resize(mStructs.size(), FDF_NONE);
+
+
+
+	int i;
+	for ( i=0; i<(int)mStructs.size(); i++)
+	{
+		short *oldStruct = mStructs[i];
+
+		int oldLookup = getReverseType(oldStruct[0]);
+		if (oldLookup == -1)
+		{
+			mCMPFlags[i] = FDF_NONE;
+			continue;
+		}
+		//char* typeName = mTypes[oldStruct[0]];
+
+//#define SLOW_FORWARD_COMPATIBLE 1
+#ifdef SLOW_FORWARD_COMPATIBLE
+		char* typeName = mTypes[oldLookup];
+		int newLookup = memDNA->getReverseType(typeName);
+		if (newLookup == -1)
+		{
+			mCMPFlags[i] = FDF_NONE;
+			continue;
+		}
+		short *curStruct = memDNA->mStructs[newLookup];
+#else
+		// memory for file
+
+		if (oldLookup < memDNA->mStructs.size())
+		{
+			short *curStruct = memDNA->mStructs[oldLookup];
+#endif	
+	
+		
+
+			// rebuild...
+			mCMPFlags[i] = FDF_STRUCT_NEQU;
+
+#ifndef TEST_BACKWARD_FORWARD_COMPATIBILITY
+
+			if (curStruct[1] == oldStruct[1])
+			{
+				// type len same ...
+				if (mTlens[oldStruct[0]] == memDNA->mTlens[curStruct[0]])
+				{
+					bool isSame = true;
+					int elementLength = oldStruct[1];
+
+
+					curStruct+=2;
+					oldStruct+=2;
+
+
+					for (int j=0; j<elementLength; j++, curStruct+=2, oldStruct+=2)
+					{
+						// type the same
+						//const char* typeFileDNA = mTypes[oldStruct[0]];
+						//const char* typeMemDNA = mTypes[curStruct[0]];
+						if (strcmp(mTypes[oldStruct[0]], memDNA->mTypes[curStruct[0]])!=0)
+						{
+							isSame=false;
+							break;
+						}
+
+						// name the same
+						if (strcmp(m_Names[oldStruct[1]].m_name, memDNA->m_Names[curStruct[1]].m_name)!=0)
+						{
+							isSame=false;
+							break;
+						}
+					}
+					// flag valid ==
+					if (isSame)
+						mCMPFlags[i] = FDF_STRUCT_EQU;
+				}
+			}
+#endif
+		}
+	}
+
+
+
+
+
+	// recurse in
+	for ( i=0; i<(int)mStructs.size(); i++)
+	{
+		if (mCMPFlags[i] == FDF_STRUCT_NEQU)
+			initRecurseCmpFlags(i);
+	}
+}
+
+
+
+
+static int name_is_array(char* name, int* dim1, int* dim2) {
+	int len = strlen(name);
+	/*fprintf(stderr,"[%s]",name);*/
+	/*if (len >= 1) {
+	if (name[len-1] != ']')
+	return 1;
+	}
+	return 0;*/
+	char *bp;
+	int num;
+	if (dim1) {
+		*dim1 = 1;
+	}
+	if (dim2) {
+		*dim2 = 1;
+	}
+	bp = strchr(name, '[');
+	if (!bp) {
+		return 0;
+	}
+	num = 0;
+	while (++bp < name+len-1) {
+		const char c = *bp;
+		if (c == ']') {
+			break;
+		}
+		if (c <= '9' && c >= '0') {
+			num *= 10;
+			num += (c - '0');
+		} else {
+			printf("array parse error.\n");
+			return 0;
+		}
+	}
+	if (dim2) {
+		*dim2 = num;
+	}
+
+	/* find second dim, if any. */
+	bp = strchr(bp, '[');
+	if (!bp) {
+		return 1; /* at least we got the first dim. */
+	}
+	num = 0;
+	while (++bp < name+len-1) {
+		const char c = *bp;
+		if (c == ']') {
+			break;
+		}
+		if (c <= '9' && c >= '0') {
+			num *= 10;
+			num += (c - '0');
+		} else {
+			printf("array2 parse error.\n");
+			return 1;
+		}
+	}
+	if (dim1) {
+		if (dim2) {
+			*dim1 = *dim2;
+			*dim2 = num;
+		} else {
+			*dim1 = num;
+		}
+	}
+
+	return 1;
+}
+
+
+// ----------------------------------------------------- //
+void bDNA::init(char *data, int len, bool swap)
+{
+	int *intPtr=0;short *shtPtr=0;
+	char *cp = 0;int dataLen =0;long nr=0;
+	intPtr = (int*)data;
+
+	/*
+		SDNA (4 bytes) (magic number)
+		NAME (4 bytes)
+		<nr> (4 bytes) amount of names (int)
+		<string>
+		<string>
+	*/
+
+	if (strncmp(data, "SDNA", 4)==0)
+	{
+		// skip ++ NAME
+		intPtr++; intPtr++;
+	}
+
+
+
+	// Parse names
+	if (swap) 
+	{
+		*intPtr = ChunkUtils::swapInt(*intPtr);
+	}
+	dataLen = *intPtr;
+	intPtr++;
+
+	cp = (char*)intPtr;
+	int i;
+	for ( i=0; i<dataLen; i++)
+	{
+		bNameInfo info;
+		info.m_name = cp;
+		info.m_isPointer = (info.m_name[0] == '*') || (info.m_name[1] == '*');
+		name_is_array(info.m_name,&info.m_dim0,&info.m_dim1);
+		m_Names.push_back(info);
+		while (*cp)cp++;
+		cp++;
+	}
+
+	
+	{
+		nr= (long)cp;
+	//long mask=3;
+		nr= ((nr+3)&~3)-nr;
+		while (nr--)
+		{
+			cp++;
+		}
+	}
+
+
+	/*
+		TYPE (4 bytes)
+		<nr> amount of types (int)
+		<string>
+		<string>
+	*/
+
+	intPtr = (int*)cp;
+	assert(strncmp(cp, "TYPE", 4)==0); intPtr++;
+
+	if (swap) 
+	{
+		*intPtr = ChunkUtils::swapInt(*intPtr);
+	}
+	dataLen = *intPtr;
+	intPtr++;
+
+	cp = (char*)intPtr;
+	for ( i=0; i<dataLen; i++)
+	{
+		mTypes.push_back(cp);
+		while (*cp)cp++;
+		cp++;
+	}
+
+{
+		nr= (long)cp;
+	//	long mask=3;
+		nr= ((nr+3)&~3)-nr;
+		while (nr--)
+		{
+			cp++;
+		}
+	}
+
+
+	/*
+		TLEN (4 bytes)
+		<len> (short) the lengths of types
+		<len>
+	*/
+
+	// Parse type lens
+	intPtr = (int*)cp;
+	assert(strncmp(cp, "TLEN", 4)==0); intPtr++;
+
+	dataLen = (int)mTypes.size();
+
+	shtPtr = (short*)intPtr;
+	for ( i=0; i<dataLen; i++, shtPtr++)
+	{
+		if (swap)
+			shtPtr[0] = ChunkUtils::swapShort(shtPtr[0]);
+		mTlens.push_back(shtPtr[0]);
+	}
+
+	if (dataLen & 1) shtPtr++;
+
+	/*
+		STRC (4 bytes)
+		<nr> amount of structs (int)
+		<typenr>
+		<nr_of_elems>
+		<typenr>
+		<namenr>
+		<typenr>
+		<namenr>
+	*/
+
+	intPtr = (int*)shtPtr;
+	cp = (char*)intPtr;
+	assert(strncmp(cp, "STRC", 4)==0); intPtr++;
+
+	if (swap) 
+	{
+		*intPtr = ChunkUtils::swapInt(*intPtr);
+	}
+	dataLen = *intPtr;
+	intPtr++;
+
+
+	shtPtr = (short*)intPtr;
+	for ( i=0; i<dataLen; i++)
+	{
+		mStructs.push_back (shtPtr);
+		if (swap)
+		{
+			shtPtr[0]= ChunkUtils::swapShort(shtPtr[0]);
+			shtPtr[1]= ChunkUtils::swapShort(shtPtr[1]);
+
+			int len = shtPtr[1];
+			shtPtr+= 2;
+
+			for (int a=0; a<len; a++, shtPtr+=2)
+			{
+				shtPtr[0]= ChunkUtils::swapShort(shtPtr[0]);
+				shtPtr[1]= ChunkUtils::swapShort(shtPtr[1]);
+			}
+		}
+		else
+			shtPtr+= (2*shtPtr[1])+2;
+	}
+
+
+	// build reverse lookups
+	for ( i=0; i<(int)mStructs.size(); i++)
+	{
+		short *strc = mStructs.at(i);
+		if (!mPtrLen && strcmp(mTypes[strc[0]],"ListBase")==0)
+		{
+			mPtrLen = mTlens[strc[0]]/2;
+		}
+
+		mStructReverse.insert(strc[0], i);
+		mTypeLookup.insert(btHashString(mTypes[strc[0]]),i);
+	}
+}
+
+
+// ----------------------------------------------------- //
+int bDNA::getArraySize(char* string)
+{
+	int ret = 1;
+	int len = strlen(string);
+
+	
+	char* next = 0;
+	for (int i=0; i<len; i++)
+	{
+		char c = string[i];
+
+		if (c == '[')
+			next = &string[i+1];
+		else if (c==']')
+			if (next)
+				ret *= atoi(next);
+	}
+
+//	print (string << ' ' << ret);
+	return ret;
+}
+
+
+void bDNA::dumpTypeDefinitions()
+{
+	int i;
+
+	int numTypes = mTypes.size();
+	
+	for (i=0;i<numTypes;i++)
+	{
+
+	}
+
+	for ( i=0; i<(int)mStructs.size(); i++)
+	{
+		int totalBytes=0;
+		short *oldStruct = mStructs[i];
+
+		int oldLookup = getReverseType(oldStruct[0]);
+		if (oldLookup == -1)
+		{
+			mCMPFlags[i] = FDF_NONE;
+			continue;
+		}
+
+		short* newStruct = mStructs[oldLookup];
+		char* typeName = mTypes[newStruct[0]];
+		printf("%3d: %s ",i,typeName);
+		
+		//char *name = mNames[oldStruct[1]];
+		int len = oldStruct[1];
+		printf(" (%d fields) ",len);
+		oldStruct+=2;
+
+		printf("{");
+		int j;
+		for (j=0; j<len; ++j,oldStruct+=2) {
+			const char* name = m_Names[oldStruct[1]].m_name;
+			printf("%s %s",	mTypes[oldStruct[0]],name);
+			int elemNumBytes= 0;
+			int arrayDimensions = getArraySizeNew(oldStruct[1]);
+
+			if (m_Names[oldStruct[1]].m_isPointer)
+			{
+				elemNumBytes = VOID_IS_8 ? 8 : 4;
+			} else
+			{
+				elemNumBytes = getLength(oldStruct[0]);
+			}
+			printf(" /* %d bytes */",elemNumBytes*arrayDimensions);
+			
+			if (j == len-1) {
+				printf(";}");
+			} else {
+				printf("; ");
+			}
+			totalBytes+=elemNumBytes*arrayDimensions;
+		}
+		printf("\ntotalBytes=%d\n\n",totalBytes);
+
+	}
+	
+
+
+#if 0
+	/* dump out display of types and their sizes */
+	for (i=0; i<bf->types_count; ++i) {
+		/* if (!bf->types[i].is_struct)*/
+		{
+			printf("%3d: sizeof(%s%s)=%d",
+				i,
+				bf->types[i].is_struct ? "struct " : "atomic ",
+				bf->types[i].name, bf->types[i].size);
+			if (bf->types[i].is_struct) {
+				int j;
+				printf(", %d fields: { ", bf->types[i].fieldtypes_count);
+				for (j=0; j<bf->types[i].fieldtypes_count; ++j) {
+					printf("%s %s",
+						bf->types[bf->types[i].fieldtypes[j]].name,
+						bf->names[bf->types[i].fieldnames[j]]);
+					if (j == bf->types[i].fieldtypes_count-1) {
+						printf(";}");
+					} else {
+						printf("; ");
+					}
+				}
+			}
+			printf("\n\n");
+
+		}
+	}
+#endif
+
+}
+
+
+
+
+//eof
+
+

Code/Physics/Bullet Source/BulletFileLoader/bDNA.h

@@ -0,0 +1,110 @@
+/*
+bParse
+Copyright (c) 2006-2009 Charlie C & Erwin Coumans  http://gamekit.googlecode.com
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef __BDNA_H__
+#define __BDNA_H__
+
+
+#include "bCommon.h"
+
+namespace bParse {
+
+	struct	bNameInfo
+	{
+		char*	m_name;
+		bool	m_isPointer;
+		int		m_dim0;
+		int		m_dim1;
+	};
+
+	class bDNA
+	{
+	public:
+		bDNA();
+		~bDNA();
+
+		void init(char *data, int len, bool swap=false);
+
+		int getArraySize(char* str);
+		int getArraySizeNew(short name)
+		{
+			const bNameInfo& nameInfo = m_Names[name];
+			return nameInfo.m_dim0*nameInfo.m_dim1;
+		}
+		int getElementSize(short type, short name)
+		{
+			const bNameInfo& nameInfo = m_Names[name];
+			int size = nameInfo.m_isPointer ? mPtrLen*nameInfo.m_dim0*nameInfo.m_dim1 : mTlens[type]*nameInfo.m_dim0*nameInfo.m_dim1;
+			return size;
+		}
+
+		int	getNumNames() const
+		{
+			return m_Names.size();
+		}
+
+		char *getName(int ind);
+		char *getType(int ind);
+		short *getStruct(int ind);
+		short getLength(int ind);
+		int getReverseType(short type);
+		int getReverseType(const char *type);
+
+
+		int getNumStructs();
+
+		//
+		bool lessThan(bDNA* other);
+
+		void initCmpFlags(bDNA *memDNA);
+		bool flagNotEqual(int dna_nr);
+		bool flagEqual(int dna_nr);
+		bool flagNone(int dna_nr);
+
+
+		int getPointerSize();
+
+		void	dumpTypeDefinitions();
+
+	
+	private:
+		enum FileDNAFlags
+		{
+			FDF_NONE=0,
+			FDF_STRUCT_NEQU,
+			FDF_STRUCT_EQU
+		};
+
+		void initRecurseCmpFlags(int i);
+
+		btAlignedObjectArray<int>			mCMPFlags;
+
+		btAlignedObjectArray<bNameInfo>			m_Names;
+		btAlignedObjectArray<char*>			mTypes;
+		btAlignedObjectArray<short*>			mStructs;
+		btAlignedObjectArray<short>			mTlens;
+		btHashMap<btHashInt, int>			mStructReverse;
+		btHashMap<btHashString,int>	mTypeLookup;
+
+		int							mPtrLen;
+		
+
+
+
+	};
+}
+
+
+#endif//__BDNA_H__

Code/Physics/Bullet Source/BulletFileLoader/bDefines.h

@@ -0,0 +1,140 @@
+/* Copyright (C) 2006-2009 Charlie C & Erwin Coumans http://gamekit.googlecode.com
+*
+* This software is provided 'as-is', without any express or implied
+* warranty.  In no event will the authors be held liable for any damages
+* arising from the use of this software.
+*
+* Permission is granted to anyone to use this software for any purpose,
+* including commercial applications, and to alter it and redistribute it
+* freely, subject to the following restrictions:
+*
+* 1. The origin of this software must not be misrepresented; you must not
+*    claim that you wrote the original software. If you use this software
+*    in a product, an acknowledgment in the product documentation would be
+*    appreciated but is not required.
+* 2. Altered source versions must be plainly marked as such, and must not be
+*    misrepresented as being the original software.
+* 3. This notice may not be removed or altered from any source distribution.
+*/
+#ifndef __B_DEFINES_H__
+#define __B_DEFINES_H__
+
+
+// MISC defines, see BKE_global.h, BKE_utildefines.h
+#define SIZEOFBLENDERHEADER 12
+
+
+// ------------------------------------------------------------
+#if defined(__sgi) || defined (__sparc) || defined (__sparc__) || defined (__PPC__) || defined (__ppc__) || defined (__BIG_ENDIAN__)
+#	define MAKE_ID(a,b,c,d) ( (int)(a)<<24 | (int)(b)<<16 | (c)<<8 | (d) )
+#else
+#	define MAKE_ID(a,b,c,d) ( (int)(d)<<24 | (int)(c)<<16 | (b)<<8 | (a) )
+#endif
+
+
+// ------------------------------------------------------------
+#if defined(__sgi) || defined(__sparc) || defined(__sparc__) || defined (__PPC__) || defined (__ppc__) || defined (__BIG_ENDIAN__)
+#	define MAKE_ID2(c, d) ( (c)<<8 | (d) )
+#	define MOST_SIG_BYTE   0
+#	define BBIG_ENDIAN
+#else
+#	define MAKE_ID2(c, d) ( (d)<<8 | (c) )
+#	define MOST_SIG_BYTE  1
+#	define BLITTLE_ENDIAN
+#endif
+
+// ------------------------------------------------------------
+#define ID_SCE		MAKE_ID2('S', 'C')
+#define ID_LI		MAKE_ID2('L', 'I')
+#define ID_OB		MAKE_ID2('O', 'B')
+#define ID_ME		MAKE_ID2('M', 'E')
+#define ID_CU		MAKE_ID2('C', 'U')
+#define ID_MB		MAKE_ID2('M', 'B')
+#define ID_MA		MAKE_ID2('M', 'A')
+#define ID_TE		MAKE_ID2('T', 'E')
+#define ID_IM		MAKE_ID2('I', 'M')
+#define ID_IK		MAKE_ID2('I', 'K')
+#define ID_WV		MAKE_ID2('W', 'V')
+#define ID_LT		MAKE_ID2('L', 'T')
+#define ID_SE		MAKE_ID2('S', 'E')
+#define ID_LF		MAKE_ID2('L', 'F')
+#define ID_LA		MAKE_ID2('L', 'A')
+#define ID_CA		MAKE_ID2('C', 'A')
+#define ID_IP		MAKE_ID2('I', 'P')
+#define ID_KE		MAKE_ID2('K', 'E')
+#define ID_WO		MAKE_ID2('W', 'O')
+#define ID_SCR		MAKE_ID2('S', 'R')
+#define ID_VF		MAKE_ID2('V', 'F')
+#define ID_TXT		MAKE_ID2('T', 'X')
+#define ID_SO		MAKE_ID2('S', 'O')
+#define ID_SAMPLE	MAKE_ID2('S', 'A')
+#define ID_GR		MAKE_ID2('G', 'R')
+#define ID_ID		MAKE_ID2('I', 'D')
+#define ID_AR		MAKE_ID2('A', 'R')
+#define ID_AC		MAKE_ID2('A', 'C')
+#define ID_SCRIPT	MAKE_ID2('P', 'Y')
+#define ID_FLUIDSIM	MAKE_ID2('F', 'S')
+#define ID_NT		MAKE_ID2('N', 'T')
+#define ID_BR		MAKE_ID2('B', 'R')
+
+
+#define ID_SEQ		MAKE_ID2('S', 'Q')
+#define ID_CO		MAKE_ID2('C', 'O')
+#define ID_PO		MAKE_ID2('A', 'C')
+#define ID_NLA		MAKE_ID2('N', 'L')
+
+#define ID_VS		MAKE_ID2('V', 'S')
+#define ID_VN		MAKE_ID2('V', 'N')
+
+
+// ------------------------------------------------------------
+#define FORM MAKE_ID('F','O','R','M')
+#define DDG1 MAKE_ID('3','D','G','1')
+#define DDG2 MAKE_ID('3','D','G','2')
+#define DDG3 MAKE_ID('3','D','G','3')
+#define DDG4 MAKE_ID('3','D','G','4')
+#define GOUR MAKE_ID('G','O','U','R')
+#define BLEN MAKE_ID('B','L','E','N')
+#define DER_ MAKE_ID('D','E','R','_')
+#define V100 MAKE_ID('V','1','0','0')
+#define DATA MAKE_ID('D','A','T','A')
+#define GLOB MAKE_ID('G','L','O','B')
+#define IMAG MAKE_ID('I','M','A','G')
+#define TEST MAKE_ID('T','E','S','T')
+#define USER MAKE_ID('U','S','E','R')
+
+
+// ------------------------------------------------------------
+#define DNA1 MAKE_ID('D','N','A','1')
+#define REND MAKE_ID('R','E','N','D')
+#define ENDB MAKE_ID('E','N','D','B')
+#define NAME MAKE_ID('N','A','M','E')
+#define SDNA MAKE_ID('S','D','N','A')
+#define TYPE MAKE_ID('T','Y','P','E')
+#define TLEN MAKE_ID('T','L','E','N')
+#define STRC MAKE_ID('S','T','R','C')
+
+
+// ------------------------------------------------------------
+#define SWITCH_INT(a) { \
+    char s_i, *p_i; \
+    p_i= (char *)&(a); \
+    s_i=p_i[0]; p_i[0]=p_i[3]; p_i[3]=s_i; \
+    s_i=p_i[1]; p_i[1]=p_i[2]; p_i[2]=s_i; }
+
+// ------------------------------------------------------------
+#define SWITCH_SHORT(a)	{ \
+    char s_i, *p_i; \
+	p_i= (char *)&(a); \
+	s_i=p_i[0]; p_i[0]=p_i[1]; p_i[1]=s_i; }
+
+// ------------------------------------------------------------
+#define SWITCH_LONGINT(a) { \
+    char s_i, *p_i; \
+    p_i= (char *)&(a);  \
+    s_i=p_i[0]; p_i[0]=p_i[7]; p_i[7]=s_i; \
+    s_i=p_i[1]; p_i[1]=p_i[6]; p_i[6]=s_i; \
+    s_i=p_i[2]; p_i[2]=p_i[5]; p_i[5]=s_i; \
+    s_i=p_i[3]; p_i[3]=p_i[4]; p_i[4]=s_i; }
+
+#endif//__B_DEFINES_H__

Code/Physics/Bullet Source/BulletFileLoader/bFile.h

@@ -0,0 +1,165 @@
+/*
+bParse
+Copyright (c) 2006-2009 Charlie C & Erwin Coumans  http://gamekit.googlecode.com
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef __BFILE_H__
+#define __BFILE_H__
+
+#include "bCommon.h"
+#include "bChunk.h"
+#include <stdio.h>
+
+namespace bParse {
+
+	// ----------------------------------------------------- //
+	enum bFileFlags
+	{
+		FD_INVALID   =0,
+		FD_OK        =1,
+		FD_VOID_IS_8 =2,
+		FD_ENDIAN_SWAP      =4,
+		FD_FILE_64   =8,
+		FD_BITS_VARIES    =16,
+		FD_VERSION_VARIES = 32,
+		FD_DOUBLE_PRECISION =64,
+		FD_BROKEN_DNA = 128
+	};
+
+	enum bFileVerboseMode
+	{
+		FD_VERBOSE_EXPORT_XML = 1,
+		FD_VERBOSE_DUMP_DNA_TYPE_DEFINITIONS = 2,
+		FD_VERBOSE_DUMP_CHUNKS = 4,
+		FD_VERBOSE_DUMP_FILE_INFO=8,
+	};
+	// ----------------------------------------------------- //
+	class bFile
+	{
+	protected:
+		
+		char				m_headerString[7];
+
+		bool				mOwnsBuffer;
+		char*				mFileBuffer;
+		int					mFileLen;
+		int					mVersion;
+
+
+		bPtrMap				mLibPointers;
+
+		int					mDataStart;
+		bDNA*				mFileDNA;
+		bDNA*				mMemoryDNA;
+
+		btAlignedObjectArray<char*>	m_pointerFixupArray;
+		btAlignedObjectArray<char*>	m_pointerPtrFixupArray;
+		
+		btAlignedObjectArray<bChunkInd>	m_chunks;
+        btHashMap<btHashPtr, bChunkInd> m_chunkPtrPtrMap;
+
+        // 
+	
+		bPtrMap				mDataPointers;
+
+		
+		int					mFlags;
+
+		// ////////////////////////////////////////////////////////////////////////////
+
+			// buffer offset util
+		int getNextBlock(bChunkInd *dataChunk,  const char *dataPtr, const int flags);
+		void safeSwapPtr(char *dst, const char *src);
+
+		virtual	void parseHeader();
+		
+		virtual	void parseData() = 0;
+
+		void resolvePointersMismatch();
+		void resolvePointersChunk(const bChunkInd& dataChunk, int verboseMode);
+
+		int resolvePointersStructRecursive(char *strcPtr, int old_dna, int verboseMode, int recursion);
+		//void swapPtr(char *dst, char *src);
+
+		void parseStruct(char *strcPtr, char *dtPtr, int old_dna, int new_dna, bool fixupPointers);
+		void getMatchingFileDNA(short* old, const char* lookupName, const char* lookupType, char *strcData, char *data, bool fixupPointers);
+		char* getFileElement(short *firstStruct, char *lookupName, char *lookupType, char *data, short **foundPos);
+
+
+		void swap(char *head, class bChunkInd& ch, bool ignoreEndianFlag);
+		void swapData(char *data, short type, int arraySize, bool ignoreEndianFlag);
+		void swapStruct(int dna_nr, char *data, bool ignoreEndianFlag);
+		void swapLen(char *dataPtr);
+		void swapDNA(char* ptr);
+
+
+		char* readStruct(char *head, class bChunkInd& chunk);
+		char *getAsString(int code);
+
+		void	parseInternal(int verboseMode, char* memDna,int memDnaLength);
+
+	public:
+		bFile(const char *filename, const char headerString[7]);
+		
+		//todo: make memoryBuffer const char
+		//bFile( const char *memoryBuffer, int len);
+		bFile( char *memoryBuffer, int len, const char headerString[7]);
+		virtual ~bFile();
+
+		bDNA*				getFileDNA()
+		{
+			return mFileDNA;
+		}
+
+		virtual	void	addDataBlock(char* dataBlock) = 0;
+
+		int	getFlags() const
+		{
+			return mFlags;
+		}
+
+		bPtrMap&		getLibPointers()
+		{
+			return mLibPointers;
+		}
+		
+		void* findLibPointer(void *ptr);
+
+		bool ok();
+
+		virtual	void parse(int verboseMode) = 0;
+
+		virtual	int	write(const char* fileName, bool fixupPointers=false) = 0;
+
+		virtual	void	writeChunks(FILE* fp, bool fixupPointers );
+
+		virtual	void	writeDNA(FILE* fp) = 0;
+
+		void	updateOldPointers();
+		void	resolvePointers(int verboseMode);
+
+		void	dumpChunks(bDNA* dna);
+		
+		int		getVersion() const
+		{
+			return mVersion;
+		}
+		//pre-swap the endianness, so that data loaded on a target with different endianness doesn't need to be swapped
+		void preSwap();
+		void writeFile(const char* fileName);
+
+	};
+}
+
+
+#endif//__BFILE_H__

Code/Physics/Bullet Source/BulletFileLoader/btBulletFile.cpp

@@ -0,0 +1,423 @@
+/*
+bParse
+Copyright (c) 2006-2010 Erwin Coumans  http://gamekit.googlecode.com
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#include "btBulletFile.h"
+#include "bDefines.h"
+#include "bDNA.h"
+
+#if !defined( __CELLOS_LV2__) && !defined(__MWERKS__)
+#include <memory.h>
+#endif
+#include <string.h>
+
+
+// 32 && 64 bit versions
+#ifdef BT_INTERNAL_UPDATE_SERIALIZATION_STRUCTURES
+#ifdef _WIN64
+extern char sBulletDNAstr64[];
+extern int sBulletDNAlen64;
+#else
+extern char sBulletDNAstr[];
+extern int sBulletDNAlen;
+#endif //_WIN64
+#else//BT_INTERNAL_UPDATE_SERIALIZATION_STRUCTURES
+
+extern char sBulletDNAstr64[];
+extern int sBulletDNAlen64;
+extern char sBulletDNAstr[];
+extern int sBulletDNAlen;
+
+#endif //BT_INTERNAL_UPDATE_SERIALIZATION_STRUCTURES
+
+using namespace bParse;
+
+btBulletFile::btBulletFile()
+:bFile("", "BULLET ")
+{
+	mMemoryDNA = new bDNA(); //this memory gets released in the bFile::~bFile destructor,@todo not consistent with the rule 'who allocates it, has to deallocate it"
+
+	m_DnaCopy = 0;
+
+
+#ifdef BT_INTERNAL_UPDATE_SERIALIZATION_STRUCTURES
+#ifdef _WIN64
+		m_DnaCopy = (char*)btAlignedAlloc(sBulletDNAlen64,16);
+		memcpy(m_DnaCopy,sBulletDNAstr64,sBulletDNAlen64);
+		mMemoryDNA->init(m_DnaCopy,sBulletDNAlen64);
+#else//_WIN64
+		m_DnaCopy = (char*)btAlignedAlloc(sBulletDNAlen,16);
+		memcpy(m_DnaCopy,sBulletDNAstr,sBulletDNAlen);
+		mMemoryDNA->init(m_DnaCopy,sBulletDNAlen);
+#endif//_WIN64
+#else//BT_INTERNAL_UPDATE_SERIALIZATION_STRUCTURES
+	if (VOID_IS_8)
+	{
+		m_DnaCopy = (char*) btAlignedAlloc(sBulletDNAlen64,16);
+		memcpy(m_DnaCopy,sBulletDNAstr64,sBulletDNAlen64);
+		mMemoryDNA->init(m_DnaCopy,sBulletDNAlen64);
+	}
+	else
+	{
+		m_DnaCopy =(char*) btAlignedAlloc(sBulletDNAlen,16);
+		memcpy(m_DnaCopy,sBulletDNAstr,sBulletDNAlen);
+		mMemoryDNA->init(m_DnaCopy,sBulletDNAlen);
+	}
+#endif//BT_INTERNAL_UPDATE_SERIALIZATION_STRUCTURES
+}
+
+
+
+btBulletFile::btBulletFile(const char* fileName)
+:bFile(fileName, "BULLET ")
+{
+	m_DnaCopy = 0;
+}
+
+
+
+btBulletFile::btBulletFile(char *memoryBuffer, int len)
+:bFile(memoryBuffer,len, "BULLET ")
+{
+	m_DnaCopy = 0;
+}
+
+
+btBulletFile::~btBulletFile()
+{
+	if (m_DnaCopy)
+		btAlignedFree(m_DnaCopy);
+
+	
+	while (m_dataBlocks.size())
+	{
+		char* dataBlock = m_dataBlocks[m_dataBlocks.size()-1];
+		delete[] dataBlock;
+		m_dataBlocks.pop_back();
+	}
+
+}
+
+
+
+// ----------------------------------------------------- //
+void btBulletFile::parseData()
+{
+//	printf ("Building datablocks");
+//	printf ("Chunk size = %d",CHUNK_HEADER_LEN);
+//	printf ("File chunk size = %d",ChunkUtils::getOffset(mFlags));
+
+	const bool brokenDNA = (mFlags&FD_BROKEN_DNA)!=0;
+
+	//const bool swap = (mFlags&FD_ENDIAN_SWAP)!=0;
+	
+
+	mDataStart = 12;
+
+	char *dataPtr = mFileBuffer+mDataStart;
+
+	bChunkInd dataChunk;
+	dataChunk.code = 0;
+
+
+	//dataPtr += ChunkUtils::getNextBlock(&dataChunk, dataPtr, mFlags);
+	int seek = getNextBlock(&dataChunk, dataPtr, mFlags);
+	
+	
+	if (mFlags &FD_ENDIAN_SWAP) 
+		swapLen(dataPtr);
+
+	//dataPtr += ChunkUtils::getOffset(mFlags);
+	char *dataPtrHead = 0;
+
+	while (dataChunk.code != DNA1)
+	{
+		if (!brokenDNA || (dataChunk.code != BT_QUANTIZED_BVH_CODE) )
+		{
+
+			// one behind
+			if (dataChunk.code == SDNA) break;
+			//if (dataChunk.code == DNA1) break;
+
+			// same as (BHEAD+DATA dependency)
+			dataPtrHead = dataPtr+ChunkUtils::getOffset(mFlags);
+			if (dataChunk.dna_nr>=0)
+			{
+				char *id = readStruct(dataPtrHead, dataChunk);
+
+				// lookup maps
+				if (id)
+				{
+					m_chunkPtrPtrMap.insert(dataChunk.oldPtr, dataChunk);
+					mLibPointers.insert(dataChunk.oldPtr, (bStructHandle*)id);
+
+					m_chunks.push_back(dataChunk);
+					// block it
+					//bListBasePtr *listID = mMain->getListBasePtr(dataChunk.code);
+					//if (listID)
+					//	listID->push_back((bStructHandle*)id);
+				}
+
+				if (dataChunk.code == BT_SOFTBODY_CODE)
+				{
+					m_softBodies.push_back((bStructHandle*) id);
+				}
+				
+				if (dataChunk.code == BT_RIGIDBODY_CODE)
+				{
+					m_rigidBodies.push_back((bStructHandle*) id);
+				}
+
+				if (dataChunk.code == BT_DYNAMICSWORLD_CODE)
+				{
+					m_dynamicsWorldInfo.push_back((bStructHandle*) id);
+				}
+
+				if (dataChunk.code == BT_CONSTRAINT_CODE)
+				{
+					m_constraints.push_back((bStructHandle*) id);
+				}
+
+				if (dataChunk.code == BT_QUANTIZED_BVH_CODE)
+				{
+					m_bvhs.push_back((bStructHandle*) id);
+				}
+
+				if (dataChunk.code == BT_TRIANLGE_INFO_MAP)
+				{
+					m_triangleInfoMaps.push_back((bStructHandle*) id);
+				}
+
+				if (dataChunk.code == BT_COLLISIONOBJECT_CODE)
+				{
+					m_collisionObjects.push_back((bStructHandle*) id);
+				}
+
+				if (dataChunk.code == BT_SHAPE_CODE)
+				{
+					m_collisionShapes.push_back((bStructHandle*) id);
+				}
+
+		//		if (dataChunk.code == GLOB)
+		//		{
+		//			m_glob = (bStructHandle*) id;
+		//		}
+			} else
+			{
+				printf("unknown chunk\n");
+
+				mLibPointers.insert(dataChunk.oldPtr, (bStructHandle*)dataPtrHead);
+			}
+		} else
+		{
+			printf("skipping BT_QUANTIZED_BVH_CODE due to broken DNA\n");
+		}
+
+		
+		dataPtr += seek;
+
+		seek =  getNextBlock(&dataChunk, dataPtr, mFlags);
+		if (mFlags &FD_ENDIAN_SWAP) 
+			swapLen(dataPtr);
+
+		if (seek < 0)
+			break;
+	}
+
+}
+
+void	btBulletFile::addDataBlock(char* dataBlock)
+{
+	m_dataBlocks.push_back(dataBlock);
+
+}
+
+
+
+
+void	btBulletFile::writeDNA(FILE* fp)
+{
+
+	bChunkInd dataChunk;
+	dataChunk.code = DNA1;
+	dataChunk.dna_nr = 0;
+	dataChunk.nr = 1;
+#ifdef BT_INTERNAL_UPDATE_SERIALIZATION_STRUCTURES	
+	if (VOID_IS_8)
+	{
+#ifdef _WIN64
+		dataChunk.len = sBulletDNAlen64;
+		dataChunk.oldPtr = sBulletDNAstr64;
+		fwrite(&dataChunk,sizeof(bChunkInd),1,fp);
+		fwrite(sBulletDNAstr64, sBulletDNAlen64,1,fp);
+#else
+		btAssert(0);
+#endif
+	}
+	else
+	{
+#ifndef _WIN64
+		dataChunk.len = sBulletDNAlen;
+		dataChunk.oldPtr = sBulletDNAstr;
+		fwrite(&dataChunk,sizeof(bChunkInd),1,fp);
+		fwrite(sBulletDNAstr, sBulletDNAlen,1,fp);
+#else//_WIN64
+		btAssert(0);
+#endif//_WIN64
+	}
+#else//BT_INTERNAL_UPDATE_SERIALIZATION_STRUCTURES
+	if (VOID_IS_8)
+	{
+		dataChunk.len = sBulletDNAlen64;
+		dataChunk.oldPtr = sBulletDNAstr64;
+		fwrite(&dataChunk,sizeof(bChunkInd),1,fp);
+		fwrite(sBulletDNAstr64, sBulletDNAlen64,1,fp);
+	}
+	else
+	{
+		dataChunk.len = sBulletDNAlen;
+		dataChunk.oldPtr = sBulletDNAstr;
+		fwrite(&dataChunk,sizeof(bChunkInd),1,fp);
+		fwrite(sBulletDNAstr, sBulletDNAlen,1,fp);
+	}
+#endif//BT_INTERNAL_UPDATE_SERIALIZATION_STRUCTURES
+}
+
+
+void	btBulletFile::parse(int verboseMode)
+{
+#ifdef BT_INTERNAL_UPDATE_SERIALIZATION_STRUCTURES
+	if (VOID_IS_8)
+	{
+#ifdef _WIN64
+		
+		if (m_DnaCopy)
+			delete m_DnaCopy;
+		m_DnaCopy = (char*)btAlignedAlloc(sBulletDNAlen64,16);
+		memcpy(m_DnaCopy,sBulletDNAstr64,sBulletDNAlen64);
+		parseInternal(verboseMode,(char*)sBulletDNAstr64,sBulletDNAlen64);
+#else
+		btAssert(0);
+#endif
+	}
+	else
+	{
+#ifndef _WIN64
+
+		if (m_DnaCopy)
+			delete m_DnaCopy;
+		m_DnaCopy = (char*)btAlignedAlloc(sBulletDNAlen,16);
+		memcpy(m_DnaCopy,sBulletDNAstr,sBulletDNAlen);
+		parseInternal(verboseMode,m_DnaCopy,sBulletDNAlen);
+#else
+		btAssert(0);
+#endif
+	}
+#else//BT_INTERNAL_UPDATE_SERIALIZATION_STRUCTURES
+	if (VOID_IS_8)
+	{
+		if (m_DnaCopy)
+			delete m_DnaCopy;
+		m_DnaCopy = (char*)btAlignedAlloc(sBulletDNAlen64,16);
+		memcpy(m_DnaCopy,sBulletDNAstr64,sBulletDNAlen64);
+		parseInternal(verboseMode,m_DnaCopy,sBulletDNAlen64);
+	}
+	else
+	{
+		if (m_DnaCopy)
+			delete m_DnaCopy;
+		m_DnaCopy = (char*)btAlignedAlloc(sBulletDNAlen,16);
+		memcpy(m_DnaCopy,sBulletDNAstr,sBulletDNAlen);
+		parseInternal(verboseMode,m_DnaCopy,sBulletDNAlen);
+	}
+#endif//BT_INTERNAL_UPDATE_SERIALIZATION_STRUCTURES
+	
+	//the parsing will convert to cpu endian
+	mFlags &=~FD_ENDIAN_SWAP;
+
+	int littleEndian= 1;
+	littleEndian= ((char*)&littleEndian)[0];
+	
+	mFileBuffer[8] = littleEndian?'v':'V';
+	
+}
+
+// experimental
+int		btBulletFile::write(const char* fileName, bool fixupPointers)
+{
+	FILE *fp = fopen(fileName, "wb");
+	if (fp)
+	{
+		char header[SIZEOFBLENDERHEADER] ;
+		memcpy(header, m_headerString, 7);
+		int endian= 1;
+		endian= ((char*)&endian)[0];
+
+		if (endian)
+		{
+			header[7] = '_';
+		} else
+		{
+			header[7] = '-';
+		}
+		if (VOID_IS_8)
+		{
+			header[8]='V';
+		} else
+		{
+			header[8]='v';
+		}
+
+		header[9] = '2';
+		header[10] = '7';
+		header[11] = '5';
+		
+		fwrite(header,SIZEOFBLENDERHEADER,1,fp);
+
+		writeChunks(fp, fixupPointers);
+
+		writeDNA(fp);
+
+		fclose(fp);
+		
+	} else
+	{
+		printf("Error: cannot open file %s for writing\n",fileName);
+		return 0;
+	}
+	return 1;
+}
+
+
+
+void	btBulletFile::addStruct(const	char* structType,void* data, int len, void* oldPtr, int code)
+{
+	
+	bParse::bChunkInd dataChunk;
+	dataChunk.code = code;
+	dataChunk.nr = 1;
+	dataChunk.len = len;
+	dataChunk.dna_nr = mMemoryDNA->getReverseType(structType);
+	dataChunk.oldPtr = oldPtr;
+
+	///Perform structure size validation
+	short* structInfo= mMemoryDNA->getStruct(dataChunk.dna_nr);
+	int elemBytes;
+	elemBytes= mMemoryDNA->getLength(structInfo[0]);
+//	int elemBytes = mMemoryDNA->getElementSize(structInfo[0],structInfo[1]);
+	assert(len==elemBytes);
+
+	mLibPointers.insert(dataChunk.oldPtr, (bStructHandle*)data);
+	m_chunks.push_back(dataChunk);
+}

Code/Physics/Bullet Source/BulletFileLoader/btBulletFile.h

@@ -0,0 +1,83 @@
+/*
+bParse
+Copyright (c) 2006-2010 Charlie C & Erwin Coumans  http://gamekit.googlecode.com
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_BULLET_FILE_H
+#define BT_BULLET_FILE_H
+
+
+#include "bFile.h"
+#include "LinearMath/btAlignedObjectArray.h"
+#include "bDefines.h"
+
+#include "LinearMath/btSerializer.h"
+
+
+
+namespace bParse {
+
+	// ----------------------------------------------------- //
+	class btBulletFile : public bFile
+	{
+		
+
+	protected:
+	
+		char*	m_DnaCopy;
+				
+	public:
+
+		btAlignedObjectArray<bStructHandle*>	m_softBodies;
+
+		btAlignedObjectArray<bStructHandle*>	m_rigidBodies;
+
+		btAlignedObjectArray<bStructHandle*>	m_collisionObjects;
+
+		btAlignedObjectArray<bStructHandle*>	m_collisionShapes;
+
+		btAlignedObjectArray<bStructHandle*>	m_constraints;
+
+		btAlignedObjectArray<bStructHandle*>	m_bvhs;
+
+		btAlignedObjectArray<bStructHandle*>	m_triangleInfoMaps;
+
+		btAlignedObjectArray<bStructHandle*>	m_dynamicsWorldInfo;
+
+		btAlignedObjectArray<char*>				m_dataBlocks;
+		btBulletFile();
+
+		btBulletFile(const char* fileName);
+
+		btBulletFile(char *memoryBuffer, int len);
+
+		virtual ~btBulletFile();
+
+		virtual	void	addDataBlock(char* dataBlock);
+	
+
+		// experimental
+		virtual int		write(const char* fileName, bool fixupPointers=false);
+
+		virtual	void	parse(int verboseMode);
+
+		virtual	void parseData();
+
+		virtual	void	writeDNA(FILE* fp);
+
+		void	addStruct(const char* structType,void* data, int len, void* oldPtr, int code);
+
+	};
+};
+
+#endif //BT_BULLET_FILE_H

Code/Physics/Bullet Source/BulletFileLoader/premake4.lua

@@ -0,0 +1,12 @@
+	project "BulletFileLoader"
+		
+	kind "StaticLib"
+	targetdir "../../lib"
+	includedirs {
+		"../../../src"
+	}
+	 
+	files {
+		"**.cpp",
+		"**.h"
+	}

Code/Physics/Bullet Source/BulletWorldImporter/CMakeLists.txt

@@ -0,0 +1,40 @@
+INCLUDE_DIRECTORIES( 
+	${BULLET_PHYSICS_SOURCE_DIR}/src
+	${BULLET_PHYSICS_SOURCE_DIR}/Extras/Serialize/BulletFileLoader
+)
+
+ADD_LIBRARY(
+BulletWorldImporter 
+btBulletWorldImporter.cpp 
+btBulletWorldImporter.h 
+btWorldImporter.cpp 
+btWorldImporter.h 
+)
+
+SET_TARGET_PROPERTIES(BulletWorldImporter PROPERTIES VERSION ${BULLET_VERSION})
+SET_TARGET_PROPERTIES(BulletWorldImporter PROPERTIES SOVERSION ${BULLET_VERSION})
+
+IF (BUILD_SHARED_LIBS)
+        TARGET_LINK_LIBRARIES(BulletWorldImporter BulletDynamics BulletCollision BulletFileLoader LinearMath)
+ENDIF (BUILD_SHARED_LIBS)
+
+IF (INSTALL_EXTRA_LIBS)
+	IF (NOT INTERNAL_CREATE_DISTRIBUTABLE_MSVC_PROJECTFILES)
+		#FILES_MATCHING requires CMake 2.6
+		IF (${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION} GREATER 2.5)
+			IF (APPLE AND BUILD_SHARED_LIBS AND FRAMEWORK)
+				INSTALL(TARGETS BulletWorldImporter DESTINATION .)
+			ELSE (APPLE AND BUILD_SHARED_LIBS AND FRAMEWORK)
+				INSTALL(TARGETS BulletWorldImporter DESTINATION lib${LIB_SUFFIX})
+				INSTALL(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+DESTINATION ${INCLUDE_INSTALL_DIR} FILES_MATCHING PATTERN "*.h"  PATTERN
+".svn" EXCLUDE PATTERN "CMakeFiles" EXCLUDE)
+			ENDIF (APPLE AND BUILD_SHARED_LIBS AND FRAMEWORK)
+		ENDIF (${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION} GREATER 2.5)
+
+		IF (APPLE AND BUILD_SHARED_LIBS AND FRAMEWORK)
+			SET_TARGET_PROPERTIES(BulletWorldImporter PROPERTIES FRAMEWORK true)
+			SET_TARGET_PROPERTIES(BulletWorldImporter PROPERTIES PUBLIC_HEADER "btBulletWorldImporter.h")
+		ENDIF (APPLE AND BUILD_SHARED_LIBS AND FRAMEWORK)
+	ENDIF (NOT INTERNAL_CREATE_DISTRIBUTABLE_MSVC_PROJECTFILES)
+ENDIF (INSTALL_EXTRA_LIBS)

Code/Physics/Bullet Source/BulletWorldImporter/btBulletWorldImporter.cpp

@@ -0,0 +1,362 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2012 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+
+#include "btBulletWorldImporter.h"
+#include "../BulletFileLoader/btBulletFile.h"
+
+#include "btBulletDynamicsCommon.h"
+#include "BulletCollision/Gimpact/btGImpactShape.h"
+
+
+
+//#define USE_INTERNAL_EDGE_UTILITY
+#ifdef USE_INTERNAL_EDGE_UTILITY
+#include "BulletCollision/CollisionDispatch/btInternalEdgeUtility.h"
+#endif //USE_INTERNAL_EDGE_UTILITY
+
+btBulletWorldImporter::btBulletWorldImporter(btDynamicsWorld* world)
+	:btWorldImporter(world)
+{
+}
+
+btBulletWorldImporter::~btBulletWorldImporter()
+{
+}
+
+
+bool	btBulletWorldImporter::loadFile( const char* fileName, const char* preSwapFilenameOut)
+{
+	bParse::btBulletFile* bulletFile2 = new bParse::btBulletFile(fileName);
+
+	
+	bool result = loadFileFromMemory(bulletFile2);
+	//now you could save the file in 'native' format using
+	//bulletFile2->writeFile("native.bullet");
+	if (result)
+	{
+		if (preSwapFilenameOut)
+		{
+			bulletFile2->preSwap();
+			bulletFile2->writeFile(preSwapFilenameOut);
+		}
+		
+	}
+	delete bulletFile2;
+	
+	return result;
+
+}
+
+
+
+bool	btBulletWorldImporter::loadFileFromMemory( char* memoryBuffer, int len)
+{
+	bParse::btBulletFile* bulletFile2 = new bParse::btBulletFile(memoryBuffer,len);
+
+	bool result = loadFileFromMemory(bulletFile2);
+
+	delete bulletFile2;
+
+	return result;
+}
+
+
+
+
+bool	btBulletWorldImporter::loadFileFromMemory(  bParse::btBulletFile* bulletFile2)
+{
+	bool ok = (bulletFile2->getFlags()& bParse::FD_OK)!=0;
+	
+	if (ok)
+		bulletFile2->parse(m_verboseMode);
+	else 
+		return false;
+	
+	if (m_verboseMode & bParse::FD_VERBOSE_DUMP_CHUNKS)
+	{
+		bulletFile2->dumpChunks(bulletFile2->getFileDNA());
+	}
+
+	return convertAllObjects(bulletFile2);
+
+}
+
+bool	btBulletWorldImporter::convertAllObjects(  bParse::btBulletFile* bulletFile2)
+{
+
+	m_shapeMap.clear();
+	m_bodyMap.clear();
+
+	int i;
+	
+	for (i=0;i<bulletFile2->m_bvhs.size();i++)
+	{
+		btOptimizedBvh* bvh = createOptimizedBvh();
+
+		if (bulletFile2->getFlags() & bParse::FD_DOUBLE_PRECISION)
+		{
+			btQuantizedBvhDoubleData* bvhData = (btQuantizedBvhDoubleData*)bulletFile2->m_bvhs[i];
+			bvh->deSerializeDouble(*bvhData);
+		} else
+		{
+			btQuantizedBvhFloatData* bvhData = (btQuantizedBvhFloatData*)bulletFile2->m_bvhs[i];
+			bvh->deSerializeFloat(*bvhData);
+		}
+		m_bvhMap.insert(bulletFile2->m_bvhs[i],bvh);
+	}
+
+
+
+	
+
+	for (i=0;i<bulletFile2->m_collisionShapes.size();i++)
+	{
+		btCollisionShapeData* shapeData = (btCollisionShapeData*)bulletFile2->m_collisionShapes[i];
+		btCollisionShape* shape = convertCollisionShape(shapeData);
+		if (shape)
+		{
+	//		printf("shapeMap.insert(%x,%x)\n",shapeData,shape);
+			m_shapeMap.insert(shapeData,shape);
+		}
+
+		if (shape&& shapeData->m_name)
+		{
+			char* newname = duplicateName(shapeData->m_name);
+			m_objectNameMap.insert(shape,newname);
+			m_nameShapeMap.insert(newname,shape);
+		}
+	}
+
+	
+
+
+	
+	for (int i=0;i<bulletFile2->m_dynamicsWorldInfo.size();i++)
+	{
+		if (bulletFile2->getFlags() & bParse::FD_DOUBLE_PRECISION)
+		{
+			btDynamicsWorldDoubleData* solverInfoData = (btDynamicsWorldDoubleData*)bulletFile2->m_dynamicsWorldInfo[i];
+			btContactSolverInfo solverInfo;
+
+			btVector3 gravity;
+			gravity.deSerializeDouble(solverInfoData->m_gravity);
+
+			solverInfo.m_tau = btScalar(solverInfoData->m_solverInfo.m_tau);
+			solverInfo.m_damping = btScalar(solverInfoData->m_solverInfo.m_damping);
+			solverInfo.m_friction = btScalar(solverInfoData->m_solverInfo.m_friction);
+			solverInfo.m_timeStep = btScalar(solverInfoData->m_solverInfo.m_timeStep);
+
+			solverInfo.m_restitution = btScalar(solverInfoData->m_solverInfo.m_restitution);
+			solverInfo.m_maxErrorReduction = btScalar(solverInfoData->m_solverInfo.m_maxErrorReduction);
+			solverInfo.m_sor = btScalar(solverInfoData->m_solverInfo.m_sor);
+			solverInfo.m_erp = btScalar(solverInfoData->m_solverInfo.m_erp);
+
+			solverInfo.m_erp2 = btScalar(solverInfoData->m_solverInfo.m_erp2);
+			solverInfo.m_globalCfm = btScalar(solverInfoData->m_solverInfo.m_globalCfm);
+			solverInfo.m_splitImpulsePenetrationThreshold = btScalar(solverInfoData->m_solverInfo.m_splitImpulsePenetrationThreshold);
+			solverInfo.m_splitImpulseTurnErp = btScalar(solverInfoData->m_solverInfo.m_splitImpulseTurnErp);
+		
+			solverInfo.m_linearSlop = btScalar(solverInfoData->m_solverInfo.m_linearSlop);
+			solverInfo.m_warmstartingFactor = btScalar(solverInfoData->m_solverInfo.m_warmstartingFactor);
+			solverInfo.m_maxGyroscopicForce = btScalar(solverInfoData->m_solverInfo.m_maxGyroscopicForce);
+			solverInfo.m_singleAxisRollingFrictionThreshold = btScalar(solverInfoData->m_solverInfo.m_singleAxisRollingFrictionThreshold);
+		
+			solverInfo.m_numIterations = solverInfoData->m_solverInfo.m_numIterations;
+			solverInfo.m_solverMode = solverInfoData->m_solverInfo.m_solverMode;
+			solverInfo.m_restingContactRestitutionThreshold = solverInfoData->m_solverInfo.m_restingContactRestitutionThreshold;
+			solverInfo.m_minimumSolverBatchSize = solverInfoData->m_solverInfo.m_minimumSolverBatchSize;
+		
+			solverInfo.m_splitImpulse = solverInfoData->m_solverInfo.m_splitImpulse;
+
+			setDynamicsWorldInfo(gravity,solverInfo);
+		} else
+		{
+			btDynamicsWorldFloatData* solverInfoData = (btDynamicsWorldFloatData*)bulletFile2->m_dynamicsWorldInfo[i];
+			btContactSolverInfo solverInfo;
+
+			btVector3 gravity;
+			gravity.deSerializeFloat(solverInfoData->m_gravity);
+
+			solverInfo.m_tau = solverInfoData->m_solverInfo.m_tau;
+			solverInfo.m_damping = solverInfoData->m_solverInfo.m_damping;
+			solverInfo.m_friction = solverInfoData->m_solverInfo.m_friction;
+			solverInfo.m_timeStep = solverInfoData->m_solverInfo.m_timeStep;
+
+			solverInfo.m_restitution = solverInfoData->m_solverInfo.m_restitution;
+			solverInfo.m_maxErrorReduction = solverInfoData->m_solverInfo.m_maxErrorReduction;
+			solverInfo.m_sor = solverInfoData->m_solverInfo.m_sor;
+			solverInfo.m_erp = solverInfoData->m_solverInfo.m_erp;
+
+			solverInfo.m_erp2 = solverInfoData->m_solverInfo.m_erp2;
+			solverInfo.m_globalCfm = solverInfoData->m_solverInfo.m_globalCfm;
+			solverInfo.m_splitImpulsePenetrationThreshold = solverInfoData->m_solverInfo.m_splitImpulsePenetrationThreshold;
+			solverInfo.m_splitImpulseTurnErp = solverInfoData->m_solverInfo.m_splitImpulseTurnErp;
+		
+			solverInfo.m_linearSlop = solverInfoData->m_solverInfo.m_linearSlop;
+			solverInfo.m_warmstartingFactor = solverInfoData->m_solverInfo.m_warmstartingFactor;
+			solverInfo.m_maxGyroscopicForce = solverInfoData->m_solverInfo.m_maxGyroscopicForce;
+			solverInfo.m_singleAxisRollingFrictionThreshold = solverInfoData->m_solverInfo.m_singleAxisRollingFrictionThreshold;
+		
+			solverInfo.m_numIterations = solverInfoData->m_solverInfo.m_numIterations;
+			solverInfo.m_solverMode = solverInfoData->m_solverInfo.m_solverMode;
+			solverInfo.m_restingContactRestitutionThreshold = solverInfoData->m_solverInfo.m_restingContactRestitutionThreshold;
+			solverInfo.m_minimumSolverBatchSize = solverInfoData->m_solverInfo.m_minimumSolverBatchSize;
+		
+			solverInfo.m_splitImpulse = solverInfoData->m_solverInfo.m_splitImpulse;
+
+			setDynamicsWorldInfo(gravity,solverInfo);
+		}
+	}
+
+
+	for (i=0;i<bulletFile2->m_rigidBodies.size();i++)
+	{
+		if (bulletFile2->getFlags() & bParse::FD_DOUBLE_PRECISION)
+		{
+			btRigidBodyDoubleData* colObjData = (btRigidBodyDoubleData*)bulletFile2->m_rigidBodies[i];
+			convertRigidBodyDouble(colObjData);
+		} else
+		{
+			btRigidBodyFloatData* colObjData = (btRigidBodyFloatData*)bulletFile2->m_rigidBodies[i];
+			convertRigidBodyFloat(colObjData);
+		}
+
+		
+	}
+
+	for (i=0;i<bulletFile2->m_collisionObjects.size();i++)
+	{
+		if (bulletFile2->getFlags() & bParse::FD_DOUBLE_PRECISION)
+		{
+			btCollisionObjectDoubleData* colObjData = (btCollisionObjectDoubleData*)bulletFile2->m_collisionObjects[i];
+			btCollisionShape** shapePtr = m_shapeMap.find(colObjData->m_collisionShape);
+			if (shapePtr && *shapePtr)
+			{
+				btTransform startTransform;
+				colObjData->m_worldTransform.m_origin.m_floats[3] = 0.f;
+				startTransform.deSerializeDouble(colObjData->m_worldTransform);
+				
+				btCollisionShape* shape = (btCollisionShape*)*shapePtr;
+				btCollisionObject* body = createCollisionObject(startTransform,shape,colObjData->m_name);
+				body->setFriction(btScalar(colObjData->m_friction));
+				body->setRestitution(btScalar(colObjData->m_restitution));
+				
+#ifdef USE_INTERNAL_EDGE_UTILITY
+				if (shape->getShapeType() == TRIANGLE_MESH_SHAPE_PROXYTYPE)
+				{
+					btBvhTriangleMeshShape* trimesh = (btBvhTriangleMeshShape*)shape;
+					if (trimesh->getTriangleInfoMap())
+					{
+						body->setCollisionFlags(body->getCollisionFlags()  | btCollisionObject::CF_CUSTOM_MATERIAL_CALLBACK);
+					}
+				}
+#endif //USE_INTERNAL_EDGE_UTILITY
+				m_bodyMap.insert(colObjData,body);
+			} else
+			{
+				printf("error: no shape found\n");
+			}
+	
+		} else
+		{
+			btCollisionObjectFloatData* colObjData = (btCollisionObjectFloatData*)bulletFile2->m_collisionObjects[i];
+			btCollisionShape** shapePtr = m_shapeMap.find(colObjData->m_collisionShape);
+			if (shapePtr && *shapePtr)
+			{
+				btTransform startTransform;
+				colObjData->m_worldTransform.m_origin.m_floats[3] = 0.f;
+				startTransform.deSerializeFloat(colObjData->m_worldTransform);
+				
+				btCollisionShape* shape = (btCollisionShape*)*shapePtr;
+				btCollisionObject* body = createCollisionObject(startTransform,shape,colObjData->m_name);
+
+#ifdef USE_INTERNAL_EDGE_UTILITY
+				if (shape->getShapeType() == TRIANGLE_MESH_SHAPE_PROXYTYPE)
+				{
+					btBvhTriangleMeshShape* trimesh = (btBvhTriangleMeshShape*)shape;
+					if (trimesh->getTriangleInfoMap())
+					{
+						body->setCollisionFlags(body->getCollisionFlags()  | btCollisionObject::CF_CUSTOM_MATERIAL_CALLBACK);
+					}
+				}
+#endif //USE_INTERNAL_EDGE_UTILITY
+				m_bodyMap.insert(colObjData,body);
+			} else
+			{
+				printf("error: no shape found\n");
+			}
+		}
+		
+	}
+
+	
+	for (i=0;i<bulletFile2->m_constraints.size();i++)
+	{
+		btTypedConstraintData2* constraintData = (btTypedConstraintData2*)bulletFile2->m_constraints[i];
+		btTypedConstraintFloatData* singleC = (btTypedConstraintFloatData*)bulletFile2->m_constraints[i];
+		btTypedConstraintDoubleData* doubleC = (btTypedConstraintDoubleData*)bulletFile2->m_constraints[i];
+
+		btCollisionObject** colAptr = m_bodyMap.find(constraintData->m_rbA);
+		btCollisionObject** colBptr = m_bodyMap.find(constraintData->m_rbB);
+
+		btRigidBody* rbA = 0;
+		btRigidBody* rbB = 0;
+
+		if (colAptr)
+		{
+			rbA = btRigidBody::upcast(*colAptr);
+			if (!rbA)
+				rbA = &getFixedBody();
+		}
+		if (colBptr)
+		{
+			rbB = btRigidBody::upcast(*colBptr);
+			if (!rbB)
+				rbB = &getFixedBody();
+		}
+		if (!rbA && !rbB)
+			continue;
+				
+		bool isDoublePrecisionData = (bulletFile2->getFlags() & bParse::FD_DOUBLE_PRECISION)!=0;
+		
+		if (isDoublePrecisionData)
+		{
+			if (bulletFile2->getVersion()>=282)
+			{
+				btTypedConstraintDoubleData* dc = (btTypedConstraintDoubleData*)constraintData;
+				convertConstraintDouble(dc, rbA,rbB, bulletFile2->getVersion());
+			} else
+			{
+				//double-precision constraints were messed up until 2.82, try to recover data...
+				
+				btTypedConstraintData* oldData = (btTypedConstraintData*)constraintData;
+				
+				convertConstraintBackwardsCompatible281(oldData, rbA,rbB, bulletFile2->getVersion());
+
+			}
+		}
+		else
+		{
+			btTypedConstraintFloatData* dc = (btTypedConstraintFloatData*)constraintData;
+			convertConstraintFloat(dc, rbA,rbB, bulletFile2->getVersion());
+		}
+		
+
+	}
+
+	return true;
+}
+

Code/Physics/Bullet Source/BulletWorldImporter/btBulletWorldImporter.h

@@ -0,0 +1,68 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2012 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+
+#ifndef BULLET_WORLD_IMPORTER_H
+#define BULLET_WORLD_IMPORTER_H
+
+
+#include "btWorldImporter.h"
+
+
+class btBulletFile;
+
+
+
+
+namespace bParse
+{
+	class btBulletFile;
+	
+};
+
+
+
+///The btBulletWorldImporter is a starting point to import .bullet files.
+///note that not all data is converted yet. You are expected to override or modify this class.
+///See Bullet/Demos/SerializeDemo for a derived class that extract btSoftBody objects too.
+class btBulletWorldImporter : public btWorldImporter
+{
+
+
+public:
+	
+	btBulletWorldImporter(btDynamicsWorld* world=0);
+
+	virtual ~btBulletWorldImporter();
+
+	///if you pass a valid preSwapFilenameOut, it will save a new file with a different endianness 
+	///this pre-swapped file can be loaded without swapping on a target platform of different endianness
+	bool	loadFile(const char* fileName, const char* preSwapFilenameOut=0);
+
+	///the memoryBuffer might be modified (for example if endian swaps are necessary)
+	bool	loadFileFromMemory(char *memoryBuffer, int len);
+
+	bool	loadFileFromMemory(bParse::btBulletFile* file);
+
+	//call make sure bulletFile2 has been parsed, either using btBulletFile::parse or btBulletWorldImporter::loadFileFromMemory
+	virtual	bool	convertAllObjects(bParse::btBulletFile* file);
+
+	
+
+
+};
+
+#endif //BULLET_WORLD_IMPORTER_H
+

Code/Physics/Bullet Source/BulletWorldImporter/btWorldImporter.h

@@ -0,0 +1,212 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2012 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+
+#ifndef BT_WORLD_IMPORTER_H
+#define BT_WORLD_IMPORTER_H
+
+#include "LinearMath/btTransform.h"
+#include "LinearMath/btVector3.h"
+#include "LinearMath/btAlignedObjectArray.h"
+#include "LinearMath/btHashMap.h"
+
+class btCollisionShape;
+class btCollisionObject;
+class btRigidBody;
+class btTypedConstraint;
+class btDynamicsWorld;
+struct ConstraintInput;
+class btRigidBodyColladaInfo;
+struct btCollisionShapeData;
+class btTriangleIndexVertexArray;
+class btStridingMeshInterface;
+struct btStridingMeshInterfaceData;
+class btGImpactMeshShape;
+class btOptimizedBvh;
+struct btTriangleInfoMap;
+class btBvhTriangleMeshShape;
+class btPoint2PointConstraint;
+class btHingeConstraint;
+class btConeTwistConstraint;
+class btGeneric6DofConstraint;
+class btGeneric6DofSpringConstraint;
+class btSliderConstraint;
+class btGearConstraint;
+struct btContactSolverInfo;
+struct btTypedConstraintData;
+struct btTypedConstraintFloatData;
+struct btTypedConstraintDoubleData;
+
+struct btRigidBodyDoubleData;
+struct btRigidBodyFloatData;
+
+#ifdef BT_USE_DOUBLE_PRECISION
+#define btRigidBodyData btRigidBodyDoubleData
+#else
+#define btRigidBodyData btRigidBodyFloatData
+#endif//BT_USE_DOUBLE_PRECISION
+
+
+class btWorldImporter
+{
+protected:
+	btDynamicsWorld* m_dynamicsWorld;
+	
+	int m_verboseMode;
+
+	btAlignedObjectArray<btCollisionShape*>  m_allocatedCollisionShapes;
+	btAlignedObjectArray<btCollisionObject*> m_allocatedRigidBodies;
+	btAlignedObjectArray<btTypedConstraint*> m_allocatedConstraints;
+	btAlignedObjectArray<btOptimizedBvh*>	 m_allocatedBvhs;
+	btAlignedObjectArray<btTriangleInfoMap*> m_allocatedTriangleInfoMaps;
+	btAlignedObjectArray<btTriangleIndexVertexArray*> m_allocatedTriangleIndexArrays;
+	btAlignedObjectArray<btStridingMeshInterfaceData*> m_allocatedbtStridingMeshInterfaceDatas;
+
+	btAlignedObjectArray<char*>				m_allocatedNames;
+
+	btAlignedObjectArray<int*>				m_indexArrays;
+	btAlignedObjectArray<short int*>		m_shortIndexArrays;
+	btAlignedObjectArray<unsigned char*>	m_charIndexArrays;
+
+	btAlignedObjectArray<btVector3FloatData*>	m_floatVertexArrays;
+	btAlignedObjectArray<btVector3DoubleData*>	m_doubleVertexArrays;
+
+
+	btHashMap<btHashPtr,btOptimizedBvh*>	m_bvhMap;
+	btHashMap<btHashPtr,btTriangleInfoMap*>	m_timMap;
+	
+	btHashMap<btHashString,btCollisionShape*>	m_nameShapeMap;
+	btHashMap<btHashString,btRigidBody*>	m_nameBodyMap;
+	btHashMap<btHashString,btTypedConstraint*>	m_nameConstraintMap;
+	btHashMap<btHashPtr,const char*>	m_objectNameMap;
+
+	btHashMap<btHashPtr,btCollisionShape*>	m_shapeMap;
+	btHashMap<btHashPtr,btCollisionObject*>	m_bodyMap;
+
+
+	//methods
+
+	static btRigidBody& getFixedBody();
+
+	char*	duplicateName(const char* name);
+
+	btCollisionShape* convertCollisionShape(  btCollisionShapeData* shapeData  );
+	
+	void	convertConstraintBackwardsCompatible281(btTypedConstraintData* constraintData, btRigidBody* rbA, btRigidBody* rbB, int fileVersion);
+	void	convertConstraintFloat(btTypedConstraintFloatData* constraintData, btRigidBody* rbA, btRigidBody* rbB, int fileVersion);
+	void	convertConstraintDouble(btTypedConstraintDoubleData* constraintData, btRigidBody* rbA, btRigidBody* rbB, int fileVersion);
+	void	convertRigidBodyFloat(btRigidBodyFloatData* colObjData);
+	void	convertRigidBodyDouble( btRigidBodyDoubleData* colObjData);
+
+public:
+	
+	btWorldImporter(btDynamicsWorld* world);
+	
+	virtual ~btWorldImporter();
+
+		///delete all memory collision shapes, rigid bodies, constraints etc. allocated during the load.
+	///make sure you don't use the dynamics world containing objects after you call this method
+	virtual void deleteAllData();
+
+	void	setVerboseMode(int verboseMode)
+	{
+		m_verboseMode = verboseMode;
+	}
+
+	int getVerboseMode() const
+	{
+		return m_verboseMode;
+	}
+
+		// query for data
+	int	getNumCollisionShapes() const;
+	btCollisionShape* getCollisionShapeByIndex(int index);
+	int getNumRigidBodies() const;
+	btCollisionObject* getRigidBodyByIndex(int index) const;
+	int getNumConstraints() const;
+	btTypedConstraint* getConstraintByIndex(int index) const;
+	int getNumBvhs() const;
+	btOptimizedBvh*  getBvhByIndex(int index) const;
+	int getNumTriangleInfoMaps() const;
+	btTriangleInfoMap* getTriangleInfoMapByIndex(int index) const;
+	
+	// queris involving named objects
+	btCollisionShape* getCollisionShapeByName(const char* name);
+	btRigidBody* getRigidBodyByName(const char* name);
+	btTypedConstraint* getConstraintByName(const char* name);
+	const char*	getNameForPointer(const void* ptr) const;
+
+	///those virtuals are called by load and can be overridden by the user
+
+	virtual void	setDynamicsWorldInfo(const btVector3& gravity, const btContactSolverInfo& solverInfo);
+
+	//bodies
+	virtual btRigidBody*  createRigidBody(bool isDynamic, 	btScalar mass, 	const btTransform& startTransform,	btCollisionShape* shape,const char* bodyName);
+	virtual btCollisionObject*  createCollisionObject(	const btTransform& startTransform,	btCollisionShape* shape,const char* bodyName);
+
+	///shapes
+
+	virtual btCollisionShape* createPlaneShape(const btVector3& planeNormal,btScalar planeConstant);
+	virtual btCollisionShape* createBoxShape(const btVector3& halfExtents);
+	virtual btCollisionShape* createSphereShape(btScalar radius);
+	virtual btCollisionShape* createCapsuleShapeX(btScalar radius, btScalar height);
+	virtual btCollisionShape* createCapsuleShapeY(btScalar radius, btScalar height);
+	virtual btCollisionShape* createCapsuleShapeZ(btScalar radius, btScalar height);
+	
+	virtual btCollisionShape* createCylinderShapeX(btScalar radius,btScalar height);
+	virtual btCollisionShape* createCylinderShapeY(btScalar radius,btScalar height);
+	virtual btCollisionShape* createCylinderShapeZ(btScalar radius,btScalar height);
+	virtual btCollisionShape* createConeShapeX(btScalar radius,btScalar height);
+	virtual btCollisionShape* createConeShapeY(btScalar radius,btScalar height);
+	virtual btCollisionShape* createConeShapeZ(btScalar radius,btScalar height);
+	virtual class btTriangleIndexVertexArray*	createTriangleMeshContainer();
+	virtual	btBvhTriangleMeshShape* createBvhTriangleMeshShape(btStridingMeshInterface* trimesh, btOptimizedBvh* bvh);
+	virtual btCollisionShape* createConvexTriangleMeshShape(btStridingMeshInterface* trimesh);
+	virtual btGImpactMeshShape* createGimpactShape(btStridingMeshInterface* trimesh);
+	virtual btStridingMeshInterfaceData* createStridingMeshInterfaceData(btStridingMeshInterfaceData* interfaceData);
+
+	virtual class btConvexHullShape* createConvexHullShape();
+	virtual class btCompoundShape* createCompoundShape();
+	virtual class btScaledBvhTriangleMeshShape* createScaledTrangleMeshShape(btBvhTriangleMeshShape* meshShape,const btVector3& localScalingbtBvhTriangleMeshShape);
+
+	virtual class btMultiSphereShape* createMultiSphereShape(const btVector3* positions,const btScalar* radi,int numSpheres);
+
+	virtual btTriangleIndexVertexArray* createMeshInterface(btStridingMeshInterfaceData& meshData);
+
+	///acceleration and connectivity structures
+	virtual btOptimizedBvh*	createOptimizedBvh();
+	virtual btTriangleInfoMap* createTriangleInfoMap();
+
+	///constraints
+	virtual btPoint2PointConstraint* createPoint2PointConstraint(btRigidBody& rbA,btRigidBody& rbB, const btVector3& pivotInA,const btVector3& pivotInB);
+	virtual btPoint2PointConstraint* createPoint2PointConstraint(btRigidBody& rbA,const btVector3& pivotInA);
+	virtual btHingeConstraint* createHingeConstraint(btRigidBody& rbA,btRigidBody& rbB, const btTransform& rbAFrame, const btTransform& rbBFrame, bool useReferenceFrameA=false);
+	virtual btHingeConstraint* createHingeConstraint(btRigidBody& rbA,const btTransform& rbAFrame, bool useReferenceFrameA=false);
+	virtual btConeTwistConstraint* createConeTwistConstraint(btRigidBody& rbA,btRigidBody& rbB,const btTransform& rbAFrame, const btTransform& rbBFrame);
+	virtual btConeTwistConstraint* createConeTwistConstraint(btRigidBody& rbA,const btTransform& rbAFrame);
+	virtual btGeneric6DofConstraint* createGeneric6DofConstraint(btRigidBody& rbA, btRigidBody& rbB, const btTransform& frameInA, const btTransform& frameInB ,bool useLinearReferenceFrameA);
+    virtual btGeneric6DofConstraint* createGeneric6DofConstraint(btRigidBody& rbB, const btTransform& frameInB, bool useLinearReferenceFrameB);
+	virtual btGeneric6DofSpringConstraint* createGeneric6DofSpringConstraint(btRigidBody& rbA, btRigidBody& rbB, const btTransform& frameInA, const btTransform& frameInB ,bool useLinearReferenceFrameA);
+	virtual btSliderConstraint* createSliderConstraint(btRigidBody& rbA, btRigidBody& rbB, const btTransform& frameInA, const btTransform& frameInB ,bool useLinearReferenceFrameA);
+    virtual btSliderConstraint* createSliderConstraint(btRigidBody& rbB, const btTransform& frameInB, bool useLinearReferenceFrameA);
+	virtual btGearConstraint* createGearConstraint(btRigidBody& rbA, btRigidBody& rbB, const btVector3& axisInA,const btVector3& axisInB, btScalar ratio);
+	
+
+
+
+};
+
+
+#endif //BT_WORLD_IMPORTER_H

Code/Physics/Bullet Source/BulletWorldImporter/premake4.lua

@@ -0,0 +1,13 @@
+	project "BulletWorldImporter"
+		
+	kind "StaticLib"
+	targetdir "../../lib"
+	includedirs {
+		"../BulletFileLoader",
+		"../../../src"
+	}
+	 
+	files {
+		"**.cpp",
+		"**.h"
+	}

Code/Physics/GamePhysics/GamePhysics.vcxproj

@@ -97,7 +97,7 @@
       <GenerateDebugInformation>true</GenerateDebugInformation>
       <ModuleDefinitionFile>
       </ModuleDefinitionFile>
-      <AdditionalDependencies>$(SolutionDir)Physics/lib/debug/BulletCollision_Debug.lib;$(SolutionDir)Physics/lib/debug/BulletDynamics_Debug.lib;$(SolutionDir)Physics/lib/debug/LinearMath_Debug.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalDependencies>$(SolutionDir)Physics/lib/debug/BulletCollision_Debug.lib;$(SolutionDir)Physics/lib/debug/BulletDynamics_Debug.lib;$(SolutionDir)Physics/lib/debug/LinearMath_Debug.lib;$(SolutionDir)Physics/lib/debug/BulletFileLoader_Debug.lib;$(SolutionDir)Physics/lib/debug/BulletWorldImporter_Debug.lib;%(AdditionalDependencies)</AdditionalDependencies>
     </Link>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
@@ -112,7 +112,7 @@
       <GenerateDebugInformation>true</GenerateDebugInformation>
       <ModuleDefinitionFile>
       </ModuleDefinitionFile>
-      <AdditionalDependencies>$(SolutionDir)Physics/lib/debug/BulletCollision_Debugx64.lib;$(SolutionDir)Physics/lib/debug/BulletDynamics_Debugx64.lib;$(SolutionDir)Physics/lib/debug/LinearMath_Debugx64.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalDependencies>$(SolutionDir)Physics/lib/debug/BulletCollision_Debugx64.lib;$(SolutionDir)Physics/lib/debug/BulletDynamics_Debugx64.lib;$(SolutionDir)Physics/lib/debug/LinearMath_Debugx64.lib;$(SolutionDir)Physics/lib/debug/BulletWorldImporter_Debugx64.lib;$(SolutionDir)Physics/lib/debug/BulletFileLoader_Debugx64.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>
     </Link>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
@@ -131,7 +131,7 @@
       <OptimizeReferences>true</OptimizeReferences>
       <ModuleDefinitionFile>
       </ModuleDefinitionFile>
-      <AdditionalDependencies>$(SolutionDir)Physics/lib/release/BulletCollision.lib;$(SolutionDir)Physics/lib/release/BulletDynamics.lib;$(SolutionDir)Physics/lib/release/LinearMath.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalDependencies>$(SolutionDir)Physics/lib/release/BulletCollision.lib;$(SolutionDir)Physics/lib/release/BulletDynamics.lib;$(SolutionDir)Physics/lib/release/LinearMath.lib;$(SolutionDir)Physics/lib/release/BulletFileLoader.lib;$(SolutionDir)Physics/lib/release/BulletWorldImporter.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>
     </Link>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
@@ -150,7 +150,7 @@
       <OptimizeReferences>true</OptimizeReferences>
       <ModuleDefinitionFile>
       </ModuleDefinitionFile>
-      <AdditionalDependencies>$(SolutionDir)Physics/lib/release/BulletCollisionx64.lib;$(SolutionDir)Physics/lib/release/BulletDynamicsx64.lib;$(SolutionDir)Physics/lib/release/LinearMathx64.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalDependencies>$(SolutionDir)Physics/lib/release/BulletCollisionx64.lib;$(SolutionDir)Physics/lib/release/BulletDynamicsx64.lib;$(SolutionDir)Physics/lib/release/LinearMathx64.lib;$(SolutionDir)Physics/lib/release/BulletWorldImporterx64.lib;$(SolutionDir)Physics/lib/release/BulletFileLoaderx64.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>
     </Link>
   </ItemDefinitionGroup>
   <ItemGroup>

Code/Physics/GamePhysics/Implementation/PhysicsAPI_Impl.cpp

@@ -1,6 +1,9 @@
 #include "PhysicsAPI_Impl.h"
 #include "OysterPhysics3D.h"
 #include "SimpleRigidBody.h"
+#include <BulletWorldImporter\btBulletWorldImporter.h>
+
+#include <codecvt>
 
 using namespace ::Oyster;
 using namespace ::Oyster::Physics;
@@ -92,8 +95,8 @@ ICustomBody* API_Impl::AddCollisionSphere(float radius, ::Oyster::Math::Float4 r
 
 	state.centerPos = position;
 	state.reach = Float3(radius, radius, radius);
-	state.dynamicFrictionCoeff = 0.5f;
+	state.dynamicFrictionCoeff = dynamicFriction;
-	state.staticFrictionCoeff = 0.5f;
+	state.staticFrictionCoeff = staticFriction;
 	state.quaternion = Quaternion(Float3(rotation.xyz), rotation.w);
 	state.mass = mass;
 
@@ -131,8 +134,8 @@ ICustomBody* API_Impl::AddCollisionBox(Float3 halfSize, ::Oyster::Math::Float4 r
 
 	state.centerPos = position;
 	state.reach = halfSize;
-	state.dynamicFrictionCoeff = 0.5f;
+	state.dynamicFrictionCoeff = dynamicFriction;
-	state.staticFrictionCoeff = 0.5f;
+	state.staticFrictionCoeff = staticFriction;
 	state.quaternion = Quaternion(Float3(rotation.xyz), rotation.w);
 	state.mass = mass;
 
@@ -170,8 +173,8 @@ ICustomBody* API_Impl::AddCollisionCylinder(::Oyster::Math::Float3 halfSize, ::O
 
 	state.centerPos = position;
 	state.reach = halfSize;
-	state.dynamicFrictionCoeff = 0.5f;
+	state.dynamicFrictionCoeff = dynamicFriction;
-	state.staticFrictionCoeff = 0.5f;
+	state.staticFrictionCoeff = staticFriction;
 	state.quaternion = Quaternion(Float3(rotation.xyz), rotation.w);
 	state.mass = mass;
 
@@ -211,8 +214,55 @@ ICustomBody* API_Impl::AddCharacter(::Oyster::Math::Float height, ::Oyster::Math
 
 	state.centerPos = position;
 	state.reach = Float3(radius, height, radius);
-	state.dynamicFrictionCoeff = 0.5f;
+	state.dynamicFrictionCoeff = dynamicFriction;
-	state.staticFrictionCoeff = 0.5f;
+	state.staticFrictionCoeff = staticFriction;
+	state.quaternion = Quaternion(Float3(rotation.xyz), rotation.w);
+	state.mass = mass;
+
+	body->SetState(state);
+
+	return body;
+}
+
+ICustomBody* API_Impl::AddTriangleMesh(const std::wstring fileName, ::Oyster::Math::Float4 rotation, ::Oyster::Math::Float3 position, float mass, float restitution, float staticFriction, float dynamicFriction)
+{
+	SimpleRigidBody* body = new SimpleRigidBody;
+	SimpleRigidBody::State state;
+
+	btBulletWorldImporter bulletFile;
+
+	typedef std::codecvt_utf8<wchar_t> convert_typeX;
+	std::wstring_convert<convert_typeX, wchar_t> converterX;
+
+	std::string bulletPath = converterX.to_bytes(fileName);
+
+	// Add collision shape
+	bulletFile.loadFile(bulletPath.c_str());
+	btCollisionShape* collisionShape = bulletFile.getCollisionShapeByIndex(0);
+	body->SetCollisionShape(collisionShape);
+
+	// Add motion state
+	btDefaultMotionState* motionState = new btDefaultMotionState(btTransform(btQuaternion(rotation.x, rotation.y, rotation.z, rotation.w),btVector3(position.x, position.y, position.z)));
+	body->SetMotionState(motionState);
+
+	// Add rigid body
+	btVector3 fallInertia(0, 0, 0);
+	collisionShape->calculateLocalInertia(mass, fallInertia);
+	btRigidBody::btRigidBodyConstructionInfo rigidBodyCI(mass, motionState, collisionShape, fallInertia);
+    btRigidBody* rigidBody = new btRigidBody(rigidBodyCI);
+	rigidBody->setFriction(staticFriction);
+	rigidBody->setRestitution(restitution);
+	rigidBody->setUserPointer(body);
+	body->SetRigidBody(rigidBody);
+
+	// Add rigid body to world
+	this->dynamicsWorld->addRigidBody(rigidBody);
+	this->customBodies.push_back(body);
+
+	state.centerPos = position;
+	state.reach = Float3(0, 0, 0);
+	state.dynamicFrictionCoeff = dynamicFriction;
+	state.staticFrictionCoeff = staticFriction;
 	state.quaternion = Quaternion(Float3(rotation.xyz), rotation.w);
 	state.mass = mass;
 

Code/Physics/GamePhysics/Implementation/PhysicsAPI_Impl.h

@@ -66,6 +66,8 @@ namespace Oyster
 
 			ICustomBody* AddCharacter(::Oyster::Math::Float height, ::Oyster::Math::Float radius, ::Oyster::Math::Float4 rotation, ::Oyster::Math::Float3 position, float mass, float restitution, float staticFriction, float dynamicFriction);
 
+			ICustomBody* AddTriangleMesh(const std::wstring fileName, ::Oyster::Math::Float4 rotation, ::Oyster::Math::Float3 position, float mass, float restitution, float staticFriction, float dynamicFriction);
+
 			void SetTimeStep(float timeStep);
 
 			void UpdateWorld();

Code/Physics/GamePhysics/Implementation/SimpleRigidBody.cpp

@@ -300,11 +300,13 @@ Float4x4 SimpleRigidBody::GetView( const ::Oyster::Math::Float3 &offset ) const
 
 Float3 SimpleRigidBody::GetGravity() const
 {
-	return this->rigidBody->getGravity();
+	btVector3 gravity = this->rigidBody->getGravity();
+	return Float3(gravity.x(), gravity.y(), gravity.z());
 }
 Float3 SimpleRigidBody::GetLinearVelocity() const
 {
-	return this->rigidBody->getLinearVelocity();
+	btVector3 linearVelocity = this->rigidBody->getLinearVelocity();
+	return Float3(linearVelocity.x(), linearVelocity.y(), linearVelocity.z());
 }
 
 

Code/Physics/GamePhysics/PhysicsAPI.h

@@ -89,6 +89,8 @@ namespace Oyster
 
 			virtual ICustomBody* AddCharacter(::Oyster::Math::Float height, ::Oyster::Math::Float radius, ::Oyster::Math::Float4 rotation, ::Oyster::Math::Float3 position, float mass, float restitution, float staticFriction, float dynamicFriction) = 0;
 
+			virtual ICustomBody* AddTriangleMesh(const std::wstring fileName, ::Oyster::Math::Float4 rotation, ::Oyster::Math::Float3 position, float mass, float restitution, float staticFriction, float dynamicFriction) = 0;
+
 			virtual void SetTimeStep(float timeStep) = 0;
 
 			virtual void UpdateWorld() = 0;