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

# Conflicts:
#	include/Engine/Collision/FillFrustumOctreeSystem.h
#	include/Engine/Core/Octree.h
#	include/Engine/Rendering/RenderSystem.h
#	include/Game/Game.h
#	resources/DefaultInput.ini
#	resources/Schema/Components.xsd
#	resources/Schema/Entities/Player.xml
#	resources/Schema/Types/Entity.xsd
#	src/Engine/Rendering/RenderSystem.cpp
#	src/Game/Game.cpp
#	src/Game/Systems/PlayerMovementSystem.cpp

src/Game/Game.cpp

@@ -1,5 +1,6 @@
 #include "Game.h"
-#include "Collision/CollidableOctreeSystem.h"
+#include "Collision/FillOctreeSystem.h"
+#include "Collision/FillFrustumOctreeSystem.h"
 #include "Collision/EntityAABB.h"
 #include "Collision/TriggerSystem.h"
 #include "Collision/CollisionSystem.h"
@@ -8,10 +9,14 @@
 #include "Systems/PlayerMovementSystem.h"
 #include "Systems/SpawnerSystem.h"
 #include "Systems/PlayerSpawnSystem.h"
+#include "Systems/PlayerDeathSystem.h"
 #include "Core/EntityFileWriter.h"
 #include "Game/Systems/CapturePointSystem.h"
+#include "Game/Systems/PickupSpawnSystem.h"
 #include "Game/Systems/WeaponSystem.h"
+#include "Rendering/AnimationSystem.h"
 #include "Game/Systems/PlayerHUDSystem.h"
+#include "Rendering/BoneAttachmentSystem.h"
 #include "Game/Systems/LifetimeSystem.h"
 #include "Rendering/AnimationSystem.h"
 #include "Network/MultiplayerSnapshotFilter.h"
@@ -74,6 +79,9 @@ Game::Game(int argc, char* argv[])
         fp.MergeEntities(m_World);
     }
 
+    // Create the sound manager
+    m_SoundManager = new SoundManager(m_World, m_EventBroker);
+
     // Initialize network
     if (m_Config->Get<bool>("Networking.StartNetwork", false)) {
         if (m_IsServer) {
@@ -87,9 +95,11 @@ Game::Game(int argc, char* argv[])
     }
 
     // Create Octrees
-    m_OctreeCollision = new Octree<EntityAABB>(AABB(glm::vec3(-100), glm::vec3(100)), 4);
-    m_OctreeTrigger = new Octree<EntityAABB>(AABB(glm::vec3(-100), glm::vec3(100)), 4);
-    m_OctreeFrustrumCulling = new Octree<EntityAABB>(AABB(glm::vec3(-100), glm::vec3(100)), 4);
+    // TODO: Perhaps the world bounds should be set in some non-arbitrary way instead of this.
+    AABB boxContainingTheWorld(glm::vec3(-300), glm::vec3(300));
+    m_OctreeCollision = new Octree<EntityAABB>(boxContainingTheWorld, 4);
+    m_OctreeTrigger = new Octree<EntityAABB>(boxContainingTheWorld, 4);
+    m_OctreeFrustrumCulling = new Octree<EntityAABB>(boxContainingTheWorld, 4);
     // Create system pipeline
     m_SystemPipeline = new SystemPipeline(m_World, m_EventBroker, m_IsClient, m_IsServer);
 
@@ -97,44 +107,45 @@ Game::Game(int argc, char* argv[])
     unsigned int updateOrderLevel = 0;
     m_SystemPipeline->AddSystem<InterpolationSystem>(updateOrderLevel);
     ++updateOrderLevel;
+    m_SystemPipeline->AddSystem<SoundSystem>(updateOrderLevel);
     m_SystemPipeline->AddSystem<RaptorCopterSystem>(updateOrderLevel);
     m_SystemPipeline->AddSystem<ExplosionEffectSystem>(updateOrderLevel);
     m_SystemPipeline->AddSystem<HealthSystem>(updateOrderLevel);
     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<PickupSpawnSystem>(updateOrderLevel);
     // Populate Octree with collidables
     ++updateOrderLevel;
-    m_SystemPipeline->AddSystem<CollidableOctreeSystem>(updateOrderLevel, m_OctreeCollision, "Collidable");
-    m_SystemPipeline->AddSystem<CollidableOctreeSystem>(updateOrderLevel, m_OctreeTrigger, "Player");
-    m_SystemPipeline->AddSystem<PlayerHUDSystem>(updateOrderLevel);
+    m_SystemPipeline->AddSystem<FillOctreeSystem>(updateOrderLevel, m_OctreeCollision, "Collidable");
+    m_SystemPipeline->AddSystem<FillOctreeSystem>(updateOrderLevel, m_OctreeTrigger, "Player");
+    m_SystemPipeline->AddSystem<FillFrustumOctreeSystem>(updateOrderLevel, m_OctreeFrustrumCulling);
     m_SystemPipeline->AddSystem<AnimationSystem>(updateOrderLevel);
-
+    m_SystemPipeline->AddSystem<PlayerHUDSystem>(updateOrderLevel);
     // Collision and TriggerSystem should update after player.
     ++updateOrderLevel;
+    m_SystemPipeline->AddSystem<BoneAttachmentSystem>(updateOrderLevel);
     m_SystemPipeline->AddSystem<CollisionSystem>(updateOrderLevel, m_OctreeCollision);
     m_SystemPipeline->AddSystem<TriggerSystem>(updateOrderLevel, m_OctreeTrigger);
     ++updateOrderLevel;
-    m_SystemPipeline->AddSystem<RenderSystem>(updateOrderLevel, m_Renderer, m_RenderFrame);
+    m_SystemPipeline->AddSystem<RenderSystem>(updateOrderLevel, m_Renderer, m_RenderFrame, m_OctreeFrustrumCulling);
     ++updateOrderLevel;
     m_SystemPipeline->AddSystem<EditorSystem>(updateOrderLevel, m_Renderer, m_RenderFrame);
 
-    // Invoke sound system
-    m_SoundSystem = new SoundSystem(m_World, m_EventBroker, m_Config->Get<bool>("Debug.EditorEnabled", false));
-
     m_LastTime = glfwGetTime();
 }
 
 Game::~Game()
 {
     delete m_SystemPipeline;
-    delete m_SoundSystem;
     delete m_OctreeFrustrumCulling;
     delete m_OctreeCollision;
     delete m_OctreeTrigger;
+    delete m_SoundManager;
     if (m_NetworkClient != nullptr) {
         delete m_NetworkClient;
     }
@@ -168,6 +179,8 @@ void Game::Tick()
     m_InputProxy->Process();
     m_EventBroker->Swap();
 
+    m_SoundManager->Update(dt);
+
     // Update network
     m_EventBroker->Process<MultiplayerSnapshotFilter>();
     if (m_NetworkClient != nullptr) {
@@ -176,12 +189,12 @@ void Game::Tick()
     if (m_NetworkServer != nullptr) {
         m_NetworkServer->Update();
     }
+    //m_SoundManager->Update(dt);
 
     // Iterate through systems and update world!
     m_EventBroker->Process<SystemPipeline>();
     m_SystemPipeline->Update(dt);
     m_Renderer->Update(dt);
-    m_SoundSystem->Update(dt);
     m_Renderer->Draw(*m_RenderFrame);
     m_RenderFrame->Clear();
     m_EventBroker->Swap();

src/Game/Systems/CapturePointSystem.cpp

@@ -57,7 +57,7 @@ void CapturePointSystem::UpdateComponent(EntityWrapper& capturePointEntity, Comp
     int blueTeamPlayersStandingInside = 0;
     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.2f, 1, 1) : ownedBy == redTeam ? glm::vec4(1, 0.2f, 0, 1) : glm::vec4(1, 1, 1, 1);
+        capturePointEntity["Model"]["Color"] = ownedBy == blueTeam ? glm::vec4(0, 0.2f, 1, 0.3) : ownedBy == redTeam ? glm::vec4(1, 0.2f, 0, 0.3) : glm::vec4(1, 1, 1, 0.3);
     }
 
     //calculate next possible capturePoint for both teams
@@ -106,10 +106,10 @@ void CapturePointSystem::UpdateComponent(EntityWrapper& capturePointEntity, Comp
 
     //colorize next possible capturepoint
     if (nextPossibleCapturePoint["Red"] == capturePointNumber) {
-        capturePointEntity["Model"]["Color"] = glm::vec4(1, 1, 0, 1);
+        capturePointEntity["Model"]["Color"] = glm::vec4(1, 1, 0, 0.3);
     }
     if (nextPossibleCapturePoint["Blue"] == capturePointNumber) {
-        capturePointEntity["Model"]["Color"] = glm::vec4(0, 1, 1, 1);
+        capturePointEntity["Model"]["Color"] = glm::vec4(0, 1, 1, 0.3);
     }
 
     //check how many players are standing inside and are healthy

src/Game/Systems/HealthSystem.cpp

@@ -11,38 +11,6 @@ HealthSystem::HealthSystem(SystemParams params)
 
 void HealthSystem::UpdateComponent(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)
-    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) == component.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) {
-                component["Health"] = 0.0;
-                //publish death event
-                Events::PlayerDeath e;
-                e.PlayerID = component.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]) == component.EntityID)
-                        m_DeltaHealthVector.erase(m_DeltaHealthVector.begin() + j - 1);
-                }
-                //delete the player and break the loop
-                m_World->DeleteEntity(entity.ID);
-                break;
-            }
-        }
-    }
 }
 
 bool HealthSystem::OnPlayerDamaged(Events::PlayerDamage& e)
@@ -50,18 +18,24 @@ bool HealthSystem::OnPlayerDamaged(Events::PlayerDamage& e)
     ComponentWrapper cHealth = e.Player["Health"];
     double& health = cHealth["Health"];
     health -= e.Damage;
-    
+
     if (health <= 0.0) {
-        m_World->DeleteEntity(e.Player.ID);
+        Events::PlayerDeath ePlayerDeath;
+        ePlayerDeath.Player = e.Player;
+        m_EventBroker->Publish(ePlayerDeath);
+        //Note: we will delete the entity in PlayerDeathSystem
     }
 
     return true;
 }
 
-bool HealthSystem::OnPlayerHealthPickup(const Events::PlayerHealthPickup& e)
+bool HealthSystem::OnPlayerHealthPickup(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));
+    ComponentWrapper cHealth = e.Player["Health"];
+    double& health = cHealth["Health"];
+    health += e.HealthAmount;
+    health = std::min(health, (double)cHealth["MaxHealth"]);
+
     return true;
 }
 

src/Game/Systems/PickupSpawnSystem.cpp

@@ -0,0 +1,66 @@
+#include "Systems/PickupSpawnSystem.h"
+
+PickupSpawnSystem::PickupSpawnSystem(SystemParams params)
+    : System(params)
+{
+    EVENT_SUBSCRIBE_MEMBER(m_ETriggerTouch, &PickupSpawnSystem::OnTriggerTouch);
+}
+
+void PickupSpawnSystem::Update(double dt)
+{
+    for (auto it = m_ETriggerTouchVector.begin(); it != m_ETriggerTouchVector.end(); ++it)
+    {
+        auto& healthPickupPosition = *it;
+        //set the double timer value (value 3)
+        healthPickupPosition.DecreaseThisRespawnTimer -= dt;
+        if (healthPickupPosition.DecreaseThisRespawnTimer < 0) {
+            //spawn and delete the vector item
+            auto entityFile = ResourceManager::Load<EntityFile>("Schema/Entities/HealthPickup.xml");
+            EntityFileParser parser(entityFile);
+            EntityID healthPickupID = parser.MergeEntities(m_World);
+
+            //let the world know a pickup has spawned (graphics effects, etc)
+            Events::PickupSpawned ePickupSpawned;
+            ePickupSpawned.Pickup = EntityWrapper(m_World, healthPickupID);
+            m_EventBroker->Publish(ePickupSpawned);
+
+            //set values from the old entity to the new entity
+            auto& newHealthPickupEntity = EntityWrapper(m_World, healthPickupID);
+            newHealthPickupEntity["Transform"]["Position"] = healthPickupPosition.Pos;
+            newHealthPickupEntity["HealthPickup"]["HealthGain"] = healthPickupPosition.HealthGain;
+            newHealthPickupEntity["HealthPickup"]["RespawnTimer"] = healthPickupPosition.RespawnTimer;
+
+            //erase the current element (healthPickupPosition)
+            m_ETriggerTouchVector.erase(it);
+            break;
+        }
+    }
+}
+
+
+bool PickupSpawnSystem::OnTriggerTouch(Events::TriggerTouch& e)
+{
+    if (!e.Trigger.HasComponent("HealthPickup")) {
+        return false;
+    }
+    double healthGiven = 0.01*(double)e.Trigger["HealthPickup"]["HealthGain"] * (double)e.Entity["Health"]["MaxHealth"];
+    //cant pick up healthpacks if you are already at MaxHealth
+    if ((double)e.Entity["Health"]["Health"] >= (double)e.Entity["Health"]["MaxHealth"]) {
+        return false;
+    }
+
+    //personEntered = e.Entity, thingEntered = e.Trigger
+    Events::PlayerHealthPickup ePlayerHealthPickup;
+    ePlayerHealthPickup.HealthAmount = healthGiven;
+    ePlayerHealthPickup.Player = e.Entity;
+    m_EventBroker->Publish(ePlayerHealthPickup);
+
+    //copy position, healthgain, 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 healthPickup
+    m_ETriggerTouchVector.push_back({ (glm::vec3)e.Trigger["Transform"]["Position"] ,e.Trigger["HealthPickup"]["HealthGain"],
+        e.Trigger["HealthPickup"]["RespawnTimer"],e.Trigger["HealthPickup"]["RespawnTimer"] });
+
+    //delete the healthpickup
+    m_World->DeleteEntity(e.Trigger.ID);
+    return true;
+}

src/Game/Systems/PlayerDeathSystem.cpp

@@ -0,0 +1,57 @@
+#include "Systems/PlayerDeathSystem.h"
+
+PlayerDeathSystem::PlayerDeathSystem(SystemParams params)
+    : System(params)
+{
+    EVENT_SUBSCRIBE_MEMBER(m_OnPlayerDeath, &PlayerDeathSystem::OnPlayerDeath);
+}
+
+void PlayerDeathSystem::Update(double dt)
+{
+}
+
+bool PlayerDeathSystem::OnPlayerDeath(Events::PlayerDeath& e)
+{
+    if (!e.Player.Valid()) {
+        return false;
+    }
+
+    createDeathEffect(e.Player);
+
+    // Delete player
+    m_World->DeleteEntity(e.Player.ID);
+
+    return true;
+}
+
+void PlayerDeathSystem::createDeathEffect(EntityWrapper player)
+{
+    //load the explosioneffect XML
+    auto deathEffect = ResourceManager::Load<EntityFile>("Schema/Entities/PlayerDeathExplosionWithCamera.xml");
+    EntityFileParser parser(deathEffect);
+    EntityID deathEffectID = parser.MergeEntities(m_World);
+    EntityWrapper deathEffectEW = EntityWrapper(m_World, deathEffectID);
+
+    //components that we need from player
+    auto playerCamera = player.FirstChildByName("Camera");
+    auto playerEntityModel = player.FirstChildByName("PlayerModel")["Model"];
+    auto playerEntityAnimation = player.FirstChildByName("PlayerModel")["Animation"];
+
+    //copy the data from player to explisioneffectmodel
+    playerEntityModel.Copy(deathEffectEW["Model"]);
+    playerEntityAnimation.Copy(deathEffectEW["Animation"]);
+    //freeze the animation
+    deathEffectEW["Animation"]["Speed"] = 0.0;
+
+    //copy the models position,orientation
+    deathEffectEW["Transform"]["Position"] = (glm::vec3)player["Transform"]["Position"];
+    deathEffectEW["Transform"]["Orientation"] = (glm::vec3)player["Transform"]["Orientation"];
+    //effect,camera is relative to playersPosition
+    //deathEffectEW["ExplosionEffect"]["ExplosionOrigin"] = glm::vec3(0, 0, 0);
+
+    //camera (with lifetime) behind the player
+    auto cam = deathEffectEW.FirstChildByName("Camera");
+    Events::SetCamera eSetCamera;
+    eSetCamera.CameraEntity = cam;
+    m_EventBroker->Publish(eSetCamera);
+}

src/Game/Systems/PlayerMovementSystem.cpp

@@ -61,12 +61,20 @@ void PlayerMovementSystem::updateMovementControllers(double dt)
             } else {
                 wishSpeed = playerMovementSpeed;
             }
+            if (player.ID == m_LocalPlayer.ID) {
+                if (glm::length(wishDirection) == 0) {
+                    // If no key is pressed, reset the distance moved since last step.
+                    m_DistanceMoved = 0;
+                }
+            }
             glm::vec3& velocity = cPhysics["Velocity"];
-            ImGui::Text("velocity: (%f, %f, %f)", velocity.x, velocity.y, velocity.z);
+            bool isOnGround = (bool)cPhysics["IsOnGround"];
+            ImGui::Text(isOnGround ? "On ground" : "In air");
+            ImGui::Text("velocity: (%f, %f, %f) |%f|", velocity.x, velocity.y, velocity.z, glm::length(velocity));
             glm::vec3 groundVelocity(0.f, 0.f, 0.f);
-            groundVelocity.x = glm::dot(velocity, glm::vec3(1.f, 0.f, 0.f));
-            groundVelocity.z = glm::dot(velocity, glm::vec3(0.f, 0.f, 1.f));
-            ImGui::Text("groundVelocity: (%f, %f, %f) |%f|", groundVelocity.x, groundVelocity.y, groundVelocity.z, glm::length(wishDirection));
+            groundVelocity.x = velocity.x;
+            groundVelocity.z = velocity.z;
+            ImGui::Text("groundVelocity: (%f, %f, %f) |%f|", groundVelocity.x, groundVelocity.y, groundVelocity.z, glm::length(groundVelocity));
             ImGui::Text("wishDirection: (%f, %f, %f) |%f|", wishDirection.x, wishDirection.y, wishDirection.z, glm::length(wishDirection));
             float currentSpeedProj = glm::dot(groundVelocity, wishDirection);
             float addSpeed = wishSpeed - currentSpeedProj;
@@ -79,7 +87,7 @@ void PlayerMovementSystem::updateMovementControllers(double dt)
                 ImGui::InputFloat("accel", &accel);
                 static float airAccel = 0.5f;
                 ImGui::InputFloat("airAccel", &airAccel);
-                float actualAccel = (velocity.y != 0) ? airAccel : accel;
+                float actualAccel = isOnGround ? accel : airAccel;
                 static float surfaceFriction = 5.f;
                 ImGui::InputFloat("surfaceFriction", &surfaceFriction);
                 float accelerationSpeed = actualAccel * (float)dt * wishSpeed * surfaceFriction;
@@ -91,13 +99,16 @@ void PlayerMovementSystem::updateMovementControllers(double dt)
             }
 
             //you cant jump and dash at the same time - since there is no friction in the air and we would thus dash much further in the air
-            if (!controller->PlayerIsDashing() && controller->Jumping() && !controller->Crouching() && (velocity.y == 0.f || !controller->DoubleJumping())) {
+            if (!controller->PlayerIsDashing() && controller->Jumping() && !controller->Crouching() && (isOnGround || !controller->DoubleJumping())) {
+                (bool)cPhysics["IsOnGround"] = false;
                 if (velocity.y == 0.f) {
                     controller->SetDoubleJumping(false);
                 } else {
                     controller->SetDoubleJumping(true);
+                    Events::DoubleJump e;
+                    m_EventBroker->Publish(e);
                 }
-                velocity.y += 4.f;
+                velocity.y = 4.f;
             }
 
             if (player.HasComponent("AABB")) {
@@ -118,19 +129,19 @@ void PlayerMovementSystem::updateMovementControllers(double dt)
                 //TODO: add assault dash animation here
                 if (glm::length(controller->Movement()) > 0.f) {
                     if (controller->Crouching()) {
-                        cAnimation["Name"] = "Crouch Walk";
-                        (double&)cAnimation["Speed"] = 1.f * -glm::sign(controller->Movement().z);
+                        cAnimation["AnimationName1"] = "Crouch Walk";
+                        (double&)cAnimation["Speed1"] = 1.f * -glm::sign(controller->Movement().z);
                     } else {
-                        cAnimation["Name"] = "Run";
-                        (double&)cAnimation["Speed"] = 2.f * -glm::sign(controller->Movement().z);
+                        cAnimation["AnimationName1"] = "Run";
+                        (double&)cAnimation["Speed1"] = 2.f * -glm::sign(controller->Movement().z);
                     }
                 } else {
                     if (controller->Crouching()) {
-                        cAnimation["Name"] = "Crouch";
+                        cAnimation["AnimationName1"] = "Crouch";
                         (double&)cAnimation["Speed"] = 1.f;
                     } else {
-                        cAnimation["Name"] = "Hold Pos";
-                        (double&)cAnimation["Speed"] = 1.f;
+                        cAnimation["AnimationName1"] = "Hold Pos";
+                        (double&)cAnimation["Speed1"] = 1.f;
                     }
                 }
             }
@@ -138,6 +149,7 @@ void PlayerMovementSystem::updateMovementControllers(double dt)
 
         controller->Reset();
     }
+    playerStep(dt);
 }
 
 
@@ -151,6 +163,7 @@ void PlayerMovementSystem::updateVelocity(double dt)
     ComponentWrapper& cTransform = LocalPlayer["Transform"];
     ComponentWrapper& cPhysics = LocalPlayer["Physics"];
     glm::vec3& velocity = cPhysics["Velocity"];
+    bool isOnGround = (bool)cPhysics["IsOnGround"];
 
     // Ground friction
     float speed = glm::length(velocity);
@@ -158,7 +171,7 @@ void PlayerMovementSystem::updateVelocity(double dt)
     ImGui::InputFloat("groundFriction", &groundFriction);
     static float airFriction = 0.f;
     ImGui::InputFloat("airFriction", &airFriction);
-    float friction = (velocity.y != 0) ? airFriction : groundFriction;
+    float friction = isOnGround ? groundFriction : airFriction;
     if (speed > 0) {
         float drop = speed * friction * (float)dt;
         float multiplier = glm::max(speed - drop, 0.f) / speed;
@@ -175,9 +188,37 @@ void PlayerMovementSystem::updateVelocity(double dt)
     position += velocity * (float)dt;
 }
 
+void PlayerMovementSystem::playerStep(double dt)
+{
+    if (!m_LocalPlayer.Valid()) {
+        return;
+    }
+    // Position of the local player, used see how far a player has moved.
+    glm::vec3 pos = (glm::vec3)m_World->GetComponent(m_LocalPlayer.ID, "Transform")["Position"];
+    // Used to see if a player is airborne.
+    bool grounded = (bool)m_World->GetComponent(m_LocalPlayer.ID, "Physics")["IsOnGround"];
+    m_DistanceMoved += glm::length(pos - m_LastPosition);
+    // Set the last position for next iteration
+    m_LastPosition = pos;
+    if (m_DistanceMoved > m_PlayerStepLength && grounded) {
+        // Player moved a step's distance
+        // Create footstep sound
+        Events::PlaySoundOnEntity e;
+        e.EmitterID = m_LocalPlayer.ID;
+        e.FilePath = m_LeftFoot ? "Audio/footstep/footstep2.wav" : "Audio/footstep/footstep3.wav";
+        m_LeftFoot = !m_LeftFoot;
+        m_EventBroker->Publish(e);
+        m_DistanceMoved = 0.f;
+    }
+}
+
 bool PlayerMovementSystem::OnPlayerSpawned(Events::PlayerSpawned& e)
 {
     // When a player spawns, create an input controller for them
     m_PlayerInputControllers[e.Player] = new FirstPersonInputController<PlayerMovementSystem>(m_EventBroker, e.PlayerID);
+    if (e.PlayerID == -1) {
+        // Keep track of the local player
+        m_LocalPlayer = e.Player;
+    }
     return true;
 }

src/Game/Systems/PlayerSpawnSystem.cpp

@@ -78,7 +78,9 @@ bool PlayerSpawnSystem::OnPlayerSpawned(Events::PlayerSpawned& e)
     // Check if a player already exists
     if (m_PlayerEntities.count(e.PlayerID) != 0) {
         // TODO: Disallow infinite respawning here
-        m_World->DeleteEntity(m_PlayerEntities[e.PlayerID].ID);
+        if (m_PlayerEntities[e.PlayerID].Valid()) {
+            m_World->DeleteEntity(m_PlayerEntities[e.PlayerID].ID);
+        }
     }
 
     // Store the player for future reference

src/Game/Systems/SoundSystem.cpp

@@ -0,0 +1,187 @@
+#include "Game/Systems/SoundSystem.h"
+
+SoundSystem::SoundSystem(SystemParams params)
+    : System(params)
+    , PureSystem("SoundEmitter")
+    //, ImpureSystem()
+{
+    ConfigFile* config = ResourceManager::Load<ConfigFile>("Config.ini");
+    m_Announcer = ResourceManager::Load<ConfigFile>("Config.ini")->Get<std::string>("Sound.Announcer", "female");
+    EVENT_SUBSCRIBE_MEMBER(m_EPlayerSpawned, &SoundSystem::OnPlayerSpawned);
+    EVENT_SUBSCRIBE_MEMBER(m_InputCommand, &SoundSystem::OnInputCommand);
+    EVENT_SUBSCRIBE_MEMBER(m_EDoubleJump, &SoundSystem::OnDoubleJump);
+    EVENT_SUBSCRIBE_MEMBER(m_EDashAbility, &SoundSystem::OnDashAbility);
+    EVENT_SUBSCRIBE_MEMBER(m_EShoot, &SoundSystem::OnShoot);
+    EVENT_SUBSCRIBE_MEMBER(m_EPlayerDamage, &SoundSystem::OnPlayerDamage);
+    EVENT_SUBSCRIBE_MEMBER(m_ECaptured, &SoundSystem::OnCaptured);
+    EVENT_SUBSCRIBE_MEMBER(m_ETriggerTouch, &SoundSystem::OnTriggerTouch);
+}
+
+void SoundSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& cComponent, double dt)
+{ }
+
+void SoundSystem::Update(double dt)
+{
+    // Temp for play test.
+    if(m_DrumsIsPlaying) {
+        m_DrumsIsPlaying = !drumTimer(dt);
+    }
+}
+
+bool SoundSystem::OnPlayerSpawned(const Events::PlayerSpawned &e)
+{
+    if (e.PlayerID == -1) { // Local player
+        m_World->AttachComponent(e.Player.ID, "Listener");
+        Events::PlaySoundOnEntity go;
+        go.EmitterID = LocalPlayer.ID;
+        go.FilePath = "Audio/announcer/" + m_Announcer + "/go.wav";
+        m_EventBroker->Publish(go);
+        // TEMP: starts bgm
+        {
+            Events::PlayBackgroundMusic ev;
+            ev.FilePath = "Audio/bgm/ambient.wav";
+            m_EventBroker->Publish(ev);
+        }
+    }
+    return true;
+}
+
+bool SoundSystem::OnInputCommand(const Events::InputCommand & e)
+{
+    if (e.Command == "Jump" && e.Value > 0) {
+        if (e.PlayerID == -1) { // local player
+            playerJumps();
+            return true;
+        }
+    }
+    if (e.Command == "TakeDamage" && e.Value > 0) {
+        Events::PlayerDamage ev;
+        ev.Player = LocalPlayer;
+        ev.Damage = 1.0;
+        m_EventBroker->Publish(ev);
+    }
+
+    return false;
+}
+
+void SoundSystem::playerJumps()
+{
+    bool grounded = (bool)m_World->GetComponent(LocalPlayer.ID, "Physics")["IsOnGround"];
+    if (grounded) {
+        Events::PlaySoundOnEntity e;
+        e.EmitterID = LocalPlayer.ID;
+        e.FilePath = "Audio/jump/jump1.wav";
+        m_EventBroker->Publish(e);
+    }
+}
+
+bool SoundSystem::drumTimer(double dt)
+{
+    m_DrumTimer += dt;
+    if (m_DrumTimer > 15) {
+        m_DrumTimer = 0.0;
+        return true;
+    } else {
+        return false;
+    }
+}
+
+bool SoundSystem::OnShoot(const Events::Shoot & e)
+{
+    Events::PlaySoundOnEntity ev;
+    ev.EmitterID = LocalPlayer.ID;
+    ev.FilePath = "Audio/laser/laser1.wav";
+    m_EventBroker->Publish(ev);
+    return true;
+}
+
+bool SoundSystem::OnCaptured(const Events::Captured & e)
+{
+    int homeTeam = (int)m_World->GetComponent(e.CapturePointID, "Team")["Team"];
+    int team = (int)m_World->GetComponent(LocalPlayer.ID, "Team")["Team"];
+    Events::PlaySoundOnEntity ev;
+    if (team == homeTeam) {
+        ev.FilePath = "Audio/announcer/" + m_Announcer + "/objective_achieved.wav";
+    } else {
+        ev.FilePath = "Audio/announcer/" + m_Announcer + "/objective_failed.wav"; // have not been tested
+    }
+    ev.EmitterID = LocalPlayer.ID;
+    m_EventBroker->Publish(ev);
+    // Temp for play test.
+    m_DrumsIsPlaying = false;
+    return false;
+}
+
+// Testing purposes atm...
+bool SoundSystem::OnPlayerDamage(const Events::PlayerDamage & e)
+{
+    // Should check for only local players here...
+    std::uniform_int_distribution<int> dist(1, 12);
+    int rand = dist(generator);
+    std::vector<std::string> paths;
+    paths.push_back("Audio/hurt/hurt" + std::to_string(rand) + ".wav");
+
+//     // Breathe
+//     int ammountOfbreaths = (static_cast<int>(e.Damage) / 10) + 2; // TEMP: Idk something stupid like this shit
+//     for (int i = 0; i < ammountOfbreaths; i++) {
+//         paths.push_back("Audio/exhausted/breath.wav");
+//     }
+    Events::PlayQueueOnEntity ev;
+    ev.Emitter = LocalPlayer;
+    ev.FilePaths = paths;
+    m_EventBroker->Publish(ev);
+    return false;
+}
+
+bool SoundSystem::OnPlayerDeath(const Events::PlayerDeath & e)
+{
+    Events::PlaySoundOnEntity ev;
+    ev.EmitterID = LocalPlayer.ID;
+    ev.FilePath = "Audio/die/die2.wav"; 
+    m_EventBroker->Publish(ev);
+    return false;
+}
+
+bool SoundSystem::OnPlayerHealthPickup(const Events::PlayerHealthPickup & e)
+{
+    Events::PlaySoundOnEntity ev;
+    ev.EmitterID = LocalPlayer.ID;
+    ev.FilePath = "Audio/pickup/pickup2.wav";
+    m_EventBroker->Publish(ev);
+    return false;
+}
+
+bool SoundSystem::OnTriggerTouch(const Events::TriggerTouch & e)
+{
+    // Temp for play test.
+    if (m_DrumsIsPlaying) {
+        return false;
+    }
+    if (m_World->HasComponent(e.Trigger.ID, "CapturePoint")) {
+        Events::PlaySoundOnEntity ev; // should be BGM
+        ev.EmitterID = LocalPlayer.ID;
+        ev.FilePath = "Audio/bgm/drumstest.wav";
+        m_EventBroker->Publish(ev);
+        // Temp for play test.
+        m_DrumsIsPlaying = true;
+    }
+    return false;
+}
+
+bool SoundSystem::OnDoubleJump(const Events::DoubleJump & e)
+{
+    Events::PlaySoundOnEntity ev;
+    ev.EmitterID = LocalPlayer.ID;
+    ev.FilePath = "Audio/jump/jump2.wav";
+    m_EventBroker->Publish(ev);
+    return false;
+}
+
+bool SoundSystem::OnDashAbility(const Events::DashAbility &e)
+{
+    Events::PlaySoundOnEntity ev;
+    ev.EmitterID = LocalPlayer.ID;
+    ev.FilePath = "Audio/jump/dash1.wav";
+    m_EventBroker->Publish(ev);
+    return false;
+}