Merge commit '0e8b97dbbade6bb39c6f2b8af6c1cfc43ce67cde' into ScoreBoard

# Conflicts:
#	resources/Schema/Entities/Player.xml
#	src/Game/Game.cpp

include/Engine/Core/EntityWrapper.h

@@ -27,6 +27,7 @@ struct EntityWrapper
     bool HasComponent(const std::string& componentType);
     void AttachComponent(const char* componentName);
     EntityWrapper Parent();
+    EntityWrapper FirstParentByName(const std::string& parentEntityName);
     EntityWrapper FirstChildByName(const std::string& name);
     EntityWrapper FirstParentWithComponent(const std::string& componentType);
     EntityWrapper Clone(EntityWrapper parent = EntityWrapper::Invalid);

include/Engine/Editor/EditorGUI.h

@@ -22,6 +22,7 @@
 #include "../Core/ELockMouse.h"
 #include "../Core/EFileDropped.h"
 #include "../Rendering/Texture.h"
+#include "Game/Events/ESpawnerSpawn.h"
 
 class EditorGUI
 {

include/Game/Systems/AmmunitionHUDSystem.h

@@ -1,17 +0,0 @@
-#ifndef AmmunitionHUDSystem_h__
-#define AmmunitionHUDSystem_h__
-
-#include "../../Engine/Core/System.h"
-#include "../../Engine/GLM.h"
-
-class AmmunitionHUDSystem : public ImpureSystem
-{
-public:
-    AmmunitionHUDSystem(SystemParams params)
-        : System(params)
-    { }
-
-    virtual void Update(double dt) override;
-};
-
-#endif

include/Game/Systems/TextFieldReader.h

@@ -0,0 +1,19 @@
+#ifndef AmmunitionHUDSystem_h__
+#define AmmunitionHUDSystem_h__
+
+#include <boost/lexical_cast.hpp>
+#include "../../Engine/Core/System.h"
+#include "../../Engine/GLM.h"
+
+class TextFieldReader : public PureSystem
+{
+public:
+    TextFieldReader(SystemParams params)
+        : System(params)
+        , PureSystem("TextFieldReader")
+    { }
+
+    virtual void UpdateComponent(EntityWrapper& entity, ComponentWrapper& cTextFieldReader, double dt) override;
+};
+
+#endif

include/Game/Systems/Weapon/DefenderWeaponBehaviour.h

@@ -1,7 +1,6 @@
 #include "WeaponBehaviour.h"
 #include "Collision/Collision.h"
 #include "Core/EPlayerDamage.h"
-#include "Rendering/ESetCamera.h"
 
 class DefenderWeaponBehaviour : public WeaponBehaviour<DefenderWeaponBehaviour>
 {
@@ -10,29 +9,24 @@ public:
         : System(systemParams)
         , WeaponBehaviour(systemParams, "DefenderWeapon", renderer, collisionOctree)
         , m_RandomEngine(m_RandomDevice())
-    {
-        EVENT_SUBSCRIBE_MEMBER(m_ESetCamera, &DefenderWeaponBehaviour::OnSetCamera);
-    }
+    { }
 
     void UpdateComponent(EntityWrapper& entity, ComponentWrapper& cWeapon, double dt) override;
-    void UpdateWeapon(WeaponInfo& wi, double dt) override;
-    void OnPrimaryFire(WeaponInfo& wi) override;
-    void OnCeasePrimaryFire(WeaponInfo& wi) override;
-    bool OnInputCommand(WeaponInfo& wi, const Events::InputCommand& e) override;
+    void UpdateWeapon(ComponentWrapper cWeapon, WeaponInfo& wi, double dt) override;
+    void OnPrimaryFire(ComponentWrapper cWeapon, WeaponInfo& wi) override;
+    void OnCeasePrimaryFire(ComponentWrapper cWeapon, WeaponInfo& wi) override;
+    void OnReload(ComponentWrapper cWeapon, WeaponInfo& wi) override;
+    bool OnInputCommand(ComponentWrapper cWeapon, WeaponInfo& wi, const Events::InputCommand& e) override;
 
 private:
     std::random_device m_RandomDevice;
     std::mt19937 m_RandomEngine;
-    EntityWrapper m_CurrentCamera;
-
-    EventRelay<DefenderWeaponBehaviour, Events::SetCamera> m_ESetCamera;
-    bool OnSetCamera(const Events::SetCamera& e);
 
     // Weapon functions
-    void fireShell(WeaponInfo& wi);
-    void dealDamage(WeaponInfo& wi, glm::vec3 direction, double damage);
+    void fireShell(ComponentWrapper cWeapon, WeaponInfo& wi);
+    void dealDamage(ComponentWrapper cWeapon, WeaponInfo& wi, glm::vec3 direction, double damage);
+    bool canFire(ComponentWrapper cWeapon, WeaponInfo& wi);
 
     // Utility
-    float traceRayDistance(glm::vec3 origin, glm::vec3 direction);
     Camera cameraFromEntity(EntityWrapper camera);
 };

include/Game/Systems/Weapon/SidearmWeaponBehaviour.h

@@ -0,0 +1,33 @@
+#include "WeaponBehaviour.h"
+#include "Collision/Collision.h"
+#include "Core/EPlayerDamage.h"
+
+class SidearmWeaponBehaviour : public WeaponBehaviour<SidearmWeaponBehaviour>
+{
+public:
+    SidearmWeaponBehaviour(SystemParams systemParams, IRenderer* renderer, Octree<EntityAABB>* collisionOctree)
+        : System(systemParams)
+        , WeaponBehaviour(systemParams, "SidearmWeapon", renderer, collisionOctree)
+        , m_RandomEngine(m_RandomDevice())
+    { }
+
+    void UpdateComponent(EntityWrapper& entity, ComponentWrapper& cWeapon, double dt) override;
+    void UpdateWeapon(ComponentWrapper cWeapon, WeaponInfo& wi, double dt) override;
+    void OnPrimaryFire(ComponentWrapper cWeapon, WeaponInfo& wi) override;
+    void OnCeasePrimaryFire(ComponentWrapper cWeapon, WeaponInfo& wi) override;
+    void OnEquip(ComponentWrapper cWeapon, WeaponInfo& wi) override;
+    void OnHolster(ComponentWrapper cWeapon, WeaponInfo& wi) override;
+
+private:
+    std::random_device m_RandomDevice;
+    std::mt19937 m_RandomEngine;
+
+    // Weapon functions
+    void fireBullet(ComponentWrapper cWeapon, WeaponInfo& wi);
+    //void dealDamage(WeaponInfo& wi, glm::vec3 direction, double damage);
+
+    // Utility
+    bool canFire(ComponentWrapper cWeapon);
+    bool playerInFirstPerson(EntityWrapper player);
+    //float traceRayDistance(glm::vec3 origin, glm::vec3 direction);
+};

include/Game/Systems/Weapon/WeaponBehaviour.h

@@ -7,6 +7,7 @@
 #include "Collision/EntityAABB.h"
 #include "Input/EInputCommand.h"
 #include "Systems/SpawnerSystem.h"
+#include "Rendering/ESetCamera.h"
 
 template <typename ETYPE>
 class WeaponBehaviour : public PureSystem
@@ -21,41 +22,81 @@ public:
         , m_CollisionOctree(collisionOctree)
     {
         EVENT_SUBSCRIBE_MEMBER(m_EInputCommand, &WeaponBehaviour::_OnInputCommand)
+        EVENT_SUBSCRIBE_MEMBER(m_ESetCamera, &WeaponBehaviour::_OnSetCamera)
     }
     virtual ~WeaponBehaviour() = default;
 
-    virtual void UpdateComponent(EntityWrapper& entity, ComponentWrapper& component, double dt) override
+    virtual void UpdateComponent(EntityWrapper& entity, ComponentWrapper& cWeapon, double dt) override
     {
         auto weapon = getActiveWeapon(entity);
         if (!weapon) {
             return;
         } else {
-            UpdateWeapon(*weapon, dt);
+            UpdateWeapon(cWeapon, *weapon, dt);
         }
     }
 
 protected:
     struct WeaponInfo
     {
-        std::string WeaponComponent;
         EntityWrapper Player;
         EntityWrapper WeaponEntity;
         EntityWrapper FirstPersonEntity;
         EntityWrapper ThirdPersonEntity;
-        ComponentWrapper GetComponent() { return WeaponEntity[WeaponComponent]; }
     };
 
     IRenderer* m_Renderer;
+    EntityWrapper m_CurrentCamera;
     Octree<EntityAABB>* m_CollisionOctree;
     std::unordered_map<EntityWrapper, WeaponInfo> m_ActiveWeapons;
 
-    virtual void UpdateWeapon(WeaponInfo& wi, double dt) { }
-    virtual void OnPrimaryFire(WeaponInfo& wi) { }
-    virtual void OnCeasePrimaryFire(WeaponInfo& wi) { }
-    virtual void OnReload(WeaponInfo& wi) { }
-    virtual bool OnInputCommand(WeaponInfo& wi, const Events::InputCommand& e) { return false; }
+    virtual void UpdateWeapon(ComponentWrapper cWeapon, WeaponInfo& wi, double dt) { }
+    virtual void OnPrimaryFire(ComponentWrapper cWeapon, WeaponInfo& wi) { }
+    virtual void OnCeasePrimaryFire(ComponentWrapper cWeapon, WeaponInfo& wi) { }
+    virtual void OnReload(ComponentWrapper cWeapon, WeaponInfo& wi) { }
+    virtual void OnEquip(ComponentWrapper cWeapon, WeaponInfo& wi) { }
+    virtual void OnHolster(ComponentWrapper cWeapon, WeaponInfo& wi) { }
+    virtual bool OnInputCommand(ComponentWrapper cWeapon, WeaponInfo& wi, const Events::InputCommand& e) { return false; }
+
+    bool isPlayerInFirstPerson(EntityWrapper player)
+    {
+        if (!m_CurrentCamera.Valid()) {
+            return false;
+        } else {
+            return m_CurrentCamera == player || m_CurrentCamera.IsChildOf(player);
+        }
+    }
+
+    // Returns wi.FirstPersonEntity or wi.ThirdPersonEntity depending on
+    // if the player is in first person mode or not.
+    EntityWrapper getRelevantWeaponModelEntity(WeaponInfo& wi)
+    {
+        if (isPlayerInFirstPerson(wi.Player)) {
+            return wi.FirstPersonEntity;
+        } else {
+            return wi.ThirdPersonEntity;
+        }
+    }
+
+    float traceRayDistance(glm::vec3 origin, glm::vec3 direction)
+    {
+        float distance;
+        glm::vec3 pos;
+        auto entity = Collision::EntityFirstHitByRay(Ray(origin, direction), m_CollisionOctree, distance, pos);
+        if (entity) {
+            return distance;
+        } else {
+            return 100.f;
+        }
+    }
 
 private:
+    EventRelay<ETYPE, Events::SetCamera> m_ESetCamera;
+    bool _OnSetCamera(const Events::SetCamera& e)
+    {
+        m_CurrentCamera = e.CameraEntity;
+        return true;
+    }
     EventRelay<ETYPE, Events::InputCommand> m_EInputCommand;
     bool _OnInputCommand(const Events::InputCommand& e)
     {
@@ -70,15 +111,19 @@ private:
         }
 
         // Make sure the player has this weapon
-        auto weapon = getWeaponComponent(player);
-        if (!weapon) {
+        auto cWeapon = getWeaponComponent(player);
+        if (!cWeapon) {
             return false;
         }
 
         // Weapon selection
         if (e.Command == "SelectWeapon") {
-            if (static_cast<ComponentInfo::EnumType>(e.Value) == static_cast<ComponentInfo::EnumType>((*weapon)["Slot"])) {
-                selectWeapon(player);
+            if (e.Value > 0) {
+                if (static_cast<ComponentInfo::EnumType>(e.Value) == static_cast<ComponentInfo::EnumType>((*cWeapon)["Slot"])) {
+                    selectWeapon(*cWeapon, player);
+                } else {
+                    holsterWeapon(*cWeapon, player);
+                }
             }
         }
 
@@ -91,18 +136,18 @@ private:
         // Fire
         if (e.Command == "PrimaryFire") {
             if (e.Value > 0) {
-                OnPrimaryFire(*activeWeapon);
+                OnPrimaryFire(*cWeapon, *activeWeapon);
             } else {
-                OnCeasePrimaryFire(*activeWeapon);
+                OnCeasePrimaryFire(*cWeapon, *activeWeapon);
             }
         }
 
         // Reload
         if (e.Command == "Reload" && e.Value != 0) {
-            OnReload(*activeWeapon);
+            OnReload(*cWeapon, *activeWeapon);
         }
 
-        return OnInputCommand(*activeWeapon, e);
+        return OnInputCommand(*cWeapon, *activeWeapon, e);
     }
 
     boost::optional<ComponentWrapper> getWeaponComponent(EntityWrapper player)
@@ -129,8 +174,13 @@ private:
         return activeWeapon;
     }
 
-    void selectWeapon(EntityWrapper player)
+    void selectWeapon(ComponentWrapper cWeapon, EntityWrapper player)
     {
+        // Don't reselect weapon if it's already active
+        if (getActiveWeapon(player)) {
+            return;
+        }
+
         // Find the weapon attachments matching the weapon type
         std::vector<EntityWrapper> weaponAttachments = player.ChildrenWithComponent("WeaponAttachment");
         EntityWrapper firstPersonAttachment;
@@ -152,14 +202,6 @@ private:
             return;
         }
 
-        // Purge other weapon entities
-        for (auto& attachment : weaponAttachments) {
-            //if (attachment == firstPersonAttachment || attachment == thirdPersonAttachment) {
-            //    continue;
-            //}
-            attachment.DeleteChildren();
-        }
-
         // Spawn the weapon(s)
         EntityWrapper firstPersonWeapon;
         EntityWrapper thirdPersonWeapon;
@@ -170,11 +212,36 @@ private:
             thirdPersonWeapon = SpawnerSystem::Spawn(thirdPersonAttachment, thirdPersonAttachment);
         }
 
-        m_ActiveWeapons[player].WeaponComponent = m_ComponentType;
-        m_ActiveWeapons[player].Player = player;
-        m_ActiveWeapons[player].WeaponEntity = player;
-        m_ActiveWeapons[player].FirstPersonEntity = firstPersonWeapon;
-        m_ActiveWeapons[player].ThirdPersonEntity = thirdPersonWeapon;
+        WeaponInfo& wi = m_ActiveWeapons[player];
+        wi.Player = player;
+        wi.WeaponEntity = player;
+        wi.FirstPersonEntity = firstPersonWeapon;
+        wi.ThirdPersonEntity = thirdPersonWeapon;
+        
+        OnEquip(cWeapon, wi);
+    }
+
+    void holsterWeapon(ComponentWrapper cWeapon, EntityWrapper player)
+    {
+        auto activeWeapon = getActiveWeapon(player);
+        if (!activeWeapon) {
+            return;
+        }
+        WeaponInfo& wi = *activeWeapon;
+
+        // Send holster event
+        OnHolster(cWeapon, wi);
+
+        // Delete weapon entities
+        if (wi.FirstPersonEntity.Valid()) {
+            m_World->DeleteEntity(wi.FirstPersonEntity.ID);
+        }
+        if (wi.ThirdPersonEntity.Valid()) {
+            m_World->DeleteEntity(wi.ThirdPersonEntity.ID);
+        }
+
+        // Make weapon inactive
+        m_ActiveWeapons.erase(player);
     }
 };