Merge branch 'GameClient' of https://github.com/dean11/Danbias into GameClient

Code/Game/GameClient/GameClientState/C_Object.cpp

@@ -5,7 +5,7 @@ C_Object::C_Object()
 	world = Oyster::Math::Float4x4::identity; 
 	position = Oyster::Math::Float3::null; 
 	rotation = Oyster::Math::Quaternion::identity; 
-	scale = Oyster::Math::Float3::null; 
+	scale = Oyster::Math::Float3(1); 
 
 	id = 0;
 	model = NULL;
@@ -88,9 +88,12 @@ int C_Object::GetId() const
 	return id;
 }
 void C_Object::Render()
+{
+	if( this->model )
 	{
 		Oyster::Graphics::API::RenderModel(model);
 	}
+}
 void C_Object::Release()
 {
 	if( this->model )
@@ -133,14 +136,16 @@ bool C_Object::InitRB(RBInitData RBInit)
 	type = RBInit.type;
 	return true;
 }
+void C_Object::updateRBWorld()
+{
+	Oyster::Math3D::Float4x4 translation = Oyster::Math3D::TranslationMatrix(this->position); 
+	Oyster::Math3D::Float4x4 rot = Oyster::Math3D::RotationMatrix(this->rotation);
+	Oyster::Math3D::Float4x4 scale = Oyster::Math3D::ScalingMatrix(this->scale);
+	RBworld = translation * rot * scale;
+}
 Oyster::Math::Float4x4 C_Object::getRBWorld() const
 {
-	Oyster::Math3D::Float4x4 translation = Oyster::Math3D::TranslationMatrix(this->RBposition); 
+	return RBworld;
-	Oyster::Math3D::Float4x4 rot = Oyster::Math3D::RotationMatrix(this->RBrotation);
-	Oyster::Math3D::Float4x4 scale = Oyster::Math3D::ScalingMatrix(this->RBscale);
-	Oyster::Math3D::Float4x4 world = translation * rot * scale;
-
-	return world;
 }
 void C_Object::setRBPos(Oyster::Math::Float3 newPos)
 {

Code/Game/GameClient/GameClientState/C_Object.h

@@ -40,6 +40,7 @@ namespace DanBias
 			Oyster::Math::Float3 scale; 
 
 			// RB DEBUG
+			Oyster::Math::Float4x4 RBworld; 
 			Oyster::Math::Float3 RBposition; 
 			Oyster::Math::Quaternion RBrotation; 
 			Oyster::Math::Float3 RBscale; 
@@ -74,6 +75,7 @@ namespace DanBias
 
 
 			// RB DEBUG
+			void updateRBWorld();
 			bool InitRB(RBInitData modelInit);
 			Oyster::Math::Float4x4 getRBWorld() const;
 			void setRBPos(Oyster::Math::Float3 newPos);

Code/Game/GameClient/GameClientState/GameState.cpp

@@ -126,6 +126,7 @@ void GameState::InitiatePlayer( int id, const std::string &modelName, const floa
 	RBData.position = position;
 	RBData.rotation = ArrayToQuaternion( rotation );
 	RBData.scale =  scale;
+	RBData.type = RB_Type_Cube;
 	// !RB DEBUG 
 	if( isMyPlayer )
 	{
@@ -138,7 +139,10 @@ 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.9f;
+			// DEBUG position of camera so we can see the player model
+			offset.y = this->privData->player.getScale().y * 5.0f;
+			offset.z = this->privData->player.getScale().z * -5.0f;
+			// !DEBUG
 			this->privData->camera.SetHeadOffset( offset );
 			this->privData->camera.UpdateOrientation();
 		}
@@ -329,7 +333,11 @@ void GameState::ReadKeyInput()
 	{
 		static const float mouseSensitivity = Radian( 1.0f );
 		this->privData->camera.PitchDown( this->privData->input->GetPitch() * mouseSensitivity );
-		this->privData->nwClient->Send( Protocol_PlayerLeftTurn(this->privData->input->GetYaw() * mouseSensitivity) );
+		float yaw = this->privData->input->GetYaw();
+		//if( yaw != 0.0f )	//This made the camera reset to a specific rotation.
+		{
+			this->privData->nwClient->Send( Protocol_PlayerLeftTurn(yaw * mouseSensitivity) );
+		}
 	}
 
 	// shoot
@@ -498,6 +506,12 @@ const GameClientState::NetEvent & GameState::DataRecieved( const GameClientState
 					this->privData->camera.SetRotation( rotation );
 					this->privData->player.setPos( position );
 					this->privData->player.setRot( rotation );
+					this->privData->player.updateWorld();
+					// RB DEBUG 
+					this->privData->player.setRBPos ( position );  
+					this->privData->player.setRBRot ( rotation );  
+					this->privData->player.updateRBWorld();
+					// !RB DEBUG 
 				}
 
 				C_DynamicObj *object = (*this->privData->dynamicObjects)[decoded.object_ID];
@@ -506,9 +520,11 @@ const GameClientState::NetEvent & GameState::DataRecieved( const GameClientState
 				{
 					object->setPos( position );
 					object->setRot( rotation );
+					object->updateWorld();
 					// RB DEBUG 
 					object->setRBPos ( position );  
 					object->setRBRot ( rotation );  
+					object->updateRBWorld();
 					// !RB DEBUG 
 				}
 			}

Code/Game/GameClient/GameClientState/MainState.cpp

@@ -79,9 +79,10 @@ GameClientState::ClientState MainState::Update( float deltaTime )
 	{
 		bool test = this->privData->input->IsMousePressed();
 		if(test)
-		{
+		{ // HACK: debug trap still in use?
 			int i = 0;
 		};
+
 		this->privData->input->GetMousePos( mouseState.x, mouseState.y );
 		mouseState.mouseButtonPressed = this->privData->input->IsMousePressed();
 	}

Code/Game/GameClient/GameClientState/NetLoadState.cpp

@@ -157,6 +157,7 @@ void NetLoadState::LoadGame( const ::std::string &fileName )
 						RBData.scale =  (Float3)oh->scale * (Float3)oh->boundingVolume.box.size * 2;
 						RBData.type = RB_Type_Cube;
 						staticObject->InitRB( RBData );
+						staticObject->updateRBWorld();
 					}
 
 					if(oh->boundingVolume.geoType == CollisionGeometryType_Sphere)
@@ -166,6 +167,7 @@ void NetLoadState::LoadGame( const ::std::string &fileName )
 						RBData.scale =  (Float3)oh->scale * oh->boundingVolume.sphere.radius * 2;
 						RBData.type = RB_Type_Sphere;
 						staticObject->InitRB( RBData );
+						staticObject->updateRBWorld();
 					}
 					// !RB DEBUG 
 

Code/Game/GameLogic/Game_PlayerData.cpp

@@ -5,7 +5,7 @@ using namespace GameLogic;
 
 Game::PlayerData::PlayerData()
 {	
-	Oyster::Math::Float3 centerPosition = Oyster::Math::Float3(-50,250,0);
+	Oyster::Math::Float3 centerPosition = Oyster::Math::Float3(-50,180,0);
 	Oyster::Math::Float height = 2.0f;
 	Oyster::Math::Float radius = 0.5f;
 	Oyster::Math::Float mass = 40;
@@ -24,7 +24,7 @@ Game::PlayerData::PlayerData()
 Game::PlayerData::PlayerData(int playerID,int teamID)
 {
 
-	Oyster::Math::Float3 centerPosition = Oyster::Math::Float3(-50,250,0);
+	Oyster::Math::Float3 centerPosition = Oyster::Math::Float3(-50,180,0);
 	Oyster::Math::Float height = 2.0f;
 	Oyster::Math::Float radius = 0.5f;
 	Oyster::Math::Float mass = 40;

Code/Game/GameLogic/Level.cpp

@@ -300,6 +300,7 @@ bool Level::InitiateLevel(std::wstring levelPath)
 					Object* dynamicGameObj = CreateGameObj(dynamicObjData, rigidBody_Dynamic);
 					if (dynamicGameObj != NULL)
 					{
+						dynamicGameObj->GetRigidBody()->SetSubscription(Level::PhysicsOnMoveLevel);
 						this->dynamicObjects.Push((DynamicObject*)dynamicGameObj);
 					}
 				}

Code/Game/GameLogic/Object.cpp

@@ -30,6 +30,7 @@ Object::Object(Oyster::Physics::ICustomBody *rigidBody, void (*collisionFuncAfte
 	this->objectID = objectID;
 	this->extraDamageOnCollision = 0;
 	this->rigidBody->SetCustomTag(this);
+	this->scale = Float3(1.0f, 1.0f, 1.0f);
 }
 
 
@@ -41,6 +42,7 @@ Object::Object(Oyster::Physics::ICustomBody *rigidBody , Oyster::Physics::ICusto
 	this->objectID = objectID;
 	this->extraDamageOnCollision = 0;
 	this->rigidBody->SetCustomTag(this);
+	this->scale = Float3(1.0f, 1.0f, 1.0f);
 }
 
 Object::~Object(void)

Code/Game/GameLogic/Player.cpp

@@ -127,7 +127,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)
+	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.2f;

Code/Game/GameProtocols/PlayerProtocols.h

@@ -97,6 +97,8 @@ namespace GameLogic
 		{
 			this->protocol[0].value = protocol_Gameplay_PlayerLeftTurn;
 			this->protocol[0].type = ::Oyster::Network::NetAttributeType_Short;
+			// deltaRadian
+			this->protocol[1].type = ::Oyster::Network::NetAttributeType_Float;
 			this->deltaRadian = deltaRadian;
 		}
 		

Code/Misc/Input/Input.vcxproj

@@ -28,6 +28,7 @@
     <ClCompile Include="Source\Win32\Win32Mouse.cpp" />
   </ItemGroup>
   <ItemGroup>
+    <ClInclude Include="Include\ApplicationKeyboard.h" />
     <ClInclude Include="Include\Common.h" />
     <ClInclude Include="Include\Input.h" />
     <ClInclude Include="Include\InputManager.h" />
@@ -35,6 +36,7 @@
     <ClInclude Include="Include\Keyboard.h" />
     <ClInclude Include="Include\Mouse.h" />
     <ClInclude Include="Include\PreReq.h" />
+    <ClInclude Include="Include\Win32\Win32ApplicationKeyboard.h" />
     <ClInclude Include="Include\Win32\Win32Input.h" />
     <ClInclude Include="Include\Win32\Win32Keyboard.h" />
     <ClInclude Include="Include\Win32\Win32Mouse.h" />

Code/Misc/Input/L_inputClass.cpp

@@ -189,7 +189,7 @@ float InputClass::GetPitch( )
 float InputClass::GetYaw( )
 {
 	float dX = (static_cast<float>( m_mouseState.lX)/5);
-	return -dX;
+	return dX;
 }
 
 bool InputClass::IsMousePressed()

Code/Network/NetworkDependencies/ConnectionUDP.cpp

@@ -0,0 +1,218 @@
+#include "ConnectionUDP.h"
+
+#include <WinSock2.h>
+
+using namespace Oyster::Network;
+
+ConnectionUDP::ConnectionUDP()
+{
+	this->ipSize = 16;
+	this->socket = -1;
+	this->stillSending = false;
+	this->closed = true;
+	this->Address = NULL;
+}
+
+ConnectionUDP::ConnectionUDP( int socket )
+{
+	this->ipSize = 16;
+	this->socket = socket;
+	this->stillSending = false;
+	this->closed = true;
+	this->Address = NULL;
+}
+
+ConnectionUDP::~ConnectionUDP()
+{
+	closesocket( this->socket );
+}
+
+int ConnectionUDP::Connect(unsigned short port, const char serverName[])
+{
+	this->port = port;
+	
+	closed = false;
+	stillSending = true;
+
+	struct hostent *hostEnt;
+	if((hostEnt = gethostbyname(serverName)) == NULL)
+	{
+		return SOCKET_ERROR;
+	}
+
+	
+	this->Address = *(unsigned long*)hostEnt->h_addr;
+	this->port = htons(this->port);
+	return 0;
+}
+
+int ConnectionUDP::Disconnect()
+{
+	int result = closesocket(this->socket);
+
+	if(result == SOCKET_ERROR)
+	{
+		return result;
+	}
+
+	return 0;
+}
+
+int ConnectionUDP::InitiateServer(unsigned short port)
+{
+	int errorCode = 0;
+
+	if((errorCode = InitiateSocket()) != 0)
+	{
+		return errorCode;
+	}
+
+	struct sockaddr_in server;
+	server.sin_family = AF_INET;
+	server.sin_addr.s_addr = INADDR_ANY;
+	server.sin_port = htons(port);
+
+	if(bind(this->socket, (sockaddr*)&server, sizeof(server)) == SOCKET_ERROR)
+	{
+		errorCode = SOCKET_ERROR;
+		closesocket(this->socket);
+		return errorCode;
+	}
+
+	closed = false;
+	stillSending = true;
+	return 0;
+}
+
+int ConnectionUDP::InitiateClient()
+{
+	return InitiateSocket();
+}
+
+int ConnectionUDP::InitiateBroadcast(unsigned short port)
+{
+	int result = InitiateSocket();
+
+
+	int flag = 1;
+	result = setsockopt(this->socket,			/* socket affected */
+							SOL_SOCKET,			/* set option at TCP level */
+							SO_BROADCAST,		/* name of option */
+							(char *) &flag,		/* the cast is historical cruft */
+							sizeof(flag));		/* length of option value */
+	if (result < 0)
+		return -1;
+}
+
+int ConnectionUDP::Send(OysterByte &bytes)
+{
+	int nBytes;
+	struct sockaddr_in reciever;
+	reciever.sin_family = AF_INET;
+	reciever.sin_addr.s_addr = this->Address;
+	reciever.sin_port = port;
+
+	//printf("Send: %d\n", bytes.GetSize());
+	nBytes = sendto(this->socket,
+					bytes,
+					bytes.GetSize(),
+					0,
+					(sockaddr*)&reciever, 
+					sizeof(sockaddr_in)
+					); 
+
+	if ( nBytes != bytes.GetSize() )
+    {
+		return nBytes;
+    }
+
+	return 0;
+}
+
+int ConnectionUDP::Recieve(OysterByte &bytes)
+{
+	int nBytes;
+	sockaddr_in from;
+    int fromLength = sizeof( from );
+
+	bytes.Resize(1000);
+	nBytes = recvfrom(this->socket,
+					  bytes,
+					  1000,
+					  0,
+					  (sockaddr*)&from,
+					  &fromLength 
+					  );
+
+
+	if(nBytes <= 0)
+	{
+		bytes.SetSize(0);
+		return WSAGetLastError();
+	}
+	else
+	{
+		bytes.SetSize(nBytes);
+	}
+
+
+	//address and port of the client who sent the message
+	unsigned int from_address = ntohl( from.sin_addr.s_addr );
+    unsigned int from_port = ntohs( from.sin_port );
+
+
+	return 0;
+}
+
+bool ConnectionUDP::IsSending()
+{
+	return stillSending;
+}
+
+bool ConnectionUDP::IsConnected()
+{
+	if(closed)
+	{
+		return false;
+	}
+
+	return true;
+}
+
+int ConnectionUDP::SetBlockingMode( bool blocking )
+{
+	DWORD nonBlocking;
+
+	if(blocking)
+	{
+		nonBlocking = 0;
+	}
+	else
+	{
+		nonBlocking = 1;
+	}
+
+	int result = ioctlsocket(this->socket, FIONBIO, &nonBlocking);
+	if(result != 0)
+	{
+		return result;
+	}
+
+	//Success
+	return 0;
+}
+//////////////////////////////////////
+// Private Methods
+//////////////////////////////////////
+
+int ConnectionUDP::InitiateSocket()
+{
+	this->socket = (int)::socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
+
+	if(this->socket == SOCKET_ERROR)
+	{
+		return socket;
+	}
+
+	return 0;
+}

Code/Network/NetworkDependencies/ConnectionUDP.h

@@ -0,0 +1,57 @@
+#ifndef NETWORK_DEPENDENCIES_CONNECTIONUDP_H
+#define NETWORK_DEPENDENCIES_CONNECTIONUDP_H
+
+//////////////////////////////////
+// Created by Sam Svensson 2013 //
+//////////////////////////////////
+
+#include "IConnection.h"
+#include "../NetworkDependencies/OysterByte.h"
+
+namespace Oyster
+{
+	namespace Network
+	{
+		class ConnectionUDP : public IConnection
+		{
+		public:
+			ConnectionUDP();
+			ConnectionUDP( int socket);
+			virtual ~ConnectionUDP();
+
+			virtual int InitiateServer( unsigned short port );
+			virtual int InitiateClient();
+
+			virtual int InitiateBroadcast(unsigned short port);
+
+			virtual int Send ( OysterByte &byte );
+			virtual int Recieve( OysterByte &byte );
+
+			virtual int Connect( unsigned short port, const char serverName[] );
+
+			virtual int Disconnect();
+
+			bool IsSending();
+			bool IsConnected();
+			int GetIpSize();
+
+			int SetBlockingMode( bool blocking );
+
+		private:
+			int InitiateSocket();
+
+			int socket;
+			//char ipAddress[16];
+			//unsigned short port;
+			int ipSize;
+			
+			unsigned long Address;
+			unsigned short port;
+
+			bool stillSending;
+			bool closed;
+		};
+	}
+}
+
+#endif

Code/Network/NetworkDependencies/NetworkDependencies.vcxproj

@@ -147,6 +147,7 @@
   </ItemDefinitionGroup>
   <ItemGroup>
     <ClCompile Include="Connection.cpp" />
+    <ClCompile Include="ConnectionUDP.cpp" />
     <ClCompile Include="Listener.cpp" />
     <ClCompile Include="Messages\MessageHeader.cpp" />
     <ClCompile Include="Messages\MessagePlayerPos.cpp" />
@@ -157,6 +158,7 @@
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="Connection.h" />
+    <ClInclude Include="ConnectionUDP.h" />
     <ClInclude Include="IConnection.h" />
     <ClInclude Include="IPostBox.h" />
     <ClInclude Include="Listener.h" />

Code/Network/NetworkDependencies/NetworkDependencies.vcxproj.filters

@@ -9,6 +9,7 @@
     <ClCompile Include="OysterByte.cpp" />
     <ClCompile Include="ThreadedClient.cpp" />
     <ClCompile Include="WinsockFunctions.cpp" />
+    <ClCompile Include="ConnectionUDP.cpp" />
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="Connection.h" />
@@ -25,5 +26,6 @@
     <ClInclude Include="Protocols.h" />
     <ClInclude Include="ThreadedClient.h" />
     <ClInclude Include="WinsockFunctions.h" />
+    <ClInclude Include="ConnectionUDP.h" />
   </ItemGroup>
 </Project>

Code/Physics/GamePhysics/Implementation/PhysicsAPI_Impl.cpp

@@ -283,6 +283,11 @@ void API_Impl::UpdateWorld()
 		SimpleRigidBody* simpleBody = dynamic_cast<SimpleRigidBody*>(this->customBodies[i]);
 		this->customBodies[i]->SetGravity(-(this->customBodies[i]->GetState().centerPos - this->gravityPoint).GetNormalized()*this->gravity);
 		simpleBody->PreStep(this->dynamicsWorld);
+
+		if(simpleBody->GetRigidBody()->getActivationState() == ACTIVE_TAG)
+		{
+			this->customBodies[i]->CallSubscription_Move();
+		}	
 	}
 
 	this->dynamicsWorld->stepSimulation(this->timeStep, 1, this->timeStep);
@@ -296,11 +301,6 @@ void API_Impl::UpdateWorld()
 		trans = simpleBody->GetRigidBody()->getWorldTransform();
 		this->customBodies[i]->SetPosition(Float3(trans.getOrigin().x(), trans.getOrigin().y(), trans.getOrigin().z()));
 		this->customBodies[i]->SetRotation(Quaternion(Float3(trans.getRotation().x(), trans.getRotation().y(), trans.getRotation().z()), trans.getRotation().w()));		
-
-		if(simpleBody->GetRigidBody()->getActivationState() == ACTIVE_TAG)
-		{
-			this->customBodies[i]->CallSubscription_Move();
-		}		
 	}
 
 	int numManifolds = this->dynamicsWorld->getDispatcher()->getNumManifolds();