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

# Conflicts:
#	include/Engine/Core/ComponentWrapper.h
#	include/Game/PlayerSystem.h
#	include/Game/Systems/HealthSystem.h
#	resources/Schema/Components.xsd
#	resources/Schema/Components/Player.xml
#	resources/Schema/Types/Entity.xsd
#	src/Game/CMakeLists.txt
#	src/Game/PlayerSystem.cpp
#	src/Game/Systems/HealthSystem.cpp
#	src/Tests/OctTreeTestGameClass.cpp
#	src/Tests/OctTreeTestGameClass.h
#	src/Tests/OctTreeTestGameMain.cpp
#	src/Tests/OctTreeTestHardCodedTestWorld.h

src/Game/Systems/HealthSystem.cpp

@@ -0,0 +1,60 @@
+#include "Systems/HealthSystem.h"
+
+HealthSystem::HealthSystem(EventBroker* eventBroker)
+    : System(eventBroker)
+    , PureSystem("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, EntityWrapper& entity, ComponentWrapper& component, 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(component.EntityID, "Player");
+    double maxHealth = (double)component["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)component["Health"] > 0.0f) {
+            //get the deltaHP value from the tuple and make sure you dont get more than maxHealth
+            double newHealth = std::min((double)component["Health"] + (double)std::get<1>(deltaHP), maxHealth);
+            component["Health"] = newHealth;
+            m_DeltaHealthVector.erase(m_DeltaHealthVector.begin() + i - 1);
+            //check if health is <= 0
+            if ((double)component["Health"] <= 0.0f) {
+                health["Health"] = 0.0;
+                //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/Systems/PlayerMovementSystem.cpp

@@ -0,0 +1,16 @@
+#include "Systems/PlayerMovementSystem.h"
+
+void PlayerMovementSystem::UpdateComponent(World* world, EntityWrapper& entity, ComponentWrapper& component, double dt)
+{
+    ComponentWrapper& cTransform = entity["Transform"];
+    if (!entity.HasComponent("Physics")) {
+        return;
+    }
+    ComponentWrapper& cPhysics = entity["Physics"];
+
+    glm::vec3& velocity = cPhysics["Velocity"];
+    velocity.y -= 9.82 * dt;
+
+    glm::vec3& position = cTransform["Position"];
+    position += velocity * (float)dt;
+}

src/Game/Systems/PlayerSpawnSystem.cpp

@@ -0,0 +1,51 @@
+#include "Systems/PlayerSpawnSystem.h"
+
+PlayerSpawnSystem::PlayerSpawnSystem(EventBroker* eventBroker) 
+    : System(eventBroker)
+{
+    EVENT_SUBSCRIBE_MEMBER(m_OnInputCommand, &PlayerSpawnSystem::OnInputCommand);
+}
+
+void PlayerSpawnSystem::Update(World* world, double dt)
+{
+    auto playerSpawns = world->GetComponents("PlayerSpawn");
+    if (playerSpawns == nullptr) {
+        return;
+    }
+
+    for (auto& team : m_SpawnRequests) {
+        for (auto& cPlayerSpawn : *playerSpawns) {
+            EntityWrapper spawner(world, cPlayerSpawn.EntityID);
+            if (!spawner.HasComponent("Spawner")) {
+                continue;
+            }
+
+            // If the spawner has a team affiliation, check it
+            if (spawner.HasComponent("Team")) {
+                if ((int)spawner["Team"]["Team"] != team) {
+                    continue;
+                }
+            }
+
+            // Spawn the player!
+            EntityWrapper player = SpawnerSystem::Spawn(spawner);
+            // Set the player team affiliation
+            player["Team"]["Team"] = team;
+        }
+    }
+    m_SpawnRequests.clear();
+}
+
+bool PlayerSpawnSystem::OnInputCommand(const Events::InputCommand& e)
+{
+    if (e.Command != "PickTeam") {
+        return false;
+    }
+
+    if (e.Value != 0) {
+        m_SpawnRequests.push_back((int)e.Value);
+    }
+
+    return true;
+}
+

src/Game/Systems/SpawnerSystem.cpp

@@ -0,0 +1,61 @@
+#include "Systems/SpawnerSystem.h"
+
+SpawnerSystem::SpawnerSystem(EventBroker* eventBroker) : System(eventBroker)
+{
+    EVENT_SUBSCRIBE_MEMBER(m_OnSpawnerSpawn, &SpawnerSystem::OnSpawnerSpawn);
+}
+
+EntityWrapper SpawnerSystem::Spawn(EntityWrapper spawner, EntityWrapper parent /*= EntityWrapper::Invalid*/)
+{
+    // Spawn the entity in the parent's world if it exists, otherwise in the spawner's world
+    World* world = parent.World;
+    if (world == nullptr) {
+        world = spawner.World;
+    } 
+
+    // Find any SpawnPoints existing as children of spawner
+    auto children = spawner.World->GetChildren(spawner.ID);
+    std::vector<EntityWrapper> spawnPoints;
+    for (auto kv = children.first; kv != children.second; ++kv) {
+        const EntityID& child = kv->second;
+        if (spawner.World->HasComponent(child, "SpawnPoint")) {
+            spawnPoints.push_back(EntityWrapper(spawner.World, child));
+        }
+    }
+
+    // Choose a random SpawnPoint
+    EntityWrapper spawnPoint = spawner;
+    if (!spawnPoints.empty()) {
+        if (spawnPoints.size() > 1) {
+            static std::random_device randomDevice;
+            static std::mt19937 randomGenerator(randomDevice());
+            std::uniform_int_distribution<> distribution(0, std::distance(spawnPoints.begin(), spawnPoints.end()) - 1);
+            auto randomSpawnPointIt = spawnPoints.begin();
+            std::advance(randomSpawnPointIt, distribution(randomGenerator));
+            spawnPoint = *randomSpawnPointIt;
+        } else {
+            spawnPoint = spawnPoints.front();
+        }
+    }
+    
+    // Load the entity file and parse it
+    const std::string& entityFilePath = spawner["Spawner"]["EntityFile"];
+    auto entityFile = ResourceManager::Load<EntityFile>(entityFilePath);
+    if (entityFile == nullptr) {
+        return EntityWrapper::Invalid;
+    }
+    EntityFileParser parser(entityFile);
+    EntityWrapper spawnedEntity(world, parser.MergeEntities(world, parent.ID));
+
+    // Set its position and orientation to that of the SpawnPoint
+    spawnedEntity["Transform"]["Position"] = Transform::AbsolutePosition(spawnPoint.World, spawnPoint.ID);
+    spawnedEntity["Transform"]["Orientation"] = glm::eulerAngles(Transform::AbsoluteOrientation(spawnPoint.World, spawnPoint.ID));
+
+    return spawnedEntity;
+}
+
+bool SpawnerSystem::OnSpawnerSpawn(Events::SpawnerSpawn& e)
+{
+    EntityWrapper spawnedEntity = Spawn(e.Spawner, e.Parent);
+    return true;
+}