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

# Conflicts:
#	src/Game/Game.cpp

src/Game/Game.cpp

@@ -14,6 +14,7 @@
 #include "Game/Systems/CapturePointSystem.h"
 #include "Game/Systems/CapturePointHUDSystem.h"
 #include "Game/Systems/PickupSpawnSystem.h"
+#include "Game/Systems/AmmoPickupSystem.h"
 #include "Game/Systems/DamageIndicatorSystem.h"
 #include "Game/Systems/Weapon/WeaponSystem.h"
 #include "Rendering/AnimationSystem.h"
@@ -44,6 +45,7 @@ Game::Game(int argc, char* argv[])
     ResourceManager::UseThreading = m_Config->Get<bool>("Multithreading.ResourceLoading", true);
     DisableMemoryPool::Value = m_Config->Get<bool>("Debug.DisableMemoryPool", false);
     LOG_LEVEL = static_cast<_LOG_LEVEL>(m_Config->Get<int>("Debug.LogLevel", 1));
+    PlayerSpawnSystem::SetRespawnTime(m_Config->Get<float>("Debug.RespawnTime", 15.0f));
 
     // Create the core event broker
     m_EventBroker = new EventBroker();
@@ -120,12 +122,12 @@ Game::Game(int argc, char* argv[])
     m_SystemPipeline->AddSystem<PlayerMovementSystem>(updateOrderLevel);
     m_SystemPipeline->AddSystem<SpawnerSystem>(updateOrderLevel);
     m_SystemPipeline->AddSystem<PlayerSpawnSystem>(updateOrderLevel);
-    m_SystemPipeline->AddSystem<PlayerDeathSystem>(updateOrderLevel);
     m_SystemPipeline->AddSystem<WeaponSystem>(updateOrderLevel, m_Renderer, m_OctreeCollision);
     m_SystemPipeline->AddSystem<LifetimeSystem>(updateOrderLevel);
     m_SystemPipeline->AddSystem<CapturePointSystem>(updateOrderLevel);
     m_SystemPipeline->AddSystem<CapturePointHUDSystem>(updateOrderLevel);
     m_SystemPipeline->AddSystem<PickupSpawnSystem>(updateOrderLevel);
+    m_SystemPipeline->AddSystem<AmmoPickupSystem>(updateOrderLevel);
     m_SystemPipeline->AddSystem<DamageIndicatorSystem>(updateOrderLevel);
     m_SystemPipeline->AddSystem<AmmunitionHUDSystem>(updateOrderLevel);
     // Populate Octree with collidables
@@ -136,6 +138,7 @@ Game::Game(int argc, char* argv[])
     m_SystemPipeline->AddSystem<AnimationSystem>(updateOrderLevel);
     m_SystemPipeline->AddSystem<UniformScaleSystem>(updateOrderLevel);
     m_SystemPipeline->AddSystem<HealthHUDSystem>(updateOrderLevel);
+    m_SystemPipeline->AddSystem<PlayerDeathSystem>(updateOrderLevel);
     // Collision and TriggerSystem should update after player.
     ++updateOrderLevel;
     m_SystemPipeline->AddSystem<BoneAttachmentSystem>(updateOrderLevel);

src/Game/Systems/AmmoPickupSystem.cpp

@@ -0,0 +1,78 @@
+#include "Systems/AmmoPickupSystem.h"
+
+AmmoPickupSystem::AmmoPickupSystem(SystemParams params)
+    : System(params)
+{
+    EVENT_SUBSCRIBE_MEMBER(m_ETriggerTouch, &AmmoPickupSystem::OnTriggerTouch);
+}
+
+void AmmoPickupSystem::Update(double dt)
+{
+    for (auto it = m_ETriggerTouchVector.begin(); it != m_ETriggerTouchVector.end(); ++it)
+    {
+        auto& ammoPickupPosition = *it;
+        //set the double timer value (value 3)
+        ammoPickupPosition.DecreaseThisRespawnTimer -= dt;
+        if (ammoPickupPosition.DecreaseThisRespawnTimer < 0.0) {
+            //spawn and delete the vector item
+            auto entityFile = ResourceManager::Load<EntityFile>("Schema/Entities/AmmoPickup.xml");
+            EntityFileParser parser(entityFile);
+            EntityID ammoPickupID = parser.MergeEntities(m_World);
+
+            //let the world know a pickup has spawned (graphics effects, etc)
+            Events::PickupSpawned ePickupSpawned;
+            ePickupSpawned.Pickup = EntityWrapper(m_World, ammoPickupID);
+            m_EventBroker->Publish(ePickupSpawned);
+
+            //set values from the old entity to the new entity
+            auto& newAmmoPickupEntity = EntityWrapper(m_World, ammoPickupID);
+            newAmmoPickupEntity["Transform"]["Position"] = ammoPickupPosition.Pos;
+            newAmmoPickupEntity["AmmoPickup"]["AmmoGain"] = ammoPickupPosition.AmmoGain;
+            newAmmoPickupEntity["AmmoPickup"]["RespawnTimer"] = ammoPickupPosition.RespawnTimer;
+
+            //erase the current element (AmmoPickupPosition)
+            m_ETriggerTouchVector.erase(it);
+            break;
+        }
+    }
+}
+
+
+bool AmmoPickupSystem::OnTriggerTouch(Events::TriggerTouch& e)
+{
+    if (e.Entity != LocalPlayer) {
+        return false;
+    }
+    //TODO: add other weapontypes
+    if (!e.Entity.HasComponent("AssaultWeapon")) {
+        return false;
+    }
+    if (!e.Trigger.HasComponent("AmmoPickup")) {
+        return false;
+    }
+    int maxWeaponAmmo = (int)e.Entity["AssaultWeapon"]["MaxAmmo"];
+    int& currentAmmo = (int)e.Entity["AssaultWeapon"]["Ammo"];
+
+    int ammoGiven = 0.01*(double)e.Trigger["AmmoPickup"]["AmmoGain"] * maxWeaponAmmo;
+    //cant pick up ammopacks if you are already at MaxAmmo
+    if (currentAmmo >= maxWeaponAmmo) {
+        return false;
+    }
+
+    //personEntered = e.Entity, thingEntered = e.Trigger
+    Events::AmmoPickup ePlayerAmmoPickup;
+    ePlayerAmmoPickup.AmmoGain = ammoGiven;
+    ePlayerAmmoPickup.Player = e.Entity;
+    m_EventBroker->Publish(ePlayerAmmoPickup);
+    //immediately give the player the ammo
+    currentAmmo = std::min(currentAmmo + ammoGiven, maxWeaponAmmo);
+
+    //copy position, ammogain, respawntimer (twice since one of the values will be counted down to 0, the other will be set in the new object)
+    //we need to copy all values since each value can be different for each ammoPickup
+    m_ETriggerTouchVector.push_back({ (glm::vec3)e.Trigger["Transform"]["Position"] ,e.Trigger["AmmoPickup"]["AmmoGain"],
+        e.Trigger["AmmoPickup"]["RespawnTimer"],e.Trigger["AmmoPickup"]["RespawnTimer"] });
+
+    //delete the ammopickup
+    m_World->DeleteEntity(e.Trigger.ID);
+    return true;
+}

src/Game/Systems/DamageIndicatorSystem.cpp

@@ -22,6 +22,10 @@ bool DamageIndicatorSystem::OnPlayerDamage(Events::PlayerDamage& e)
         return false;
     }
 
+    if (!e.Inflictor.Valid() || !e.Victim.Valid()) {
+        return false;
+    }
+
     //grab players direction
     auto playerOrientation = glm::quat((glm::vec3)e.Victim["Transform"]["Orientation"]);
 

src/Game/Systems/HealthSystem.cpp

@@ -7,6 +7,7 @@ HealthSystem::HealthSystem(SystemParams params)
     //subscribe/listenTo playerdamage,healthpickup events (using the eventBroker)
     EVENT_SUBSCRIBE_MEMBER(m_EPlayerDamage, &HealthSystem::OnPlayerDamaged);
     EVENT_SUBSCRIBE_MEMBER(m_EPlayerHealthPickup, &HealthSystem::OnPlayerHealthPickup);
+    EVENT_SUBSCRIBE_MEMBER(m_InputCommand, &HealthSystem::OnInputCommand);
 }
 
 void HealthSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& component, double dt)
@@ -29,6 +30,17 @@ bool HealthSystem::OnPlayerDamaged(Events::PlayerDamage& e)
     return true;
 }
 
+bool HealthSystem::OnInputCommand(Events::InputCommand& e)
+{
+    if (e.Command == "TakeDamage" && e.Value > 0 && LocalPlayer.Valid()) {
+        Events::PlayerDamage ev;
+        ev.Victim = LocalPlayer;
+        ev.Damage = e.Value;
+        m_EventBroker->Publish(ev);
+    }
+    return true;
+}
+
 bool HealthSystem::OnPlayerHealthPickup(Events::PlayerHealthPickup& e)
 {
     ComponentWrapper cHealth = e.Player["Health"];

src/Game/Systems/PlayerDeathSystem.cpp

@@ -34,8 +34,15 @@ void PlayerDeathSystem::createDeathEffect(EntityWrapper player)
 
     //components that we need from player
     auto playerCamera = player.FirstChildByName("Camera");
-    auto playerEntityModel = player.FirstChildByName("PlayerModel")["Model"];
-    auto playerEntityAnimation = player.FirstChildByName("PlayerModel")["Animation"];
+    auto playerModel = player.FirstChildByName("PlayerModel");
+    if (!playerCamera.Valid() || !playerModel.Valid()) {
+        return;
+    }
+    if (!playerModel.HasComponent("Model") || !playerModel.HasComponent("Animation")) {
+        return;
+    }
+    auto playerEntityModel = playerModel["Model"];
+    auto playerEntityAnimation = playerModel["Animation"];
 
     //copy the data from player to explisioneffectmodel
     playerEntityModel.Copy(deathEffectEW["Model"]);

src/Game/Systems/PlayerSpawnSystem.cpp

@@ -1,20 +1,39 @@
 #include "Systems/PlayerSpawnSystem.h"
 
+//This should be set by the config anyway.
+float PlayerSpawnSystem::m_RespawnTime = 15.0f;
+
 PlayerSpawnSystem::PlayerSpawnSystem(SystemParams params) 
     : System(params)
+    , m_Timer(0.f)
 {
     EVENT_SUBSCRIBE_MEMBER(m_OnInputCommand, &PlayerSpawnSystem::OnInputCommand);
     EVENT_SUBSCRIBE_MEMBER(m_OnPlayerSpawnerd, &PlayerSpawnSystem::OnPlayerSpawned);
+    EVENT_SUBSCRIBE_MEMBER(m_OnPlayerDeath, &PlayerSpawnSystem::OnPlayerDeath);
     m_NetworkEnabled = ResourceManager::Load<ConfigFile>("Config.ini")->Get("Networking.StartNetwork", false);
 }
 
 void PlayerSpawnSystem::Update(double dt)
 {
+    //Increase timer.
+    m_Timer += dt;
+    if (m_Timer < m_RespawnTime) {
+        return;
+    }
+    //If respawn time has passed, we spawn all players that have requested to be spawned.
+    m_Timer = 0.f;
+
+    //If there are no spawn requests, return immediately, if we are client the SpawnRequests should always be empty.
+    if (m_SpawnRequests.size() == 0) {
+        return;
+    }
+
     auto playerSpawns = m_World->GetComponents("PlayerSpawn");
     if (playerSpawns == nullptr) {
         return;
     }
 
+    int numSpawnedPlayers = 0;
     for (auto& req : m_SpawnRequests) {
         for (auto& cPlayerSpawn : *playerSpawns) {
             EntityWrapper spawner(m_World, cPlayerSpawn.EntityID);
@@ -40,29 +59,61 @@ void PlayerSpawnSystem::Update(double dt)
             e.Player = player;
             e.Spawner = spawner;
             m_EventBroker->Publish(e);
-
+            ++numSpawnedPlayers;
+            break;
         }
     }
+    if (numSpawnedPlayers != (int)m_SpawnRequests.size()) {
+        LOG_DEBUG("%i players were supposed to be spawned, but %i was spawned.", (int)m_SpawnRequests.size(), numSpawnedPlayers);
+    } else {
+        LOG_DEBUG("%i players were spawned.", numSpawnedPlayers);
+    }
     m_SpawnRequests.clear();
 }
 
-bool PlayerSpawnSystem::OnInputCommand(const Events::InputCommand& e)
+bool PlayerSpawnSystem::OnInputCommand(Events::InputCommand& e)
 {
     if (e.Command != "PickTeam") {
         return false;
     }
 
     // Team picks should be processed ONLY server-side!
-    // Don't make a spawn request if PlayerID is -1, i.e. we're the client.
-    if (e.PlayerID == -1 && m_NetworkEnabled) {
+    // Don't make a spawn request if we're the client.
+    if (!IsServer && m_NetworkEnabled) {
         return false;
     }
 
-    if (e.Value != 0) {
+    if (e.Value == 0) {
+        return false;
+    }
+
+    //TODO: Spectating?
+    //Right now, return if someone picks spectator.
+    //1 signifies spectator here, could not get Playerteam component since it may be invalid or without team comp.
+    if ((ComponentInfo::EnumType)e.Value == 1) {
+        return false;
+    }
+
+    //Check if the player already requested spawn.
+    auto iter = m_SpawnRequests.begin();
+    for (; iter != m_SpawnRequests.end(); ++iter) {
+        if (iter->PlayerID == e.PlayerID) {
+            break;
+        }
+    }
+
+    if (iter != m_SpawnRequests.end()) {
+        //If player is in queue to spawn, then change their team affiliation in the request.
+        iter->Team = (ComponentInfo::EnumType)e.Value;
+    } else if (m_PlayerEntities.count(e.PlayerID) == 0 || !m_PlayerEntities[e.PlayerID].Valid()) {
+        //If player is not in queue to spawn, then create a spawn request, 
+        //but only if they are spectating and/or just connected.
         SpawnRequest req;
         req.PlayerID = e.PlayerID;
         req.Team = (ComponentInfo::EnumType)e.Value;
         m_SpawnRequests.push_back(req);
+    } else {
+        return false;
     }
 
     return true;
@@ -70,21 +121,15 @@ bool PlayerSpawnSystem::OnInputCommand(const Events::InputCommand& e)
 
 bool PlayerSpawnSystem::OnPlayerSpawned(Events::PlayerSpawned& e)
 {
+    // Store the player for future reference
+    m_PlayerEntities[e.PlayerID] = e.Player;
+    m_PlayerIDs[e.Player.ID] = e.PlayerID;
+
     // When a player is actually spawned (since the actual spawning is handled on the server)
     if (!IsClient) {
         return false;
     }
 
-    // Check if a player already exists
-    if (m_PlayerEntities.count(e.PlayerID) != 0) {
-        // TODO: Disallow infinite respawning here
-        if (m_PlayerEntities[e.PlayerID].Valid()) {
-            m_World->DeleteEntity(m_PlayerEntities[e.PlayerID].ID);
-        }
-    }
-
-    // Store the player for future reference
-    m_PlayerEntities[e.PlayerID] = e.Player;
 
     // Set the camera to the correct entity
     EntityWrapper cameraEntity = e.Player.FirstChildByName("Camera");
@@ -114,4 +159,24 @@ bool PlayerSpawnSystem::OnPlayerSpawned(Events::PlayerSpawned& e)
     }
 
     return true;
-}
+}
+
+bool PlayerSpawnSystem::OnPlayerDeath(Events::PlayerDeath& e)
+{
+    //Only spawn request if network is disabled or we are server.
+    if (!IsServer && m_NetworkEnabled) {
+        return false;
+    }
+    if (!e.Player.HasComponent("Team")) {
+        return false;
+    }
+    ComponentWrapper cTeam = e.Player["Team"];
+    //A spectator can't die anyway
+    if ((ComponentInfo::EnumType)cTeam["Team"] == cTeam["Team"].Enum("Spectator")) {
+        return false;
+    }
+    SpawnRequest req;
+    req.PlayerID = m_PlayerIDs.at(e.Player.ID);
+    req.Team = cTeam["Team"];
+    m_SpawnRequests.push_back(req);
+}

src/Game/Systems/SoundSystem.cpp

@@ -52,12 +52,6 @@ bool SoundSystem::OnInputCommand(const Events::InputCommand & e)
             return true;
         }
     }
-    if (e.Command == "TakeDamage" && e.Value > 0) {
-        Events::PlayerDamage ev;
-        ev.Victim = LocalPlayer;
-        ev.Damage = 1.0;
-        m_EventBroker->Publish(ev);
-    }
 
     return false;
 }