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

# Conflicts:
#	resources/Schema/Components.xsd
#	resources/Schema/Entities/Player.xml
#	resources/Schema/Types/Entity.xsd

src/Engine/GUI/ButtonSystem.cpp

@@ -1,4 +1,5 @@
 #include "GUI/ButtonSystem.h"
+#include "Input/EInputCommand.h"
 
 ButtonSystem::ButtonSystem(SystemParams params, IRenderer* renderer)
     : System(params)
@@ -37,10 +38,20 @@ bool ButtonSystem::OnMousePress(const Events::MousePress& e)
                 m_PickEntity = EntityWrapper(m_World, m_PickData.Entity);
 
                 //You have clicked on a button entity, send pressed event.
-                Events::ButtonPressed ePressed;
-                ePressed.Entity = m_PickEntity;
-                ePressed.EntityName = m_PickEntity.Name();
-                m_EventBroker->Publish(ePressed);
+                if (m_World->HasComponent(m_PickData.Entity, "InputCmdButton")) {
+                    Events::InputCommand eInputCmd;
+                    eInputCmd.PlayerID = LocalPlayer.ID;
+                    eInputCmd.Player = LocalPlayer;
+                    EntityWrapper button = EntityWrapper(m_World, m_PickData.Entity);
+                    eInputCmd.Command = (std::string)button["InputCmdButton"]["Command"];
+                    eInputCmd.Value = (float)button["InputCmdButton"]["PressValue"];
+                    m_EventBroker->Publish(eInputCmd);
+                } else {
+                    Events::ButtonPressed ePressed;
+                    ePressed.Entity = m_PickEntity;
+                    ePressed.EntityName = m_PickEntity.Name();
+                    m_EventBroker->Publish(ePressed);
+                }
             }
         }
     }
@@ -55,10 +66,20 @@ bool ButtonSystem::OnMouseRelease(const Events::MouseRelease& e)
         if(m_PickData.Entity != EntityID_Invalid && m_PickData.World == m_World) {
             EntityWrapper ent = EntityWrapper(m_World, m_PickData.Entity);
 
-            Events::ButtonReleased eReleased;
-            eReleased.EntityName = m_PickEntity.Name();
-            eReleased.Entity = m_PickEntity;
-            m_EventBroker->Publish(eReleased);
+            if (m_World->HasComponent(m_PickData.Entity, "InputCmdButton")) {
+                Events::InputCommand eInputCmd;
+                eInputCmd.PlayerID = LocalPlayer.ID;
+                eInputCmd.Player = LocalPlayer;
+                EntityWrapper button = EntityWrapper(m_World, m_PickData.Entity);
+                eInputCmd.Command = (std::string)button["InputCmdButton"]["Command"];
+                eInputCmd.Value = 0;
+                m_EventBroker->Publish(eInputCmd);
+            } else {
+                Events::ButtonReleased eReleased;
+                eReleased.EntityName = m_PickEntity.Name();
+                eReleased.Entity = m_PickEntity;
+                m_EventBroker->Publish(eReleased);
+            }
 
             if(m_World->HasComponent(m_PickData.Entity, "Button")) {
                 if (ent == m_PickEntity) {

src/Engine/Network/UDPClient.cpp

@@ -47,7 +47,7 @@ int UDPClient::readBuffer()
     memcpy(&sizeOfPacket, m_ReadBuffer, sizeof(int));
     if (sizeOfPacket > m_Socket->available()) {
         LOG_WARNING("UDPClient::readBuffer(): We haven't got the whole packet yet.");
-        return 0;
+        //return 0;
     }
     // if the buffer is to small increase the size of it
     if (sizeOfPacket > m_BufferSize) {

src/Engine/Network/UDPServer.cpp

@@ -94,7 +94,7 @@ int UDPServer::readBuffer()
 
     if (sizeOfPacket > m_Socket->available()) {
         LOG_WARNING("UDPServer::readBuffer(): We haven't got the whole packet yet.");
-        return 0;
+        //return 0;
     }
 
     // if the buffer is to small increase the size of it

src/Game/Game.cpp

@@ -18,6 +18,7 @@
 #include "Game/Systems/PickupSpawnSystem.h"
 #include "Game/Systems/AmmoPickupSystem.h"
 #include "Game/Systems/DamageIndicatorSystem.h"
+#include "Game/Systems/Weapon/AssaultWeaponBehaviour.h"
 #include "Game/Systems/Weapon/DefenderWeaponBehaviour.h"
 #include "Game/Systems/Weapon/SidearmWeaponBehaviour.h"
 #include "Rendering/AnimationSystem.h"
@@ -130,6 +131,7 @@ Game::Game(int argc, char* argv[])
     m_SystemPipeline->AddSystem<PlayerMovementSystem>(updateOrderLevel);
     m_SystemPipeline->AddSystem<SpawnerSystem>(updateOrderLevel);
     m_SystemPipeline->AddSystem<PlayerSpawnSystem>(updateOrderLevel);
+    m_SystemPipeline->AddSystem<AssaultWeaponBehaviour>(updateOrderLevel, m_Renderer, m_OctreeCollision);
     m_SystemPipeline->AddSystem<DefenderWeaponBehaviour>(updateOrderLevel, m_Renderer, m_OctreeCollision);
     m_SystemPipeline->AddSystem<SidearmWeaponBehaviour>(updateOrderLevel, m_Renderer, m_OctreeCollision);
     m_SystemPipeline->AddSystem<LifetimeSystem>(updateOrderLevel);

src/Game/Systems/PlayerMovementSystem.cpp

@@ -62,7 +62,14 @@ void PlayerMovementSystem::updateMovementControllers(double dt)
             playerMovementSpeed *= (double)playerBoostAssaultEntity["BoostAssault"]["StrengthOfEffect"];
             playerCrouchSpeed *= (double)playerBoostAssaultEntity["BoostAssault"]["StrengthOfEffect"];
         }
-
+        bool sniperSprinting = false;
+        if (player.HasComponent("SprintAbility")) {
+            if (controller->SpecialAbilityKeyDown()) {
+                playerMovementSpeed *= (double)player["SprintAbility"]["StrengthOfEffect"];
+                playerCrouchSpeed *= (double)player["SprintAbility"]["StrengthOfEffect"];
+                sniperSprinting = true;
+            }
+        }
 
         if (player.HasComponent("Physics")) {
             ComponentWrapper cPhysics = player["Physics"];
@@ -118,6 +125,9 @@ void PlayerMovementSystem::updateMovementControllers(double dt)
                 if (playerBoostAssaultEntity.Valid()) {
                     accelerationSpeed *= (double)playerBoostAssaultEntity["BoostAssault"]["StrengthOfEffect"];
                 }
+                if (sniperSprinting) {
+                    accelerationSpeed *= (double)player["SprintAbility"]["StrengthOfEffect"];
+                }
                 velocity += accelerationSpeed * wishDirection;
                 ImGui::Text("velocity: (%f, %f, %f) |%f|", velocity.x, velocity.y, velocity.z, glm::length(velocity));
             }

src/Game/Systems/PlayerSpawnSystem.cpp

@@ -105,7 +105,7 @@ void PlayerSpawnSystem::Update(double dt)
 
 bool PlayerSpawnSystem::OnInputCommand(Events::InputCommand& e)
 {
-    if (e.Command != "PickTeam") {
+    if (e.Command != "PickTeam" && e.Command != "SwapToClassPick") {
         return false;
     }
 
@@ -113,11 +113,12 @@ bool PlayerSpawnSystem::OnInputCommand(Events::InputCommand& e)
         return false;
     }
 
-    // A dead client should be able to swap to the spectator camera.
+    // A dead client should be able to swap to the overwatch camera.
     if (IsClient && !LocalPlayer.Valid()) {
-        // Set the spectator camera as active, if it exists.
-        // Find the camera.
-        EntityWrapper spectatorCam = m_World->GetFirstEntityByName("SpectatorCamera");
+        // 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;
@@ -135,10 +136,18 @@ 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);
+            }
             break;
         }
     }
 
+    if (e.Command == "SwapToClassPick") {
+        return true;
+    }
+
     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;

src/Game/Systems/Weapon/AssaultWeaponBehaviour.cpp

@@ -0,0 +1,228 @@
+#include "Systems/Weapon/AssaultWeaponBehaviour.h"
+
+void AssaultWeaponBehaviour::UpdateComponent(EntityWrapper& entity, ComponentWrapper& cWeapon, double dt)
+{
+    double& fireCooldown = cWeapon["FireCooldown"];
+    fireCooldown = glm::max(0.0, fireCooldown - dt);
+
+    WeaponBehaviour::UpdateComponent(entity, cWeapon, dt);
+}
+
+void AssaultWeaponBehaviour::UpdateWeapon(ComponentWrapper cWeapon, WeaponInfo& wi, double dt)
+{
+    // Decrement reload timer
+    double& reloadTimer = cWeapon["ReloadTimer"];
+    reloadTimer = glm::max(0.0, reloadTimer - dt);
+
+    // Start reloading automatically if at 0 mag ammo
+    int& magAmmo = cWeapon["MagazineAmmo"];
+    if (m_ConfigAutoReload && magAmmo <= 0) {
+        OnReload(cWeapon, wi);
+    }
+
+    // Handle reloading
+    bool& isReloading = cWeapon["IsReloading"];
+    if (isReloading && reloadTimer <= 0.0) {
+        int& magSize = cWeapon["MagazineSize"];
+        int& ammo = cWeapon["Ammo"];
+
+        ammo = glm::max(0, ammo - (magSize - magAmmo));
+        magAmmo = glm::min(magSize, ammo);
+        isReloading = false;
+    }    
+    
+    // Restore view angle
+    if (IsClient) {
+        float& currentTravel = cWeapon["CurrentTravel"];
+        float& returnSpeed = cWeapon["ViewReturnSpeed"];
+        if (currentTravel > 0) {
+            float change = returnSpeed * dt;
+            currentTravel = glm::max(0.f, currentTravel - change);
+            EntityWrapper camera = wi.Player.FirstChildByName("Camera");
+            if (camera.Valid()) {
+                glm::vec3& cameraOrientation = camera["Transform"]["Orientation"];
+                cameraOrientation.x -= change;
+            }
+        }
+    }
+
+    // Fire if we're able to fire
+    if (canFire(cWeapon, wi)) {
+        fireBullet(cWeapon, wi);
+    }
+}
+
+void AssaultWeaponBehaviour::OnPrimaryFire(ComponentWrapper cWeapon, WeaponInfo& wi)
+{
+    cWeapon["TriggerHeld"] = true;
+    if (canFire(cWeapon, wi)) {
+        fireBullet(cWeapon, wi);
+    }
+}
+
+void AssaultWeaponBehaviour::OnCeasePrimaryFire(ComponentWrapper cWeapon, WeaponInfo& wi)
+{
+    cWeapon["TriggerHeld"] = false;
+}
+
+void AssaultWeaponBehaviour::OnReload(ComponentWrapper cWeapon, WeaponInfo& wi)
+{
+    bool& isReloading = cWeapon["IsReloading"];
+    if (isReloading) {
+        return;
+    }
+
+    int& magAmmo = cWeapon["MagazineAmmo"];
+    int& magSize = cWeapon["MagazineSize"];
+    if (magAmmo >= magSize) {
+        return;
+    }
+    int& ammo = cWeapon["Ammo"];
+    if (ammo <= 0) {
+        return;
+    }
+
+    double reloadTime = cWeapon["ReloadTime"];
+    double& reloadTimer = cWeapon["ReloadTimer"];
+   
+    // Start reload
+    isReloading = true;
+    reloadTimer = reloadTime;
+}
+
+void AssaultWeaponBehaviour::OnHolster(ComponentWrapper cWeapon, WeaponInfo& wi)
+{
+    // Make sure the trigger is released if weapon is holstered while firing
+    cWeapon["TriggerHeld"] = false;
+
+    // Cancel any reload
+    cWeapon["IsReloading"] = false;
+    cWeapon["ReloadTimer"] = 0.0;
+}
+
+void AssaultWeaponBehaviour::fireBullet(ComponentWrapper cWeapon, WeaponInfo& wi)
+{
+    cWeapon["FireCooldown"] = 60.0 / (double)cWeapon["RPM"];
+
+    // Ammo
+    int& magAmmo = cWeapon["MagazineAmmo"];
+    if (magAmmo <= 0) {
+        return;
+    } else {
+        magAmmo -= 1;
+    }
+
+    // View punch
+    if (IsClient) {
+        EntityWrapper camera = wi.Player.FirstChildByName("Camera");
+        if (camera.Valid()) {
+            glm::vec3& cameraOrientation = camera["Transform"]["Orientation"];
+            float viewPunch = cWeapon["ViewPunch"];
+            float maxTravelAngle = cWeapon["MaxTravelAngle"];
+            float& currentTravel = cWeapon["CurrentTravel"];
+            if (currentTravel < maxTravelAngle) {
+                float change = viewPunch;
+                if (currentTravel + change > maxTravelAngle) {
+                    change = maxTravelAngle - currentTravel;
+                }
+                cameraOrientation.x += change;
+                currentTravel += change;
+            }
+        }
+    }
+
+    // Get weapon model based on current person
+    EntityWrapper weaponModelEntity = getRelevantWeaponModelEntity(wi);
+    if (!weaponModelEntity.Valid()) {
+        return;
+    }
+
+    // Tracer
+    EntityWrapper tracerSpawner = weaponModelEntity.FirstChildByName("WeaponMuzzle");
+    if (tracerSpawner.Valid()) {
+        glm::vec3 origin = Transform::AbsolutePosition(tracerSpawner);
+        glm::vec3 direction = glm::quat(Transform::AbsoluteOrientationEuler(tracerSpawner)) * glm::vec3(0, 0, -1);
+        float distance = traceRayDistance(origin, direction);
+        EntityWrapper ray = SpawnerSystem::Spawn(tracerSpawner);
+        if (ray.Valid()) {
+            ((glm::vec3&)ray["Transform"]["Scale"]).z = distance;
+        }
+    }
+
+    // Deal damage
+    if (dealDamage(cWeapon, wi)) {
+        // Show hit marker
+        EntityWrapper hitMarkerSpawner = wi.Player.FirstChildByName("HitMarkerSpawner");
+        if (hitMarkerSpawner.Valid()) {
+            SpawnerSystem::Spawn(hitMarkerSpawner, hitMarkerSpawner);
+            Events::PlaySoundOnEntity e;
+            e.EmitterID = wi.Player.ID;
+            e.FilePath = "Audio/weapon/hitclick.wav";
+            m_EventBroker->Publish(e);
+        }
+    }
+}
+
+bool AssaultWeaponBehaviour::canFire(ComponentWrapper cWeapon, WeaponInfo& wi)
+{
+    bool triggerHeld = cWeapon["TriggerHeld"];
+    bool cooldownPassed = (double)cWeapon["FireCooldown"] <= 0.0;
+    bool isReloading = cWeapon["IsReloading"];
+    return triggerHeld && cooldownPassed;
+}
+
+bool AssaultWeaponBehaviour::dealDamage(ComponentWrapper cWeapon, WeaponInfo& wi)
+{
+    // Only deal damage client side
+    if (!IsClient) {
+        return false;
+    }
+
+    // Only handle damage for the local player
+    if (wi.Player != LocalPlayer) {
+        return false;
+    }
+
+    // Make sure the player isn't shooting from the grave
+    if (!wi.Player.Valid()) {
+        return false;
+    }
+
+    // 3D-pick middle of screen
+    Rectangle viewport = m_Renderer->GetViewportSize();
+    glm::vec2 centerScreen(viewport.Width / 2, viewport.Height / 2);
+    // TODO: Some horizontal spread
+    PickData pickData = m_Renderer->Pick(centerScreen);
+    EntityWrapper victim(m_World, pickData.Entity);
+    if (!victim.Valid()) {
+        return false;
+    }
+
+    // Don't let us somehow shoot ourselves in the foot
+    if (victim == LocalPlayer) {
+        return false;
+    }
+
+    // Only care about players being hit
+    if (!victim.HasComponent("Player")) {
+        victim = victim.FirstParentWithComponent("Player");
+    }
+    if (!victim.Valid()) {
+        return false;
+    }
+
+    double damage = cWeapon["BaseDamage"];
+    // If friendly fire, reduce damage to 0 (needed to make Boosts, Ammosharing work)
+    if ((ComponentInfo::EnumType)victim["Team"]["Team"] == (ComponentInfo::EnumType)wi.Player["Team"]["Team"]) {
+        damage = 0;
+    }
+
+    // Deal damage! 
+    Events::PlayerDamage ePlayerDamage;
+    ePlayerDamage.Inflictor = wi.Player;
+    ePlayerDamage.Victim = victim;
+    ePlayerDamage.Damage = damage;
+    m_EventBroker->Publish(ePlayerDamage);
+
+    return damage > 0;
+}

src/Game/Systems/Weapon/DefenderWeaponBehaviour.cpp

@@ -10,24 +10,51 @@ void DefenderWeaponBehaviour::UpdateComponent(EntityWrapper& entity, ComponentWr
 
 void DefenderWeaponBehaviour::UpdateWeapon(ComponentWrapper cWeapon, WeaponInfo& wi, double dt)
 {
+    // Decrement reload timer
     double& reloadTimer = cWeapon["ReloadTimer"];
     reloadTimer = glm::max(0.0, reloadTimer - dt);
 
-    double reloadTime = cWeapon["ReloadTime"];
+    // Start reloading automatically if at 0 mag ammo
+    int& magAmmo = cWeapon["MagazineAmmo"];
+    if (m_ConfigAutoReload && magAmmo <= 0) {
+        OnReload(cWeapon, wi);
+    }
+
+    // Handle reloading
     bool& isReloading = cWeapon["IsReloading"];
     if (isReloading && reloadTimer <= 0.0) {
-        int& magAmmo = cWeapon["MagazineAmmo"];
+        double reloadTime = cWeapon["ReloadTime"];
         int& magSize = cWeapon["MagazineSize"];
         int& ammo = cWeapon["Ammo"];
         if (magAmmo < magSize && ammo > 0) {
             ammo -= 1;
             magAmmo += 1;
             reloadTimer = reloadTime;
+            Events::PlaySoundOnEntity e;
+            e.EmitterID = wi.Player.ID;
+            e.FilePath = "Audio/weapon/Zoom.wav";
+            m_EventBroker->Publish(e);
         } else {
             isReloading = false;
         }
     }
 
+    // Restore view angle
+    if (IsClient) {
+        float& currentTravel = cWeapon["CurrentTravel"];
+        float& returnSpeed = cWeapon["ViewReturnSpeed"];
+        if (currentTravel > 0) {
+            float change = returnSpeed * dt;
+            currentTravel = glm::max(0.f, currentTravel - change);
+            EntityWrapper camera = wi.Player.FirstChildByName("Camera");
+            if (camera.Valid()) {
+                glm::vec3& cameraOrientation = camera["Transform"]["Orientation"];
+                cameraOrientation.x -= change;
+            }
+        }
+    }
+
+    // Fire if we're able to fire
     if (canFire(cWeapon, wi)) {
         fireShell(cWeapon, wi);
     }
@@ -71,6 +98,16 @@ void DefenderWeaponBehaviour::OnReload(ComponentWrapper cWeapon, WeaponInfo& wi)
     reloadTimer = reloadTime;
 }
 
+void DefenderWeaponBehaviour::OnHolster(ComponentWrapper cWeapon, WeaponInfo& wi)
+{
+    // Make sure the trigger is released if weapon is holstered while firing
+    cWeapon["TriggerHeld"] = false;
+
+    // Cancel any reload
+    cWeapon["IsReloading"] = false;
+    cWeapon["ReloadTimer"] = 0.0;
+}
+
 bool DefenderWeaponBehaviour::OnInputCommand(ComponentWrapper cWeapon, WeaponInfo& wi, const Events::InputCommand& e)
 {
     if (e.Command == "SpecialAbility" && IsServer) {
@@ -98,7 +135,6 @@ void DefenderWeaponBehaviour::fireShell(ComponentWrapper cWeapon, WeaponInfo& wi
     // Ammo
     int& magAmmo = cWeapon["MagazineAmmo"];
     if (magAmmo <= 0) {
-        OnReload(cWeapon, wi);
         return;
     } else {
         magAmmo -= 1;
@@ -114,11 +150,29 @@ void DefenderWeaponBehaviour::fireShell(ComponentWrapper cWeapon, WeaponInfo& wi
     std::vector<glm::vec2> pelletAngles;
     for (int i = 0; i < numPellets; i++) {
         pelletAngles.push_back(glm::vec2(randomSpreadAngle(m_RandomEngine), randomSpreadAngle(m_RandomEngine)));
-        LOG_DEBUG("%f %f", pelletAngles[i].x, pelletAngles[i].y);
     }
 
     double pelletDamage = (double)cWeapon["BaseDamage"] / numPellets;
 
+    // View punch
+    if (IsClient) {
+        EntityWrapper camera = wi.Player.FirstChildByName("Camera");
+        if (camera.Valid()) {
+            glm::vec3& cameraOrientation = camera["Transform"]["Orientation"];
+            float viewPunch = cWeapon["ViewPunch"];
+            float maxTravelAngle = cWeapon["MaxTravelAngle"];
+            float& currentTravel = cWeapon["CurrentTravel"];
+            if (currentTravel < maxTravelAngle) {
+                float change = viewPunch;
+                if (currentTravel + change > maxTravelAngle) {
+                    change = maxTravelAngle - currentTravel;
+                }
+                cameraOrientation.x += change;
+                currentTravel += change;
+            }
+        }
+    }
+
     // Tracers
     EntityWrapper weaponModelEntity;
     if (wi.Player == LocalPlayer) {
@@ -140,6 +194,12 @@ void DefenderWeaponBehaviour::fireShell(ComponentWrapper cWeapon, WeaponInfo& wi
             dealDamage(cWeapon, wi, direction, pelletDamage);
         }
     }
+
+    // Sound
+    Events::PlaySoundOnEntity e;
+    e.EmitterID = wi.Player.ID;
+    e.FilePath = "Audio/weapon/Blast.wav";
+    m_EventBroker->Publish(e);
 }
 
 void DefenderWeaponBehaviour::dealDamage(ComponentWrapper cWeapon, WeaponInfo& wi, glm::vec3 direction, double damage)
@@ -206,7 +266,6 @@ bool DefenderWeaponBehaviour::canFire(ComponentWrapper cWeapon, WeaponInfo& wi)
     bool triggerHeld = cWeapon["TriggerHeld"];
     bool cooldownPassed = (double)cWeapon["FireCooldown"] <= 0.0;
     bool isNotShielding = wi.Player.ChildrenWithComponent("Shield").size() == 0;
-    // TODO: Ammo checks
     return triggerHeld && cooldownPassed && isNotShielding;
 }
 

src/Game/Systems/Weapon/SidearmWeaponBehaviour.cpp

@@ -45,8 +45,6 @@ void SidearmWeaponBehaviour::OnHolster(ComponentWrapper cWeapon, WeaponInfo& wi)
     // Cancel any reload
     cWeapon["IsReloading"] = false;
     cWeapon["ReloadTimer"] = 0.0;
-    
-    LOG_DEBUG("HOLSTER");
 }
 
 void SidearmWeaponBehaviour::fireBullet(ComponentWrapper cWeapon, WeaponInfo& wi)