609 lines
17 KiB
C++
609 lines
17 KiB
C++
#include "GameState.h"
|
|
#include "DllInterfaces/GFXAPI.h"
|
|
#include <Protocols.h>
|
|
#include "NetworkClient.h"
|
|
#include "Camera_FPSV2.h"
|
|
#include <GameServerAPI.h>
|
|
#include "C_Light.h"
|
|
#include "C_obj/C_Player.h"
|
|
#include "C_obj/C_DynamicObj.h"
|
|
#include "C_obj/C_StaticObj.h"
|
|
#include "Utilities.h"
|
|
#include "GamingUI.h"
|
|
#include "RespawnUI.h"
|
|
#include "StatsUI.h"
|
|
|
|
using namespace ::DanBias::Client;
|
|
using namespace ::Oyster;
|
|
using namespace ::Oyster::Network;
|
|
using namespace ::Oyster::Math3D;
|
|
using namespace ::GameLogic;
|
|
using namespace ::Utility::DynamicMemory;
|
|
using namespace ::Utility::String;
|
|
using namespace ::Utility::Value;
|
|
|
|
struct GameState::MyData
|
|
{
|
|
MyData(){}
|
|
GameClientState::ClientState nextState;
|
|
NetworkClient *nwClient;
|
|
InputClass *input;
|
|
|
|
::std::map<int, ::Utility::DynamicMemory::UniquePointer<::DanBias::Client::C_StaticObj>> *staticObjects;
|
|
::std::map<int, ::Utility::DynamicMemory::UniquePointer<::DanBias::Client::C_DynamicObj>> *dynamicObjects;
|
|
::std::map<int, ::Utility::DynamicMemory::UniquePointer<::DanBias::Client::C_Light>> *lights;
|
|
|
|
C_Player player;
|
|
Camera_FPSV2 camera;
|
|
|
|
int myId;
|
|
|
|
} privData;
|
|
|
|
inline Quaternion ArrayToQuaternion( const float source[4] )
|
|
{
|
|
return Quaternion( Float3(source[0], source[1], source[2]), source[3] );
|
|
}
|
|
|
|
GameState::GameState()
|
|
{
|
|
this->privData = nullptr;
|
|
}
|
|
|
|
GameState::~GameState()
|
|
{
|
|
if( this->privData )
|
|
this->Release();
|
|
}
|
|
|
|
bool GameState::Init( SharedStateContent &shared )
|
|
{
|
|
// we may assume that shared.network is properly connected
|
|
// and there is content in shared.dynamicObjects and shared.staticObjects
|
|
|
|
this->privData = new MyData();
|
|
|
|
this->privData->nextState = GameClientState::ClientState_Same;
|
|
this->privData->nwClient = shared.network;
|
|
this->privData->input = shared.input;
|
|
this->privData->staticObjects = &shared.staticObjects;
|
|
this->privData->dynamicObjects = &shared.dynamicObjects;
|
|
this->privData->lights = &shared.lights;
|
|
|
|
Graphics::API::Option gfxOp = Graphics::API::GetOption();
|
|
Float aspectRatio = gfxOp.Resolution.x / gfxOp.Resolution.y;
|
|
this->privData->camera.SetPerspectiveProjection( Utility::Value::Radian(90.0f), aspectRatio, 0.1f, 1000.0f );
|
|
Graphics::API::SetProjection( this->privData->camera.GetProjectionMatrix() );
|
|
gfxOp.AmbientValue = 0.5f;
|
|
gfxOp.GlobalGlowTint = Math::Float3(2,1,1);
|
|
gfxOp.GlobalTint = Math::Float3(1,1,1);
|
|
Graphics::API::SetOptions(gfxOp);
|
|
|
|
//tell server ready
|
|
this->privData->nwClient->Send( Protocol_General_Status(Protocol_General_Status::States_ready) );
|
|
|
|
// DEGUG KEYS
|
|
this->key_Reload_Shaders = false;
|
|
this->key_Wireframe_Toggle = false;
|
|
this->renderWhireframe = false;
|
|
// !DEGUG KEYS
|
|
|
|
auto light = this->privData->lights->begin();
|
|
for( ; light != this->privData->lights->end(); ++light )
|
|
{
|
|
light->second->Render();
|
|
}
|
|
|
|
// create UI states
|
|
this->gameUI = new GamingUI(this->privData->input, this->privData->nwClient, &this->privData->camera);
|
|
this->respawnUI = new RespawnUI(this->privData->nwClient, 20);
|
|
this->statsUI = new StatsUI();
|
|
this->currGameUI = gameUI;
|
|
((GamingUI*)gameUI)->Init();
|
|
((RespawnUI*)respawnUI)->Init();
|
|
((StatsUI*)statsUI)->Init();
|
|
|
|
return true;
|
|
}
|
|
|
|
void GameState::InitiatePlayer( int id, const std::string &modelName, const float position[3], const float rotation[4], const float scale[3], bool isMyPlayer )
|
|
{
|
|
ModelInitData modelData;
|
|
modelData.visible = true;
|
|
modelData.position = position;
|
|
modelData.rotation = ArrayToQuaternion( rotation );
|
|
modelData.scale = scale;
|
|
StringToWstring( modelName, modelData.modelPath );
|
|
modelData.id = id;
|
|
|
|
// RB DEBUG
|
|
RBInitData RBData;
|
|
RBData.position = position;
|
|
RBData.rotation = ArrayToQuaternion( rotation );
|
|
RBData.scale = scale;
|
|
RBData.type = RB_Type_Cube;
|
|
// !RB DEBUG
|
|
if( isMyPlayer )
|
|
{
|
|
if( this->privData->player.Init(modelData) )
|
|
{
|
|
// RB DEBUG
|
|
this->privData->player.InitRB( RBData );
|
|
// !RB DEBUG
|
|
|
|
this->privData->myId = id;
|
|
this->privData->camera.SetPosition( this->privData->player.getPos() );
|
|
Float3 offset = Float3( 0.0f );
|
|
// 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();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
C_DynamicObj *p = new C_DynamicObj();
|
|
if( p->Init(modelData) )
|
|
{
|
|
// RB DEBUG
|
|
this->privData->player.InitRB( RBData );
|
|
// !RB DEBUG
|
|
|
|
(*this->privData->dynamicObjects)[id] = p;
|
|
}
|
|
}
|
|
}
|
|
|
|
GameClientState::ClientState GameState::Update( float deltaTime )
|
|
{
|
|
GameStateUI::UIState UIstate = this->currGameUI->Update( deltaTime );
|
|
switch (UIstate)
|
|
{
|
|
case DanBias::Client::GameStateUI::UIState_same:
|
|
break;
|
|
case DanBias::Client::GameStateUI::UIState_gaming:
|
|
break;
|
|
case DanBias::Client::GameStateUI::UIState_main_menu:
|
|
//this->privData->nextState =
|
|
break;
|
|
case DanBias::Client::GameStateUI::UIState_shut_down:
|
|
this->privData->nextState = ClientState_Quit;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
// DEBUG keybindings
|
|
ReadKeyInput();
|
|
|
|
return this->privData->nextState;
|
|
}
|
|
|
|
bool GameState::Render()
|
|
{
|
|
Oyster::Graphics::API::SetView( this->privData->camera.GetViewMatrix() );
|
|
|
|
Oyster::Graphics::API::NewFrame();
|
|
|
|
// for debugging to be replaced with render weapon
|
|
this->privData->player.Render();
|
|
|
|
auto staticObject = this->privData->staticObjects->begin();
|
|
for( ; staticObject != this->privData->staticObjects->end(); ++staticObject )
|
|
{
|
|
staticObject->second->Render();
|
|
}
|
|
|
|
auto dynamicObject = this->privData->dynamicObjects->begin();
|
|
for( ; dynamicObject != this->privData->dynamicObjects->end(); ++dynamicObject )
|
|
{
|
|
if( dynamicObject->second )
|
|
{
|
|
dynamicObject->second->Render();
|
|
|
|
}
|
|
}
|
|
|
|
#ifdef _DEBUG
|
|
//RB DEBUG render wire frame
|
|
if(this->renderWhireframe)
|
|
{
|
|
Oyster::Graphics::API::StartRenderWireFrame();
|
|
|
|
Oyster::Math3D::Float4x4 translation = Oyster::Math3D::TranslationMatrix(Float3( 0,132, 20));
|
|
Oyster::Math3D::Float4x4 scale = Oyster::Math3D::ScalingMatrix(Float3( 0.5f, 0.5f, 0.5f));
|
|
Oyster::Math3D::Float4x4 world = translation * scale;
|
|
Oyster::Graphics::API::RenderDebugCube( world );
|
|
Oyster::Graphics::API::RenderDebugCube(this->privData->player.getRBWorld());
|
|
|
|
staticObject = this->privData->staticObjects->begin();
|
|
for( ; staticObject != this->privData->staticObjects->end(); ++staticObject )
|
|
{
|
|
if( staticObject->second->getBRtype() == RB_Type_Cube)
|
|
{
|
|
Oyster::Graphics::API::RenderDebugCube( staticObject->second->getRBWorld());
|
|
}
|
|
if( staticObject->second->getBRtype() == RB_Type_Sphere)
|
|
{
|
|
Oyster::Graphics::API::RenderDebugSphere( staticObject->second->getRBWorld());
|
|
}
|
|
}
|
|
|
|
dynamicObject = this->privData->dynamicObjects->begin();
|
|
for( ; dynamicObject != this->privData->dynamicObjects->end(); ++dynamicObject )
|
|
{
|
|
if( dynamicObject->second )
|
|
{
|
|
if( dynamicObject->second->getBRtype() == RB_Type_Cube)
|
|
{
|
|
Oyster::Graphics::API::RenderDebugCube( dynamicObject->second->getRBWorld());
|
|
}
|
|
if( dynamicObject->second->getBRtype() == RB_Type_Sphere)
|
|
{
|
|
Oyster::Graphics::API::RenderDebugSphere( dynamicObject->second->getRBWorld());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
//!RB DEBUG
|
|
#endif
|
|
|
|
Oyster::Graphics::API::StartGuiRender();
|
|
// render gui elemnts
|
|
if(currGameUI->HaveGUIRender())
|
|
currGameUI->RenderGUI();
|
|
if(renderStats)
|
|
{
|
|
if(statsUI->HaveGUIRender())
|
|
statsUI->RenderGUI();
|
|
}
|
|
Oyster::Graphics::API::StartTextRender();
|
|
if(currGameUI->HaveTextRender())
|
|
currGameUI->RenderText();
|
|
if(renderStats)
|
|
{
|
|
if(statsUI->HaveTextRender())
|
|
statsUI->RenderText();
|
|
}
|
|
|
|
Oyster::Graphics::API::EndFrame();
|
|
return true;
|
|
}
|
|
|
|
bool GameState::Release()
|
|
{
|
|
Graphics::API::Option o = Graphics::API::GetOption();
|
|
if( privData )
|
|
{
|
|
auto staticObject = this->privData->staticObjects->begin();
|
|
for( ; staticObject != this->privData->staticObjects->end(); ++staticObject )
|
|
{
|
|
staticObject->second = nullptr;
|
|
}
|
|
|
|
auto dynamicObject = this->privData->dynamicObjects->begin();
|
|
for( ; dynamicObject != this->privData->dynamicObjects->end(); ++dynamicObject )
|
|
{
|
|
dynamicObject->second = nullptr;
|
|
}
|
|
|
|
auto light = this->privData->lights->begin();
|
|
for( ; light != this->privData->lights->end(); ++light )
|
|
{
|
|
light->second->Render();
|
|
}
|
|
|
|
this->privData->staticObjects->clear();
|
|
this->privData->dynamicObjects->clear();
|
|
this->privData->lights->clear();
|
|
|
|
privData = NULL;
|
|
}
|
|
|
|
if(respawnUI)
|
|
{
|
|
respawnUI->Release();
|
|
delete respawnUI;
|
|
respawnUI = NULL;
|
|
}
|
|
if(gameUI)
|
|
{
|
|
gameUI->Release();
|
|
delete gameUI;
|
|
gameUI = NULL;
|
|
}
|
|
if(statsUI)
|
|
{
|
|
statsUI->Release();
|
|
delete statsUI;
|
|
statsUI = NULL;
|
|
}
|
|
currGameUI = NULL;
|
|
|
|
return true;
|
|
}
|
|
|
|
void GameState::ChangeState( ClientState next )
|
|
{
|
|
this->privData->nextState = next;
|
|
}
|
|
void GameState::ReadKeyInput()
|
|
{
|
|
// DEGUG KEYS
|
|
|
|
// Reload shaders
|
|
if( this->privData->input->IsKeyPressed(DIK_R) )
|
|
{
|
|
if( !this->key_Reload_Shaders )
|
|
{
|
|
#ifdef _DEBUG
|
|
Oyster::Graphics::API::ReloadShaders();
|
|
#endif
|
|
this->key_Reload_Shaders = true;
|
|
}
|
|
}
|
|
else
|
|
this->key_Reload_Shaders = false;
|
|
|
|
// toggle wire frame render
|
|
if( this->privData->input->IsKeyPressed(DIK_T) )
|
|
{
|
|
if( !this->key_Wireframe_Toggle )
|
|
{
|
|
this->renderWhireframe = !this->renderWhireframe;
|
|
this->key_Wireframe_Toggle = true;
|
|
// DEBUG set you as dead when render wireframe
|
|
this->currGameUI = respawnUI;
|
|
// !DEBUG
|
|
}
|
|
}
|
|
else
|
|
{
|
|
this->key_Wireframe_Toggle = false;
|
|
// DEBUG set you as dead when render wireframe
|
|
this->currGameUI = gameUI;
|
|
// !DEBUG
|
|
}
|
|
|
|
// toggle wire frame render
|
|
if( this->privData->input->IsKeyPressed(DIK_TAB) )
|
|
{
|
|
if( !this->key_showStats )
|
|
{
|
|
this->renderStats = true;
|
|
this->key_showStats = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
this->renderStats = false;
|
|
this->key_showStats = false;
|
|
}
|
|
}
|
|
const GameClientState::NetEvent & GameState::DataRecieved( const GameClientState::NetEvent &message )
|
|
{
|
|
if( message.args.type == NetworkClient::ClientEventArgs::EventType_ProtocolFailedToSend )
|
|
{ // 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 */
|
|
case protocol_Gameplay_ObjectDamage:
|
|
{
|
|
Protocol_ObjectDamage decoded(data);
|
|
if( this->privData->myId == decoded.object_ID )
|
|
{
|
|
if(currGameUI == gameUI)
|
|
{
|
|
((GamingUI*)currGameUI)->SetHPtext(std::to_wstring(decoded.healthLost));
|
|
}
|
|
}
|
|
}
|
|
return GameClientState::event_processed;
|
|
case protocol_Gameplay_ObjectHealthStatus:
|
|
{
|
|
}
|
|
return GameClientState::event_processed;
|
|
case protocol_Gameplay_ObjectPosition:
|
|
{
|
|
Protocol_ObjectPosition decoded(data);
|
|
|
|
// if is this player. Remember to change camera
|
|
if( this->privData->myId == decoded.object_ID )
|
|
this->privData->camera.SetPosition( decoded.position );
|
|
|
|
(*this->privData->dynamicObjects)[decoded.object_ID]->setPos( decoded.position );
|
|
// RB DEBUG
|
|
(*this->privData->dynamicObjects)[decoded.object_ID]->setRBPos ( decoded.position );
|
|
// !RB DEBUG
|
|
}
|
|
return GameClientState::event_processed;
|
|
case protocol_Gameplay_ObjectScale:
|
|
{
|
|
Protocol_ObjectScale decoded(data);
|
|
(*this->privData->dynamicObjects)[decoded.object_ID]->setScale( decoded.scale );
|
|
// RB DEBUG
|
|
(*this->privData->dynamicObjects)[decoded.object_ID]->setRBScale ( decoded.scale );
|
|
// !RB DEBUG
|
|
}
|
|
return GameClientState::event_processed;
|
|
case protocol_Gameplay_ObjectRotation:
|
|
{
|
|
Protocol_ObjectRotation decoded(data);
|
|
Quaternion rotation = Quaternion( Float3(decoded.rotationQ), decoded.rotationQ[3] );
|
|
|
|
// if is this player. Remember to change camera
|
|
if( this->privData->myId == decoded.object_ID )
|
|
this->privData->camera.SetRotation( rotation );
|
|
|
|
(*this->privData->dynamicObjects)[decoded.object_ID]->setRot( rotation );
|
|
// RB DEBUG
|
|
(*this->privData->dynamicObjects)[decoded.object_ID]->setRBRot ( rotation );
|
|
// !RB DEBUG
|
|
}
|
|
return GameClientState::event_processed;
|
|
case protocol_Gameplay_ObjectPositionRotation:
|
|
{
|
|
Protocol_ObjectPositionRotation decoded(data);
|
|
Float3 position = decoded.position;
|
|
Quaternion rotation = Quaternion( Float3(decoded.rotationQ), decoded.rotationQ[3] );
|
|
|
|
// if is this player. Remember to change camera
|
|
if( this->privData->myId == decoded.object_ID )
|
|
{
|
|
if( !Within(position.Dot(position), 2500.0f, 90000.0f) )
|
|
{ // HACK: bug trap
|
|
const char *breakPoint = "Something is wrong.";
|
|
position = Float3( 0.0f, 160.0f, 0.0f );
|
|
}
|
|
|
|
this->privData->camera.SetPosition( position );
|
|
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
|
|
}
|
|
else
|
|
{
|
|
C_DynamicObj *object = (*this->privData->dynamicObjects)[decoded.object_ID];
|
|
|
|
if( object )
|
|
{
|
|
object->setPos( position );
|
|
object->setRot( rotation );
|
|
object->updateWorld();
|
|
// RB DEBUG
|
|
object->setRBPos ( position );
|
|
object->setRBRot ( rotation );
|
|
object->updateRBWorld();
|
|
// !RB DEBUG
|
|
}
|
|
}
|
|
}
|
|
return GameClientState::event_processed;
|
|
case protocol_Gameplay_ObjectEnabled: break; /** @todo TODO: implement */
|
|
case protocol_Gameplay_ObjectDisabled:
|
|
{
|
|
Protocol_ObjectDisable decoded(data);
|
|
|
|
auto object = this->privData->dynamicObjects->find( decoded.objectID );
|
|
if( object != this->privData->dynamicObjects->end() )
|
|
{
|
|
object->second = nullptr;
|
|
this->privData->dynamicObjects->erase( object );
|
|
}
|
|
}
|
|
return GameClientState::event_processed;
|
|
case protocol_Gameplay_ObjectCreate:
|
|
{
|
|
Protocol_ObjectCreate decoded(data);
|
|
C_DynamicObj* object = new C_DynamicObj();
|
|
|
|
ModelInitData modelData;
|
|
{
|
|
modelData.position = Float3( decoded.position );
|
|
modelData.rotation = Quaternion( Float3(decoded.position), decoded.rotationQ[3] );
|
|
modelData.scale = Float3( decoded.scale );
|
|
modelData.visible = true;
|
|
modelData.id = decoded.object_ID;
|
|
|
|
::Utility::String::StringToWstring( decoded.name, modelData.modelPath );
|
|
}
|
|
object->Init(modelData);
|
|
// RB DEBUG
|
|
// Is just using the model position since the rigid body data should never be sent to the client
|
|
RBInitData RBData;
|
|
RBData.position = decoded.position;
|
|
RBData.rotation = ArrayToQuaternion( decoded.position );
|
|
RBData.scale = Float3( decoded.scale );
|
|
|
|
this->privData->player.InitRB( RBData );
|
|
// !RB DEBUG
|
|
|
|
(*this->privData->dynamicObjects)[decoded.object_ID] = object;
|
|
|
|
}
|
|
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 );
|
|
}
|
|
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 */
|
|
case protocol_Gameplay_ObjectWeaponEnergy: break; /** @todo TODO: implement */
|
|
case protocol_Gameplay_ObjectRespawn:
|
|
{
|
|
// set player pos
|
|
Protocol_ObjectRespawn decoded(data);
|
|
// move player. Remember to change camera
|
|
this->privData->camera.SetPosition( decoded.position );
|
|
this->privData->player.setPos( decoded.position );
|
|
this->privData->player.updateWorld();
|
|
// RB DEBUG
|
|
this->privData->player.setRBPos ( decoded.position );
|
|
this->privData->player.updateRBWorld();
|
|
// !RB DEBUG
|
|
|
|
this->currGameUI = this->gameUI;
|
|
}
|
|
return GameClientState::event_processed;
|
|
case protocol_Gameplay_ObjectDie:
|
|
{
|
|
Protocol_ObjectDie decoded(data);
|
|
// if is this player. Remember to change camera
|
|
if( this->privData->myId == decoded.objectID )
|
|
{
|
|
this->currGameUI = this->respawnUI;
|
|
// set countdown
|
|
((RespawnUI*)currGameUI)->SetCountdown( decoded.seconds );
|
|
}
|
|
}
|
|
return GameClientState::event_processed;
|
|
case protocol_Gameplay_ObjectDisconnectPlayer:
|
|
{
|
|
//Remove the disconnected player
|
|
Protocol_ObjectDisconnectPlayer decoded(data);
|
|
auto object = this->privData->dynamicObjects->find( decoded.objectID );
|
|
if( object != this->privData->dynamicObjects->end() )
|
|
{
|
|
object->second = nullptr;
|
|
this->privData->dynamicObjects->erase( object );
|
|
}
|
|
}
|
|
return GameClientState::event_processed;
|
|
default: break;
|
|
}
|
|
}
|
|
else if( ProtocolIsGeneral(ID) )
|
|
{
|
|
switch( ID )
|
|
{
|
|
case protocol_General_Status: break; /** @todo TODO: implement */
|
|
case protocol_General_Text: break; /** @todo TODO: implement */
|
|
default: break;
|
|
}
|
|
}
|
|
|
|
return message;
|
|
}
|