Merge. Also fixed interpolation for scale and rotation.

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

# Conflicts:
#	include/Game/Game.h
#	src/Game/CMakeLists.txt
#	src/Game/Game.cpp

include/Game/Systems/HealthSystem.h

@@ -0,0 +1,36 @@
+#ifndef HealthSystem_h__
+#define HealthSystem_h__
+
+#include <GLFW/glfw3.h>
+#include <glm/common.hpp>
+
+#include "Common.h"
+#include "Core/System.h"
+#include "Core/EPlayerDamage.h"
+#include "Core/EPlayerHealthPickup.h"
+#include "Core/EPlayerDeath.h"
+
+#include <tuple>
+#include <vector>
+
+class HealthSystem : public PureSystem
+{
+public:
+    HealthSystem(EventBroker* eventBroker);
+
+    //updatecomponent
+    virtual void UpdateComponent(World* world, EntityWrapper& entity, ComponentWrapper& component, double dt) override;
+
+private:
+    //methods which will take care of specific events
+    EventRelay<HealthSystem, Events::PlayerDamage> m_EPlayerDamage;
+    bool HealthSystem::OnPlayerDamaged(const Events::PlayerDamage& e);
+    EventRelay<HealthSystem, Events::PlayerHealthPickup> m_EPlayerHealthPickup;
+    bool HealthSystem::OnPlayerHealthPickup(const Events::PlayerHealthPickup& e);
+
+    //vector which will keep track of health changes
+    std::vector<std::tuple<EntityID, double>> m_DeltaHealthVector;
+   
+};
+
+#endif

include/Game/Systems/InterpolationSystem.h

@@ -0,0 +1,53 @@
+#ifndef Systems_InterpolationSystem_h__
+#define Systems_InterpolationSystem_h__
+
+#include <queue>
+#include <unordered_map>
+#include <boost/shared_array.hpp>
+#include <glm/common.hpp>
+#include <glm/gtc/quaternion.hpp>
+
+#include "Common.h"
+#include "Core/System.h"
+#include "Core/EventBroker.h"
+
+#include "Network/EInterpolate.h"
+
+#define SNAPSHOTINTERVAL 0.05f
+
+class InterpolationSystem : public PureSystem
+{
+    struct Transform 
+    {
+        glm::vec3 Position;
+        glm::vec3 Scale;
+        glm::quat Orientation;
+        double interpolationTime;
+    };
+public:
+    InterpolationSystem(EventBroker* eventBroker)
+        : System(eventBroker)
+        , PureSystem("Transform")
+    {
+        EVENT_SUBSCRIBE_MEMBER(m_EInterpolate, &InterpolationSystem::OnInterpolate);
+    }
+    ~InterpolationSystem() { }
+    virtual void UpdateComponent(World* world, EntityWrapper& entity, ComponentWrapper& transform, double dt) override;
+private:
+    //std::unordered_map<EntityID, std::queue<Transform>> m_InterpolationPoints;
+    std::unordered_map<EntityID, Transform> m_InterpolationPoints;
+
+    //glm::vec3 vectorInterpolation(glm::vec3 prev, glm::vec3 next, double currentTime);
+    template <typename T>
+    T vectorInterpolation(T prev, T next, double currentTime)
+    {
+        T difference = next - prev;
+        T vector = (difference / SNAPSHOTINTERVAL) * static_cast<float>(currentTime);
+        return vector;
+    }
+
+    EventRelay<InterpolationSystem, Events::Interpolate> m_EInterpolate;
+    bool InterpolationSystem::OnInterpolate(const Events::Interpolate& e);
+};
+
+#endif

include/Game/Systems/PlayerMovementSystem.h

@@ -0,0 +1,14 @@
+#include "Common.h"
+#include "GLM.h"
+#include "Core/System.h"
+
+class PlayerMovementSystem : public PureSystem
+{
+public:
+    PlayerMovementSystem(EventBroker* eventBroker)
+        : System(eventBroker)
+        , PureSystem("Player")
+    { }
+
+    virtual void UpdateComponent(World* world, EntityWrapper& entity, ComponentWrapper& component, double dt);
+};

include/Game/Systems/PlayerSpawnSystem.h

@@ -0,0 +1,18 @@
+#include "Core/System.h"
+#include "Input/EInputCommand.h"
+#include "Systems/SpawnerSystem.h"
+#include "Events/ESpawnerSpawn.h"
+
+class PlayerSpawnSystem : public ImpureSystem
+{
+public:
+    PlayerSpawnSystem(EventBroker* eventBroker);
+
+    virtual void Update(World* world, double dt) override;
+
+private:
+    EventRelay<PlayerSpawnSystem, Events::InputCommand> m_OnInputCommand;
+    bool OnInputCommand(const Events::InputCommand& e);
+
+    std::vector<int> m_SpawnRequests;
+};

include/Game/Systems/RaptorCopterSystem.h

@@ -0,0 +1,17 @@
+#include "Common.h"
+#include "Core/System.h"
+
+class RaptorCopterSystem : public PureSystem
+{
+public:
+    RaptorCopterSystem(EventBroker* eventBroker)
+        : System(eventBroker)
+        , PureSystem("RaptorCopter")
+    { }
+
+    virtual void UpdateComponent(World* world, EntityWrapper& entity, ComponentWrapper& component, double dt) override
+    {
+        ComponentWrapper& transform = world->GetComponent(component.EntityID, "Transform");
+        (glm::vec3&)transform["Orientation"] += (float)(double)component["Speed"] * (float)dt * (glm::vec3)component["Axis"];
+    }
+};

include/Game/Systems/SpawnerSystem.h

@@ -0,0 +1,25 @@
+#ifndef SpawnerSystem_h__
+#define SpawnerSystem_h__
+
+#include <random>
+#include "Common.h"
+#include "GLM.h"
+#include "Core/System.h"
+#include "Events/ESpawnerSpawn.h"
+#include "Core/Transform.h"
+#include "Core/ResourceManager.h"
+#include "Core/EntityFileParser.h"
+
+class SpawnerSystem : public System
+{
+public:
+    SpawnerSystem(EventBroker* eventBroker);
+
+    static EntityWrapper Spawn(EntityWrapper spawner, EntityWrapper parent = EntityWrapper::Invalid);
+
+private:
+    EventRelay<SpawnerSystem, Events::SpawnerSpawn> m_OnSpawnerSpawn;
+    bool OnSpawnerSpawn(Events::SpawnerSpawn& e);
+};
+
+#endif