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

# Conflicts:
#	assets
#	resources/Schema/Entities/Player.xml
#	resources/Schema/Entities/PlayerAssaultFallbackBlue.xml
#	resources/Schema/Entities/PlayerAssaultFallbackRed.xml
#	resources/Schema/Entities/PlayerAssaultRed.xml
#	resources/Schema/Entities/aaaatestremoveme.xml
#	resources/Schema/Entities/aim_rays.xml

src/Game/Game.cpp

@@ -35,8 +35,10 @@
 #include "Game/Systems/BoostSystem.h"
 #include "Game/Systems/BoostIconsHUDSystem.h"
 #include "Game/Systems/ScoreScreenSystem.h"
+#include "Game/Systems/SpectatorCameraSystem.h"
 #include "GUI/ButtonSystem.h"
-#include "GUI/MainMenuSystem.h"
+#include "Game/Systems/MainMenuSystem.h"
+#include "Game/Systems/ServerListSystem.h"
 
 
 Game::Game(int argc, char* argv[])
@@ -137,25 +139,20 @@ Game::Game(int argc, char* argv[])
     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<TextFieldReader>(updateOrderLevel);
     m_SystemPipeline->AddSystem<AbilityCooldownHUDSystem>(updateOrderLevel);
     m_SystemPipeline->AddSystem<CapturePointArrowHUDSystem>(updateOrderLevel);
     m_SystemPipeline->AddSystem<KillFeedSystem>(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<TextFieldReader>(updateOrderLevel);
-    m_SystemPipeline->AddSystem<KillFeedSystem>(updateOrderLevel);
     m_SystemPipeline->AddSystem<BoostSystem>(updateOrderLevel);
     m_SystemPipeline->AddSystem<ButtonSystem>(updateOrderLevel, m_Renderer);
     m_SystemPipeline->AddSystem<MainMenuSystem>(updateOrderLevel, m_Renderer);
     m_SystemPipeline->AddSystem<BoostIconsHUDSystem>(updateOrderLevel);
     m_SystemPipeline->AddSystem<ScoreScreenSystem>(updateOrderLevel);
+    m_SystemPipeline->AddSystem<SpectatorCameraSystem>(updateOrderLevel);
+    m_SystemPipeline->AddSystem<ServerListSystem>(updateOrderLevel, m_Renderer);
     // Populate Octree with collidables
     ++updateOrderLevel;
     m_SystemPipeline->AddSystem<FillOctreeSystem>(updateOrderLevel, m_OctreeCollision, "Collidable");

src/Game/Systems/AbilityCooldownHUDSystem.cpp

@@ -11,23 +11,72 @@ void AbilityCooldownHUDSystem::Update(double dt)
     for (auto& abilityHUDC : *abilityHUDs) {
         EntityWrapper entity = EntityWrapper(m_World, abilityHUDC.EntityID);
         EntityWrapper abilityEntity = entity.FirstParentWithComponent("DashAbility");
-        if (!abilityEntity.Valid())
-            return;
-        EntityWrapper cooldownTextEntity = entity.FirstChildByName("Cooldown");
+        std::string abilityName = "";
 
-        double maxAbilityCD = (double)abilityEntity["DashAbility"]["CoolDownMaxTimer"];
-        double currentAbilityCD = (double)abilityEntity["DashAbility"]["CoolDownTimer"];
+        if (!abilityEntity.Valid()) {
+            //If we dont have a dash ability on player, we check for Sprint ability
+            abilityEntity = entity.FirstParentWithComponent("SprintAbility");
 
-        currentAbilityCD = currentAbilityCD >= 0.0 ? currentAbilityCD : 0.0;
+            if (!abilityEntity.Valid()) {
+                //If we dont have a sprint ability on player, we check for shield ability
+                abilityEntity = entity.FirstParentWithComponent("ShieldAbility");
 
-        if(cooldownTextEntity.Valid()) {
-            if(cooldownTextEntity.HasComponent("Text"))
-            {
-                std::string t = (std::string&)cooldownTextEntity["Text"]["Content"] = std::to_string(currentAbilityCD).substr(0, 3);
+                if (!abilityEntity.Valid()) {
+                    //If we dont have a shield ability, we return, since we cannot do anything.
+                    return;
+                } else {
+                    //If we have a shield ability, we set the right icon
+                    abilityName = "ShieldAbility";
+                    if (entity.HasComponent("Sprite")) {
+                        (std::string&)entity["Sprite"]["DiffuseTexture"] = "Textures\\Icons\\Abilities\\SheildDots-01.png";
+                    }
+                }
+            } else {
+                //If we do have a sprint ability, we change the icon
+                abilityName = "SprintAbility";
+                if (entity.HasComponent("Sprite")) {
+                    (std::string&)entity["Sprite"]["DiffuseTexture"] = "Textures\\Icons\\Abilities\\Dash-01.png";
+                }
+            }
+        } else {
+            //If we have a dash ability, we set the icon to the correct one.
+            abilityName = "DashAbility";
+            if (entity.HasComponent("Sprite")) {
+                (std::string&)entity["Sprite"]["DiffuseTexture"] = "Textures\\Icons\\Abilities\\Superman-01.png";
             }
         }
+
+        EntityWrapper cooldownTextEntity = entity.FirstChildByName("Cooldown");
+        //TODO: Fix so this track correctly for shield and sprint depending on how they work.
+        double maxAbilityCD, currentAbilityCD;
+
+        if (abilityName == "DashAbility") {
+            maxAbilityCD = (double)abilityEntity[abilityName]["CoolDownMaxTimer"];
+            currentAbilityCD = (double)abilityEntity[abilityName]["CoolDownTimer"];
+            currentAbilityCD = currentAbilityCD >= 0.0 ? currentAbilityCD : 0.0;
+
+            if (cooldownTextEntity.Valid()) {
+                if (cooldownTextEntity.HasComponent("Text")) {
+                    std::string t = (std::string&)cooldownTextEntity["Text"]["Content"] = std::to_string(currentAbilityCD).substr(0, 3);
+                }
+            }
+        }
+
+        if (abilityName == "ShieldAbility") {
+            maxAbilityCD = 0.0;
+            currentAbilityCD = 1 - (bool)abilityEntity[abilityName]["Active"];
+        }
+
+        if (abilityName == "SprintAbility") {
+            maxAbilityCD = 0.0;
+            currentAbilityCD = 1 - (bool)abilityEntity[abilityName]["Active"];
+        }
+
         if (entity.HasComponent("Fill")) {
             entity["Fill"]["Percentage"] = currentAbilityCD/maxAbilityCD;
         }
+
+
+
     }
 }

src/Game/Systems/AmmoPickupSystem.cpp

@@ -37,8 +37,7 @@ void AmmoPickupSystem::Update(double dt)
 
                 //erase the current element (somePickup)
                 it = m_ETriggerTouchVector.erase(it);
-            }
-            else { 
+            } else {
                 it++;
             }
         }
@@ -48,7 +47,7 @@ void AmmoPickupSystem::Update(double dt)
                 m_PickupAtMaximum.erase(it);
                 break;
             }
-            if ((int)it->player["AssaultWeapon"]["Ammo"] < (int)it->player["AssaultWeapon"]["MaxAmmo"]) {
+            if (!DoesPlayerHaveMaxAmmo(it->player)) {
                 DoPickup(it->player, it->trigger);
                 m_PickupAtMaximum.erase(it);
                 break;
@@ -56,6 +55,58 @@ void AmmoPickupSystem::Update(double dt)
         }
     }
 }
+bool AmmoPickupSystem::DoesPlayerHaveMaxAmmo(EntityWrapper &player) {
+    PlayerClass playerClass = DetermineClass(player);
+    if (playerClass == PlayerClass::Defender) {
+        return !((int)player["DefenderWeapon"]["Ammo"] < (int)player["DefenderWeapon"]["MaxAmmo"]);
+    } else if (playerClass == PlayerClass::Sniper) {
+        return !((int)player["SniperWeapon"]["Ammo"] < (int)player["SniperWeapon"]["MaxAmmo"]);
+    } else if (playerClass == PlayerClass::Assault) {
+        return !((int)player["AssaultWeapon"]["Ammo"] < (int)player["AssaultWeapon"]["MaxAmmo"]);
+    } else {
+        return false;
+    }
+}
+void AmmoPickupSystem::SetPlayerAmmo(EntityWrapper &player, int ammoGain) {
+    int maxWeaponAmmo = GetPlayerMaxAmmo(player);
+
+    PlayerClass playerClass = DetermineClass(player);
+    if (playerClass == PlayerClass::Defender) {
+        (int&)player["DefenderWeapon"]["Ammo"] = std::min((int)player["DefenderWeapon"]["Ammo"] + ammoGain, maxWeaponAmmo);
+    } else if (playerClass == PlayerClass::Sniper) {
+        (int&)player["SniperWeapon"]["Ammo"] = std::min((int)player["SniperWeapon"]["Ammo"] + ammoGain, maxWeaponAmmo);
+    } else if (playerClass == PlayerClass::Assault) {
+        (int&)player["AssaultWeapon"]["Ammo"] = std::min((int)player["AssaultWeapon"]["Ammo"] + ammoGain, maxWeaponAmmo);
+    } else {
+        //unknown class - ignore
+    }
+}
+int AmmoPickupSystem::GetPlayerMaxAmmo(EntityWrapper &player) {
+    PlayerClass playerClass = DetermineClass(player);
+    if (playerClass == PlayerClass::Defender) {
+        return (int)player["DefenderWeapon"]["MaxAmmo"];
+    } else if (playerClass == PlayerClass::Sniper) {
+        return (int)player["SniperWeapon"]["MaxAmmo"];
+    } else if (playerClass == PlayerClass::Assault) {
+        return (int)player["AssaultWeapon"]["MaxAmmo"];
+    } else {
+        return -1;
+    }
+}
+AmmoPickupSystem::PlayerClass AmmoPickupSystem::DetermineClass(EntityWrapper &player)
+{
+    //determine the class based on what component the inflictor-player has
+    if (m_World->HasComponent(player.ID, "DashAbility")) {
+        return PlayerClass::Assault;
+    }
+    if (m_World->HasComponent(player.ID, "ShieldAbility")) {
+        return PlayerClass::Defender;
+    }
+    if (m_World->HasComponent(player.ID, "SprintAbility")) {
+        return PlayerClass::Sniper;
+    }
+    return PlayerClass::None;
+}
 
 bool AmmoPickupSystem::OnTriggerTouch(Events::TriggerTouch& e)
 {
@@ -63,7 +114,7 @@ bool AmmoPickupSystem::OnTriggerTouch(Events::TriggerTouch& e)
         return false;
     }
     //TODO: add other weapontypes
-    if (!e.Entity.HasComponent("AssaultWeapon")) {
+    if (DetermineClass(e.Entity) == PlayerClass::None) {
         return false;
     }
     if (!e.Trigger.HasComponent("AmmoPickup")) {
@@ -71,7 +122,7 @@ bool AmmoPickupSystem::OnTriggerTouch(Events::TriggerTouch& e)
     }
 
     //if at maxammo, save the trigger-touch to a vector since standing inside it will not re-trigger the trigger
-    if ((int)e.Entity["AssaultWeapon"]["Ammo"] >= (int)e.Entity["AssaultWeapon"]["MaxAmmo"]) {
+    if (DoesPlayerHaveMaxAmmo(e.Entity)) {
         m_PickupAtMaximum.push_back({ e.Entity, e.Trigger });
         return false;
     }
@@ -85,18 +136,16 @@ bool AmmoPickupSystem::OnAmmoPickup(Events::AmmoPickup & e)
         return false;
     }
     //TODO: add other weapontypes
-    if (!e.Player.HasComponent("AssaultWeapon")) {
+    if (DetermineClass(e.Player) == PlayerClass::None) {
         return false;
     }
-    int maxWeaponAmmo = (int)e.Player["AssaultWeapon"]["MaxAmmo"];
-    int& currentAmmo = (int)e.Player["AssaultWeapon"]["Ammo"];
     //cant pick up ammopacks if you are already at MaxAmmo
-    if (currentAmmo >= maxWeaponAmmo) {
+    if (DoesPlayerHaveMaxAmmo(e.Player)) {
         return false;
     }
+    SetPlayerAmmo(e.Player, e.AmmoGain);
 
-    currentAmmo = std::min(currentAmmo + e.AmmoGain, maxWeaponAmmo);
-    return false;
+    return true;
 }
 
 bool AmmoPickupSystem::OnTriggerLeave(Events::TriggerLeave& e) {
@@ -114,8 +163,11 @@ bool AmmoPickupSystem::OnTriggerLeave(Events::TriggerLeave& e) {
 }
 
 void AmmoPickupSystem::DoPickup(EntityWrapper &player, EntityWrapper &trigger) {
-    int maxWeaponAmmo = (int)player["AssaultWeapon"]["MaxAmmo"];
-    int& currentAmmo = (int)player["AssaultWeapon"]["Ammo"];
+    //trigger should be valid but if it isnt we just return (to avoid crash)
+    if (!trigger.Valid()) {
+        return;
+    }
+    int maxWeaponAmmo = GetPlayerMaxAmmo(player);
     int ammoGiven = 0.01*(double)trigger["AmmoPickup"]["AmmoGain"] * maxWeaponAmmo;
 
     Events::AmmoPickup ePlayerAmmoPickup;
@@ -123,9 +175,6 @@ void AmmoPickupSystem::DoPickup(EntityWrapper &player, EntityWrapper &trigger) {
     ePlayerAmmoPickup.Player = player;
     m_EventBroker->Publish(ePlayerAmmoPickup);
 
-    //immediately give the player the ammo (on server)
-    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)trigger["Transform"]["Position"], trigger["AmmoPickup"]["AmmoGain"],

src/Game/Systems/CapturePointSystem.cpp

@@ -69,6 +69,7 @@ void CapturePointSystem::UpdateComponent(EntityWrapper& capturePointEntity, Comp
     int ownedBy = teamComponent["Team"];
     int redTeamPlayersStandingInside = 0;
     int blueTeamPlayersStandingInside = 0;
+    //note: old color system
     if (capturePointEntity.HasComponent("Model")) {
         //Now sets team color to the capturepoint, or white if it is uncaptured.
         capturePointEntity["Model"]["Color"] = ownedBy == blueTeam ? glm::vec4(0, 0.0f, 1, 0.3) : ownedBy == redTeam ? glm::vec4(1, 0.0f, 0, 0.3) : glm::vec4(1, 1, 1, 0.3);
@@ -102,7 +103,18 @@ void CapturePointSystem::UpdateComponent(EntityWrapper& capturePointEntity, Comp
             nextPossibleCapturePoint["Blue"] = i - 1;
         }
     }
+
     if (m_RecentlyCapturedNeedNextCapturePointNow) {
+        //change what model is displaying (change all in case 2 capturepoints has been captured on the same frame)
+        for (int i = 0; i < m_NumberOfCapturePoints; i++) {
+            auto owner = (int)m_CapturePointNumberToEntityMap[i]["Team"]["Team"];
+            if (m_CapturePointNumberToEntityMap[i].FirstChildByName("Red").ID != EntityID_Invalid) {
+                (bool&)m_CapturePointNumberToEntityMap[i].FirstChildByName("Red")["Model"]["Visible"] = owner == redTeam ? true : false;
+                (bool&)m_CapturePointNumberToEntityMap[i].FirstChildByName("Blue")["Model"]["Visible"] = owner == blueTeam ? true : false;
+                (bool&)m_CapturePointNumberToEntityMap[i].FirstChildByName("Spectator")["Model"]["Visible"] = owner == spectatorTeam ? true : false;
+            }
+        }
+        //save the next cap points and publish the captured event
         m_CapturedEvent.BlueTeamNextCapturePoint = m_CapturePointNumberToEntityMap[nextPossibleCapturePoint["Blue"]];
         m_CapturedEvent.RedTeamNextCapturePoint = m_CapturePointNumberToEntityMap[nextPossibleCapturePoint["Red"]];
         m_EventBroker->Publish(m_CapturedEvent);

src/Game/Systems/DamageIndicatorSystem.cpp

@@ -10,10 +10,11 @@ DamageIndicatorSystem::DamageIndicatorSystem(SystemParams params)
     //load texture to cache
     auto texture = CommonFunctions::LoadTexture("Textures/DamageIndicator.png", false);
     auto entityFile = ResourceManager::Load<EntityXMLFile>("Schema/Entities/DamageIndicator.xml");
+    m_NetworkEnabled = ResourceManager::Load<ConfigFile>("Config.ini")->Get("Networking.StartNetwork", false);
 }
 
 void DamageIndicatorSystem::Update(double dt) {
-    if (!IsServer && LocalPlayer.Valid()) {
+    if ((!IsServer || !m_NetworkEnabled) && LocalPlayer.Valid()) {
         for (auto& iter = updateDamageIndicatorVector.begin(); iter != updateDamageIndicatorVector.end(); iter++) {
             if (!iter->spriteEntity.Valid()) {
                 updateDamageIndicatorVector.erase(iter);
@@ -40,10 +41,15 @@ bool DamageIndicatorSystem::OnPlayerDamage(Events::PlayerDamage& e)
         return false;
     }
 
+    //friendly fire - return
+    if (e.Damage < 0.1f) {
+        return false;
+    }
+
     glm::vec3 inflictorPos = e.Inflictor["Transform"]["Position"];
     //if testing
 #ifdef INDICATOR_TEST
-        inflictorPos = DamageIndicatorTest(e.Victim);
+    inflictorPos = DamageIndicatorTest(e.Victim);
 #endif
 
     float angleBetweenVectors = CalculateAngle(e.Victim, inflictorPos);
@@ -55,7 +61,7 @@ bool DamageIndicatorSystem::OnPlayerDamage(Events::PlayerDamage& e)
     //simply set the rotation z-wise to the angleBetweenVectors
     sprite["Transform"]["Orientation"] = glm::vec3(0, 0, angleBetweenVectors);
 
-    if (!IsServer) {
+    if (!IsServer || !m_NetworkEnabled) {
         updateDamageIndicatorVector.emplace_back(sprite, inflictorPos);
     }
 
@@ -122,7 +128,7 @@ glm::vec3 DamageIndicatorSystem::DamageIndicatorTest(EntityWrapper player) {
     }
     m_TestVar++;
 
-     auto inflictorPos = glm::vec3(currentPos.x + testVar*6.0f, currentPos.y, currentPos.z + testVar2*6.0f);
+    auto inflictorPos = glm::vec3(currentPos.x + testVar*6.0f, currentPos.y, currentPos.z + testVar2*6.0f);
 
     //load the explosioneffect XML
     auto deathEffect = ResourceManager::Load<EntityXMLFile>("Schema/Entities/PlayerDeathExplosionWithCamera.xml");

src/Game/Systems/MainMenuSystem.cpp

@@ -0,0 +1,94 @@
+#include "../Game/Systems/MainMenuSystem.h"
+
+MainMenuSystem::MainMenuSystem(SystemParams params, IRenderer* renderer)
+    : System(params)
+    , ImpureSystem()
+    , m_Renderer(renderer)
+{
+    EVENT_SUBSCRIBE_MEMBER(m_EPressed, &MainMenuSystem::OnButtonPress);
+    EVENT_SUBSCRIBE_MEMBER(m_EReleased, &MainMenuSystem::OnButtonRelease);
+    EVENT_SUBSCRIBE_MEMBER(m_EClicked, &MainMenuSystem::OnButtonClick);
+    EVENT_SUBSCRIBE_MEMBER(m_EInputCommand, &MainMenuSystem::OnInputCommand);
+}
+
+void MainMenuSystem::Update(double dt)
+{
+
+}
+
+bool MainMenuSystem::OnButtonClick(const Events::ButtonClicked& e)
+{
+    if (e.EntityName == "ServerIdentityConnect") {
+        EntityWrapper entity = e.Entity;
+        EntityWrapper serverIdentityEntity = entity.FirstParentWithComponent("ServerIdentity");
+        if(serverIdentityEntity.Valid()) {
+            Events::ConnectRequest event;
+            event.IP = (std::string)entity["ServerIdentity"]["IP"];
+            event.Port = (int)entity["ServerIdentity"]["Port"];
+            printf("\n ----Request Server Connect----\nIP: %s\nPort: %i\n ------------------------------", event.IP, event.Port);
+            m_EventBroker->Publish(event);
+        }
+    }
+    return true;
+}
+
+bool MainMenuSystem::OnButtonRelease(const Events::ButtonReleased& e)
+{
+    return true;
+}
+
+bool MainMenuSystem::OnButtonPress(const Events::ButtonPressed& e)
+{
+    return true;
+}
+
+bool MainMenuSystem::OnInputCommand(const Events::InputCommand& e)
+{
+    if(e.Command == "Play" && e.Value == 1) {
+        auto menus = m_World->GetComponents("Menu");
+        if (menus == nullptr) {
+            return 0;
+        }
+
+        if (m_OpenSubMenu == EntityWrapper::Invalid) {
+            //No submenu is open, open one.
+            for (auto& menu : *menus) {
+                EntityWrapper menuEntity = EntityWrapper(m_World, menu.EntityID);
+                auto serverListSpawner = menuEntity.FirstChildByName(e.Command + "Spawner");
+                if (!serverListSpawner.HasComponent("Spawner")) {
+                    return 0;
+                }
+                m_OpenSubMenu = SpawnerSystem::Spawn(serverListSpawner, serverListSpawner);
+                Events::SearchForServers event;
+                m_EventBroker->Publish(event);
+                break;
+            }
+
+        } else if(!m_OpenSubMenu.HasComponent("ServerList")) {
+            //Menu is open, but not the right one, delete the old one and open a new one.
+            m_World->DeleteEntity(m_OpenSubMenu.ID);
+            m_OpenSubMenu = EntityWrapper::Invalid;
+
+            for (auto& menu : *menus) {
+                EntityWrapper menuEntity = EntityWrapper(m_World, menu.EntityID);
+                auto serverListSpawner = menuEntity.FirstChildByName(e.Command + "Spawner");
+                if (!serverListSpawner.HasComponent("Spawner")) {
+                    return 0;
+                }
+                m_OpenSubMenu = SpawnerSystem::Spawn(serverListSpawner, serverListSpawner);
+                Events::SearchForServers event;
+                m_EventBroker->Publish(event);
+                break;
+            }
+        } else {
+            //Serverlist submenu is open, close it.
+            printf("\n\nMenuShit\n\n");
+            m_World->DeleteEntity(m_OpenSubMenu.ID);
+            m_OpenSubMenu = EntityWrapper::Invalid;
+        }
+    } else if (e.Command == "RefreshServerList" && e.Value == 1){
+        Events::SearchForServers event;
+        m_EventBroker->Publish(event);
+    }
+    return true;
+}

src/Game/Systems/PickupSpawnSystem.cpp

@@ -83,6 +83,10 @@ bool PickupSpawnSystem::OnTriggerLeave(Events::TriggerLeave& e)
 }
 void PickupSpawnSystem::DoPickup(EntityWrapper &player, EntityWrapper &trigger)
 {
+    //trigger should be valid but if it isnt we just return (to avoid crash)
+    if (!trigger.Valid()) {
+        return;
+    }
     double healthGiven = 0.01*(double)trigger["HealthPickup"]["HealthGain"] * (double)player["Health"]["MaxHealth"];
 
     //only the server will increase the players hp and set it in the next delta

src/Game/Systems/PlayerDeathSystem.cpp

@@ -1,10 +1,12 @@
 #include "Systems/PlayerDeathSystem.h"
+#include "Core/ELockMouse.h"
 
 PlayerDeathSystem::PlayerDeathSystem(SystemParams params)
     : System(params)
 {
     EVENT_SUBSCRIBE_MEMBER(m_OnPlayerDeath, &PlayerDeathSystem::OnPlayerDeath);
     EVENT_SUBSCRIBE_MEMBER(m_EEntityDeleted, &PlayerDeathSystem::OnEntityDeleted);
+    EVENT_SUBSCRIBE_MEMBER(m_EInputCommand, &PlayerDeathSystem::OnInputCommand);
 }
 
 void PlayerDeathSystem::Update(double dt)
@@ -33,10 +35,10 @@ void PlayerDeathSystem::createDeathEffect(EntityWrapper player)
 
     //components that we need from player
     auto playerModel = player.FirstChildByName("PlayerModel");
-    if (!playerModel.Valid()) {
-        return;
-    }
     if (!playerModel.HasComponent("Model") || !playerModel.HasComponent("Animation")) {
+        if (player == LocalPlayer) {
+            setSpectatorCamera();
+        }
         return;
     }
     auto playerEntityModel = playerModel["Model"];
@@ -68,14 +70,35 @@ bool PlayerDeathSystem::OnEntityDeleted(Events::EntityDeleted& e)
     if (m_LocalPlayerDeathEffect.ID != e.DeletedEntity) {
         return false;
     }
-    
+
+    // If the player hasn't spawned already, activate the spectator camera.
+    if (!LocalPlayer.Valid()) {
+        setSpectatorCamera();
+    }
+    return true;
+}
+
+void PlayerDeathSystem::setSpectatorCamera()
+{
     // Look for the spectator camera entity in the level.
     EntityWrapper spectatorCam = m_World->GetFirstEntityByName("SpectatorCamera");
-    if (!spectatorCam.Valid() || !spectatorCam.HasComponent("Camera") || LocalPlayer.Valid()) {
-        return false;
+    if (!spectatorCam.HasComponent("Camera")) {
+        return;
     }
     Events::SetCamera eSetCamera;
     eSetCamera.CameraEntity = spectatorCam;
     m_EventBroker->Publish(eSetCamera);
-    return true;
+    Events::UnlockMouse unlock;
+    m_EventBroker->Publish(unlock);
 }
+
+bool PlayerDeathSystem::OnInputCommand(Events::InputCommand& e)
+{
+    if (e.Value == 0 ||  e.Command != "SwapToTeamPick" && e.Command != "SwapToClassPick") {
+        return false;
+    }
+
+    // Ensure that we don't set spectator camera if the player deliberately changes to class/team pick.
+    m_LocalPlayerDeathEffect = EntityWrapper::Invalid;
+    return true;
+}

src/Game/Systems/PlayerSpawnSystem.cpp

@@ -1,4 +1,5 @@
 #include "Systems/PlayerSpawnSystem.h"
+#include "Core/ELockMouse.h"
 
 PlayerSpawnSystem::PlayerSpawnSystem(SystemParams params)
     : System(params)
@@ -59,7 +60,15 @@ void PlayerSpawnSystem::Update(double dt)
     }
 
     int numSpawnedPlayers = 0;
-    for (auto& req : m_SpawnRequests) {
+    int playersSpectating = 0;
+    const int numRequestsToHandle = (int)m_SpawnRequests.size();
+    for (auto it = m_SpawnRequests.begin(); it != m_SpawnRequests.end(); ++it) {
+        // It is valid if they didn't pick class yet
+        // but don't spawn anything, goto next spawnrequest.
+        if (it->Class == PlayerClass::None) {
+            ++playersSpectating;
+            continue;
+        }
         for (auto& cPlayerSpawn : *playerSpawns) {
             EntityWrapper spawner(m_World, cPlayerSpawn.EntityID);
             if (!spawner.HasComponent("Spawner")) {
@@ -69,43 +78,49 @@ void PlayerSpawnSystem::Update(double dt)
             // If the spawner has a team affiliation, check it
             if (spawner.HasComponent("Team")) {
                 auto cSpawnerTeam = spawner["Team"];
-                if ((int)cSpawnerTeam["Team"] != req.Team) {
-                    // Increase num spawned players if someone picks spectator, since it is valid to pick spectator
-                    // but don't spawn anything, goto next spawnrequest.
-                    if (req.Team == (int)cSpawnerTeam["Team"].Enum("Spectator")) {
-                        ++numSpawnedPlayers;
+                if ((int)cSpawnerTeam["Team"] != it->Team) {
+                    // If they somehow has a valid class as spectator, don't spawn them.
+                    if (it->Team == cSpawnerTeam["Team"].Enum("Spectator")) {
+                        ++playersSpectating;
                         break;
                     }
                     continue;
                 }
             }
 
+            // TODO: Choose a different spawner depending on class picked?
+
             // Spawn the player!
             EntityWrapper player = SpawnerSystem::Spawn(spawner, EntityWrapper::Invalid, "Player");
             // Set the player team affiliation
-            player["Team"]["Team"] = req.Team;
+            player["Team"]["Team"] = it->Team;
 
             // Publish a PlayerSpawned event
             Events::PlayerSpawned e;
-            e.PlayerID = req.PlayerID;
+            e.PlayerID = it->PlayerID;
             e.Player = player;
             e.Spawner = spawner;
             m_EventBroker->Publish(e);
             ++numSpawnedPlayers;
+            it = m_SpawnRequests.erase(it);
+            break;
+        }
+        if (it == m_SpawnRequests.end()) {
             break;
         }
     }
-    if (numSpawnedPlayers != (int)m_SpawnRequests.size()) {
-        LOG_DEBUG("%i players were supposed to be spawned or set as spectator, but only %i was handled.", (int)m_SpawnRequests.size(), numSpawnedPlayers);
+    if (numSpawnedPlayers != numRequestsToHandle - playersSpectating) {
+        LOG_DEBUG("%i players were supposed to be spawned, but only %i was successfully.", numRequestsToHandle - playersSpectating, numSpawnedPlayers);
     } else {
-        LOG_DEBUG("%i players were spawned or set as spectator.", numSpawnedPlayers);
+        std::string dbg = numSpawnedPlayers != 0 ? std::to_string(numSpawnedPlayers) + " players were spawned. " : "";
+        dbg += playersSpectating != 0 ? std::to_string(playersSpectating) + " players are spectating/picking class. " : "";
+        LOG_DEBUG(dbg.c_str());
     }
-    m_SpawnRequests.clear();
 }
 
 bool PlayerSpawnSystem::OnInputCommand(Events::InputCommand& e)
 {
-    if (e.Command != "PickTeam" && e.Command != "SwapToClassPick") {
+    if (e.Command != "PickTeam" && e.Command != "PickClass" && e.Command != "SwapToTeamPick" && e.Command != "SwapToClassPick") {
         return false;
     }
 
@@ -113,19 +128,6 @@ bool PlayerSpawnSystem::OnInputCommand(Events::InputCommand& e)
         return false;
     }
 
-    // A dead client should be able to swap to the overwatch camera.
-    if (IsClient && !LocalPlayer.Valid()) {
-        // Set the camera as active, if it exists.
-        // Find the respawn camera or class pick camera.
-        std::string camName = e.Command == "SwapToClassPick" ? "PickClassCamera" : "SpectatorCamera";
-        EntityWrapper spectatorCam = m_World->GetFirstEntityByName(camName);
-        if (spectatorCam.Valid() && spectatorCam.HasComponent("Camera")) {
-            Events::SetCamera eSetCamera;
-            eSetCamera.CameraEntity = spectatorCam;
-            m_EventBroker->Publish(eSetCamera);
-        }
-    }
-
     // Team picks should be processed ONLY server-side!
     // Don't make a spawn request if we're the client.
     if (!IsServer && m_NetworkEnabled) {
@@ -136,27 +138,38 @@ bool PlayerSpawnSystem::OnInputCommand(Events::InputCommand& e)
     auto iter = m_SpawnRequests.begin();
     for (; iter != m_SpawnRequests.end(); ++iter) {
         if (iter->PlayerID == e.PlayerID) {
-            // If player wants to switch class, remove their spawn request.
-            if (e.Command == "SwapToClassPick") {
-                m_SpawnRequests.erase(iter);
+            // If player wants to switch team or class , remove their selected class so they don't spawn.
+            if (e.Command == "SwapToTeamPick" || e.Command == "SwapToClassPick") {
+                iter->Class = PlayerClass::None;
+                return true;
             }
             break;
         }
     }
 
-    if (e.Command == "SwapToClassPick") {
-        return true;
-    }
+    //If we get here we got a PickTeam or PickClass, so add or alter a spawn request.
 
     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;
+        // If player is in queue to spawn, then change their team affiliation or class in the request.
+        if (e.Command == "PickTeam") {
+            iter->Team = (ComponentInfo::EnumType)e.Value;
+        } else {
+            iter->Class = static_cast<PlayerClass>((int)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;
+        if (e.Command == "PickTeam") {
+            req.Team = (ComponentInfo::EnumType)e.Value;
+            req.Class = PlayerClass::None;
+        } else {
+            // Should never get here, since you should have picked a team before you ever get a chance to pick class.
+            LOG_WARNING("Sequence error: Should not be able to pick class before team");
+            req.Team = 1;           // TODO: 1 Signifies spectator, should probably have real enum here later.
+            req.Class = static_cast<PlayerClass>((int)e.Value);
+        }
         m_SpawnRequests.push_back(req);
     } else {
         return false;
@@ -191,6 +204,8 @@ bool PlayerSpawnSystem::OnPlayerSpawned(Events::PlayerSpawned& e)
         Events::SetCamera e;
         e.CameraEntity = cameraEntity;
         m_EventBroker->Publish(e);
+        Events::LockMouse lock;
+        m_EventBroker->Publish(lock);
     }
 
     // HACK: Set the player model color to team color
@@ -210,7 +225,7 @@ bool PlayerSpawnSystem::OnPlayerSpawned(Events::PlayerSpawned& e)
 
 bool PlayerSpawnSystem::OnPlayerDeath(Events::PlayerDeath& e)
 {
-    //Only spawn request if network is disabled or we are server.
+    // Only spawn request if network is disabled or we are server.
     if (!IsServer && m_NetworkEnabled) {
         return false;
     }
@@ -218,10 +233,6 @@ bool PlayerSpawnSystem::OnPlayerDeath(Events::PlayerDeath& e)
         return false;
     }
     ComponentWrapper cTeam = e.Player["Team"];
-    //A spectator can't die anyway
-    if ((ComponentInfo::EnumType)cTeam["Team"] == cTeam["Team"].Enum("Spectator")) {
-        return false;
-    }
 
     if (m_PlayerIDs.count(e.Player.ID) == 0) {
         return false;
@@ -230,6 +241,16 @@ bool PlayerSpawnSystem::OnPlayerDeath(Events::PlayerDeath& e)
     SpawnRequest req;
     req.PlayerID = m_PlayerIDs.at(e.Player.ID);
     req.Team = cTeam["Team"];
+    // TODO: Something better than temp class state code, if we ever add class enums in .xml
+    if (e.Player.HasComponent("DashAbility")) {
+        req.Class = PlayerClass::Assault;
+    } else if (e.Player.HasComponent("SprintAbility")) {
+        req.Class = PlayerClass::Sniper;
+    } else if (e.Player.HasComponent("ShieldAbility")) {
+        req.Class = PlayerClass::Defender;
+    } else {
+        req.Class = PlayerClass::None;
+    }
     m_SpawnRequests.push_back(req);
 
     return true;

src/Game/Systems/ScoreScreenSystem.cpp

@@ -78,7 +78,7 @@ void ScoreScreenSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper&
 
         if (it == m_PlayerIdentities.end()) {
             break;
-        }
+        }  
 
         if(found == false) {
             if(it->second.Team != currentTeam) {

src/Game/Systems/ServerListSystem.cpp

@@ -0,0 +1,53 @@
+#include "../Game/Systems/ServerListSystem.h"
+
+ServerListSystem::ServerListSystem(SystemParams params, IRenderer* renderer)
+    : System(params)
+    , PureSystem("ServerList")
+    , m_Renderer(renderer)
+{
+    EVENT_SUBSCRIBE_MEMBER(m_EServerListRecieved, &ServerListSystem::OnServerListRecieved);
+}
+
+void ServerListSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& cServerList, double dt)
+{
+    
+}
+
+void ServerListSystem::RefreshList()
+{
+    Events::SearchForServers event;
+    m_EventBroker->Publish(event);
+}
+
+
+bool ServerListSystem::OnServerListRecieved(const Events::DisplayServerlist& e)
+{
+    if (e.Serverlist.size() == 0) {
+        return 1;
+    }
+    auto serverLists = m_World->GetComponents("ServerList");
+    if (serverLists == nullptr)
+        return 1;
+    for (auto& cServerList : *serverLists) {
+        EntityWrapper serverListEntity = EntityWrapper(m_World, cServerList.EntityID);
+        EntityWrapper identitySpawner = serverListEntity.FirstChildByName("ServerIdentitySpawner");
+        identitySpawner.DeleteChildren();
+
+        (int&)cServerList["TotalIdentities"] = (int)e.Serverlist.size();
+        for (int i = 0; i < e.Serverlist.size(); i++) {
+            //Create Identities for each server and place them on the right position.
+            EntityWrapper newIdentity = SpawnerSystem::Spawn(identitySpawner, identitySpawner);
+
+            glm::vec3 offset = (glm::vec3)serverListEntity["ServerList"]["Offset"];
+            (glm::vec3&)newIdentity["Transform"]["Position"] = offset * (float)i;
+
+            auto& cIdentity = newIdentity["ServerIdentity"];
+            (std::string&)cIdentity["IP"] = e.Serverlist[i].Address;
+            (std::string&)cIdentity["ServerName"] = e.Serverlist[i].Name;
+            (int&)cIdentity["Port"] = e.Serverlist[i].Port;
+            (int&)cIdentity["PlayersConnected"] = e.Serverlist[i].PlayersConnected;
+        }
+    }
+
+    return 1;
+}

src/Game/Systems/SpectatorCameraSystem.cpp

@@ -0,0 +1,90 @@
+#include "Systems/SpectatorCameraSystem.h"
+#include "Rendering/ESetCamera.h"
+#include "Core/ELockMouse.h"
+
+SpectatorCameraSystem::SpectatorCameraSystem(SystemParams params)
+    : System(params)
+    , m_CamSetToTeamPick(false)
+    , m_PickedTeam(-1)
+{
+    EVENT_SUBSCRIBE_MEMBER(m_EInputCommand, &SpectatorCameraSystem::OnInputCommand);
+}
+
+void SpectatorCameraSystem::Update(double dt)
+{
+    if (!m_CamSetToTeamPick && IsClient) {
+        // Find the class pick camera and set them to it, since they need to pick a team before they can leave the screen.
+        EntityWrapper spectatorCam = m_World->GetFirstEntityByName("PickTeamCamera");
+        if (spectatorCam.HasComponent("Camera")) {
+            m_CamSetToTeamPick = true;
+            Events::SetCamera eSetCamera;
+            eSetCamera.CameraEntity = spectatorCam;
+            m_EventBroker->Publish(eSetCamera);
+            Events::UnlockMouse unlock;
+            m_EventBroker->Publish(unlock);
+        }
+    }
+}
+
+bool SpectatorCameraSystem::OnInputCommand(const Events::InputCommand& e)
+{
+    // Only the client should do this, and only if player is not spawned.
+    if (!IsClient || LocalPlayer.Valid()) {
+        return false;
+    }
+    bool swapToClass = e.Command == "PickTeam" || e.Command == "SwapToClassPick";
+    if (e.Value == 0 || !swapToClass && e.Command != "SwapToTeamPick" && e.Command != "PickClass") {
+        return false;
+    }
+
+    if (e.Command == "PickTeam") {
+        m_PickedTeam = e.Value;
+    }
+
+    // If a team has not been picked, they may not exit the pick team screen.
+    if (m_PickedTeam == -1) {
+        return false;
+    }
+
+    // A dead client should be able to swap to and between the overwatch cameras.
+    std::string camName;
+    // TODO: 1 Signifies spectator, should probably have real enum here later.
+    // Spectators should never end up at the class select, instead put them at the SpectatorCamera.
+    if (swapToClass && m_PickedTeam != 1) {
+        camName = "PickClassCamera";
+    } else if (e.Command == "SwapToTeamPick") {
+        camName = "PickTeamCamera";
+    } else {
+        camName = "SpectatorCamera";
+    }
+    EntityWrapper spectatorCam = m_World->GetFirstEntityByName(camName);
+    // Set the camera as active, if it exists.
+    if (spectatorCam.HasComponent("Camera")) {
+        // Set the class pick button visible if a blue or red team is picked, else invisible.
+        EntityWrapper HUD;
+        if (camName == "SpectatorCamera") {
+            HUD = spectatorCam.FirstChildByName("SpectatorHUD");
+        } else if (camName == "PickTeamCamera") {
+            HUD = spectatorCam.FirstChildByName("PickTeamHUD");
+        }
+        // If we are at the class pick already, or if HUD is invalid for any other reason, do nothing.
+        if (HUD.Valid()) {
+            EntityWrapper toClassButton = spectatorCam.FirstChildByName("ToClassPick");
+            if (toClassButton.Valid()) {
+                // Set ClassButton as invisible if spectator, else visible.
+                bool visible = m_PickedTeam != 1;   // TODO: 1 Signifies spectator.
+                toClassButton["Sprite"]["Visible"] = visible;
+                for (auto& child : toClassButton.ChildrenWithComponent("Text")) {
+                    child["Text"]["Visible"] = visible;
+                }
+            }
+        }
+        Events::SetCamera eSetCamera;
+        eSetCamera.CameraEntity = spectatorCam;
+        m_EventBroker->Publish(eSetCamera);
+        Events::UnlockMouse unlock;
+        m_EventBroker->Publish(unlock);
+    }
+
+    return true;
+}