BTH/axyz
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Merge remote-tracking branch 'origin/master' into Rendering

Browse Source 
# Conflicts:
#	include/Engine/Editor/EditorSystem.h
#	include/Engine/Rendering/EPicking.h
#	include/Engine/Rendering/Renderer.h
#	include/Game/Game.h
#	resources/Schema/Components.xsd
#	resources/Schema/Entities/Test.xml
#	src/Engine/Editor/EditorSystem.cpp
#	src/Engine/Rendering/RawModel.cpp
#	src/Engine/Rendering/RenderQueueFactory.cpp
#	src/Engine/Rendering/Renderer.cpp
#	src/Game/Game.cpp
This commit is contained in:
viktorljung
2016-01-12 16:13:20 +01:00
parent 2450769190 84818f6fcb
commit 0f17f9a888
110 changed files with 6424 additions and 1129 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/Game/CMakeLists.txt
+1
View File
@@ -19,6 +19,7 @@ file(GLOB SOURCE_FILES
set(SOURCE_FILES
${SOURCE_FILES}
"Game.cpp"
"HealthSystem.cpp"
"PlayerSystem.cpp"
)
src/Game/Game.cpp
+64 -31
View File
@@ -1,12 +1,16 @@
#include "Game.h"
#include "Collision/TriggerSystem.h"
#include "Collision/CollisionSystem.h"
#include "Game/HealthSystem.h"
#include "Core/EntityFileWriter.h"
Game::Game(int argc, char* argv[])
{
ResourceManager::RegisterType<ConfigFile>("ConfigFile");
ResourceManager::RegisterType<Model>("Model");
ResourceManager::RegisterType<Texture>("Texture");
ResourceManager::RegisterType<EntityXMLFile>("EntityXMLFile");
ResourceManager::RegisterType<ShaderProgram>("ShaderProgram");
ResourceManager::RegisterType<EntityFile>("EntityFile");
m_Config = ResourceManager::Load<ConfigFile>("Config.ini");
LOG_LEVEL = static_cast<_LOG_LEVEL>(m_Config->Get<int>("Debug.LogLevel", 1));
@@ -19,7 +23,7 @@ Game::Game(int argc, char* argv[])
m_Renderer = new Renderer(m_EventBroker, m_World);
m_Renderer->SetFullscreen(m_Config->Get<bool>("Video.Fullscreen", false));
m_Renderer->SetVSYNC(m_Config->Get<bool>("Video.VSYNC", false));
m_Renderer->SetResolution(Rectangle(
m_Renderer->SetResolution(Rectangle::Rectangle(
0,
0,
m_Config->Get<int>("Video.Width", 1280),
@@ -44,26 +48,51 @@ Game::Game(int argc, char* argv[])
m_World = new World();
std::string mapToLoad = m_Config->Get<std::string>("Debug.LoadMap", "");
if (!mapToLoad.empty()) {
ResourceManager::Load<EntityXMLFile>(mapToLoad)->PopulateWorld(m_World);
auto file = ResourceManager::Load<EntityFile>(mapToLoad);
EntityFilePreprocessor fpp(file);
fpp.RegisterComponents(m_World);
EntityFileParser fp(file);
fp.MergeEntities(m_World);
}
m_RenderFrame = new RenderFrame();
// Create system pipeline
m_SystemPipeline = new SystemPipeline(m_EventBroker);
m_SystemPipeline->AddSystem<RaptorCopterSystem>();
m_SystemPipeline->AddSystem<PlayerSystem>();
m_SystemPipeline->AddSystem<EditorSystem>(m_Renderer);
m_SystemPipeline->AddSystem<RenderSystem>(m_Renderer, m_RenderFrame);
//All systems with orderlevel 0 will be updated first.
unsigned int updateOrderLevel = 0;
m_SystemPipeline->AddSystem<RaptorCopterSystem>(updateOrderLevel);
m_SystemPipeline->AddSystem<PlayerSystem>(updateOrderLevel);
m_SystemPipeline->AddSystem<EditorSystem>(updateOrderLevel, m_Renderer);
m_SystemPipeline->AddSystem<HealthSystem>(updateOrderLevel);
//Collision and TriggerSystem should update after player.
++updateOrderLevel;
m_SystemPipeline->AddSystem<CollisionSystem>(updateOrderLevel);
m_SystemPipeline->AddSystem<TriggerSystem>(updateOrderLevel);
++updateOrderLevel;
m_SystemPipeline->AddSystem<RenderSystem>(updateOrderLevel, m_Renderer, m_RenderFrame);
// Invoke network
if (m_Config->Get<bool>("Networking.StartNetwork", false)) {
//boost::thread workerThread(&Game::networkFunction, this);
networkFunction();
}
m_LastTime = glfwGetTime();
debugInitialize();
}
Game::~Game()
{
delete m_SystemPipeline;
delete m_World;
delete m_FrameStack;
delete m_InputProxy;
delete m_InputManager;
delete m_RenderFrame;
delete m_Renderer;
delete m_EventBroker;
}
@@ -85,10 +114,15 @@ void Game::Tick()
m_InputProxy->Process();
m_EventBroker->Swap();
// Update network
if (m_IsClientOrServer) {
m_ClientOrServer->Update();
}
// Iterate through systems and update world!
m_SystemPipeline->Update(m_World, dt);
debugTick(dt);
m_Renderer->Update(dt);
m_EventBroker->Process<Client>();
GLERROR("Game::Tick m_RenderQueueFactory->Update");
m_Renderer->Draw(*m_RenderFrame);
@@ -97,28 +131,27 @@ void Game::Tick()
m_EventBroker->Clear();
}
bool Game::debugOnInputCommand(const Events::InputCommand& e)
{
if (e.Command == "DebugReload" && e.Value == 1) {
std::string mapToLoad = m_Config->Get<std::string>("Debug.LoadMap", "");
if (!mapToLoad.empty()) {
delete m_World;
m_World = new World();
ResourceManager::Release("EntityXMLFile", mapToLoad);
ResourceManager::Load<EntityXMLFile>(mapToLoad)->PopulateWorld(m_World);
}
}
return false;
}
void Game::debugInitialize()
{
EVENT_SUBSCRIBE_MEMBER(m_EInputCommand, &Game::debugOnInputCommand);
}
void Game::debugTick(double dt)
{
m_EventBroker->Process<Game>();
}
void Game::networkFunction()
{
bool isServer = m_Config->Get<bool>("Networking.IsServer", false);
if (!isServer) {
m_IsClientOrServer = true;
m_ClientOrServer = new Client(m_Config);
}
if (isServer) {
m_IsClientOrServer = true;
m_ClientOrServer = new Server();
}
m_ClientOrServer->Start(m_World, m_EventBroker);
// I don't think we are reaching this part of the code right now.
// ~Game() is not called if the game is exited by closing console windows
// When server or client is done set it to false.
//m_IsClientOrServer = false;
// Destroy it
//delete m_ClientOrServer;
}
src/Game/HealthSystem.cpp
+59
View File
@@ -0,0 +1,59 @@
#include "HealthSystem.h"
#include <algorithm>
HealthSystem::HealthSystem(EventBroker* eventBroker)
: PureSystem(eventBroker, "Health")
{
//subscribe/listenTo playerdamage,healthpickup events (using the eventBroker)
EVENT_SUBSCRIBE_MEMBER(m_EPlayerDamage, &HealthSystem::OnPlayerDamaged);
EVENT_SUBSCRIBE_MEMBER(m_EPlayerHealthPickup, &HealthSystem::OnPlayerHealthPickup);
}
void HealthSystem::UpdateComponent(World *world, ComponentWrapper &health, double dt)
{
//if entityID of health is 9 then the players ID is also 9 (player,health are connected to the same entity)
ComponentWrapper player = world->GetComponent(health.EntityID, "Player");
double maxHealth = (double)health["MaxHealth"];
//process the DeltaHealthVector and change the entitys health accordingly
for (size_t i = m_DeltaHealthVector.size(); i > 0; i--)
{
auto deltaHP = m_DeltaHealthVector[i - 1];
//if we have a healthchange for the current player and health is greater than 0, then apply it
if (std::get<0>(deltaHP) == player.EntityID && (double)health["Health"] > 0.0f) {
//get the deltaHP value from the tuple and make sure you dont get more than maxHealth
double newHealth = std::min((double)health["Health"] + (double)std::get<1>(deltaHP), maxHealth);
health["Health"] = newHealth;
m_DeltaHealthVector.erase(m_DeltaHealthVector.begin() + i - 1);
//check if health is <= 0
if ((double)health["Health"] <= 0.0f) {
//publish death event
Events::PlayerDeath e;
e.PlayerID = player.EntityID;
m_EventBroker->Publish(e);
//clear the remaining hpDeltas for the dead player
for (size_t j = m_DeltaHealthVector.size(); j > 0; j--)
{
if (std::get<0>(m_DeltaHealthVector[j - 1]) == player.EntityID)
m_DeltaHealthVector.erase(m_DeltaHealthVector.begin() + j - 1);
}
//break the loop if the player is dead
break;
}
}
}
}
bool HealthSystem::OnPlayerDamaged(const Events::PlayerDamage& e)
{
//save the changed HP to a vector. it will be taken care of in UpdateComponent
m_DeltaHealthVector.push_back(std::make_tuple(e.PlayerDamagedID, -e.DamageAmount));
return true;
}
bool HealthSystem::OnPlayerHealthPickup(const Events::PlayerHealthPickup& e)
{
//save the changed HP to a vector. it will be taken care of in UpdateComponent
m_DeltaHealthVector.push_back(std::make_tuple(e.PlayerHealedID, e.HealthAmount));
return true;
}
src/Game/PlayerSystem.cpp
+31 -46
View File
@@ -2,56 +2,41 @@
void PlayerSystem::UpdateComponent(World * world, ComponentWrapper & player, double dt)
{
if (input.Forward) {
m_Direction.z = -1;
} else if (input.Back) {
m_Direction.z = 1;
} else {
m_Direction.z = 0;
player["Velocity"] = glm::vec3(0.f, 0.f, 0.f);
if ((bool&)player["Forward"] == true) {
((glm::vec3&)player["Velocity"]).z = m_Speed * float(dt) * -1;
}
if (input.Left) {
m_Direction.x = -1;
} else if (input.Right) {
m_Direction.x = 1;
} else {
m_Direction.x = 0;
if ((bool&)player["Left"] == true) {
((glm::vec3&)player["Velocity"]).x = m_Speed * float(dt) * -1;
}
if ((bool&)player["Back"] == true) {
((glm::vec3&)player["Velocity"]).z = m_Speed * float(dt);
}
if ((bool&)player["Right"] == true) {
((glm::vec3&)player["Velocity"]).x = m_Speed * float(dt);
}
if ((glm::vec3)player["Velocity"] != glm::vec3(0.f)) {
ComponentWrapper& transform = world->GetComponent(player.EntityID, "Transform");
(glm::vec3&)transform["Position"] += (glm::vec3)player["Velocity"];
}
m_EventBroker->Process<PlayerSystem>();
ComponentWrapper& transform = world->GetComponent(player.EntityID, "Transform");
(glm::vec3&)player["Velocity"] = m_Speed * float(dt) * m_Direction;
(glm::vec3&)transform["Position"] += (glm::vec3)player["Velocity"];
}
bool PlayerSystem::OnKeyDown(const Events::KeyDown & event)
bool PlayerSystem::OnTouch(const Events::TriggerTouch &event)
{
if (event.KeyCode == GLFW_KEY_W) {
input.Forward = true;
}
if (event.KeyCode == GLFW_KEY_A) {
input.Left = true;
}
if (event.KeyCode == GLFW_KEY_S) {
input.Back = true;
}
if (event.KeyCode == GLFW_KEY_D) {
input.Right = true;
}
return true;
}
bool PlayerSystem::OnKeyUp(const Events::KeyUp & event)
{
if (event.KeyCode == GLFW_KEY_W) {
input.Forward = false;
}
if (event.KeyCode == GLFW_KEY_A) {
input.Left = false;
}
if (event.KeyCode == GLFW_KEY_S) {
input.Back = false;
}
if (event.KeyCode == GLFW_KEY_D) {
input.Right = false;
}
LOG_INFO("Player entity %i touched widget (entity %i).", event.Entity, event.Trigger);
return false;
}
bool PlayerSystem::OnEnter(const Events::TriggerEnter &event)
{
LOG_INFO("Player entity %i entered widget (entity %i).", event.Entity, event.Trigger);
return false;
}
bool PlayerSystem::OnLeave(const Events::TriggerLeave &event)
{
LOG_INFO("Player entity %i left widget (entity %i).", event.Entity, event.Trigger);
return false;
}