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

# Conflicts:
#	include/Engine/Collision/CollidableOctreeSystem.h
#	include/Engine/Collision/CollisionSystem.h
#	include/Engine/Collision/TriggerSystem.h
#	include/Engine/Rendering/RenderSystem.h
#	include/Game/Systems/PlayerSystem.h
#	resources/Schema/Components/Physics.xsd
#	resources/Schema/Types/Entity.xsd
#	src/Engine/Rendering/RenderSystem.cpp
#	src/Engine/Rendering/Renderer.cpp
#	src/Game/Game.cpp
#	src/Game/Systems/HealthSystem.cpp
#	src/Game/Systems/PlayerSystem.cpp
#	src/Tests/OctTreeTestGameClass.cpp

include/Game/Systems/CapturePointSystem.h

@@ -0,0 +1,55 @@
+#ifndef CapturePointSystem_h__
+#define CapturePointSystem_h__
+
+#include <GLFW/glfw3.h>
+#include <glm/common.hpp>
+
+#include "Common.h"
+#include "Core/System.h"
+#include "Engine/Collision/ETrigger.h"
+#include "Core/ECaptured.h"
+#include "Core/EWin.h"
+
+#include <tuple>
+#include <vector>
+
+class CapturePointSystem : public PureSystem
+{
+public:
+    //WARNING: on new map, destroy all info in the vectors, as well as reset all variables (just make new?)
+    CapturePointSystem(World* world, EventBroker* eventBroker);
+
+    //updatecomponent
+    virtual void UpdateComponent(EntityWrapper& entity, ComponentWrapper& capturePoint, double dt) override;
+
+private:
+    //methods which will take care of specific events
+    EventRelay<CapturePointSystem, Events::TriggerTouch> m_ETriggerTouch;
+    bool CapturePointSystem::OnTriggerTouch(const Events::TriggerTouch& e);
+    EventRelay<CapturePointSystem, Events::TriggerLeave> m_ETriggerLeave;
+    bool CapturePointSystem::OnTriggerLeave(const Events::TriggerLeave& e);
+    EventRelay<CapturePointSystem, Events::Captured> m_ECaptured;
+    bool CapturePointSystem::OnCaptured(const Events::Captured& e);
+
+    bool m_WinnerWasFound = false;
+    //need to track these variables for the captureSystem to work as per design!
+    const int m_NotACapturePoint = 999;
+    int m_RedTeamNextPossibleCapturePoint = m_NotACapturePoint;
+    int m_BlueTeamNextPossibleCapturePoint = m_NotACapturePoint;
+    int m_RedTeamHomeCapturePoint = m_NotACapturePoint;
+    int m_BlueTeamHomeCapturePoint = m_NotACapturePoint;
+
+    int m_NumberOfCapturePoints = 0;
+    std::map<int, EntityID> m_CapturePointNumberToEntityIDMap;
+
+    //std::vector<ComponentWrapper>
+
+    const double m_CaptureTimeToTakeOver = 15.0;
+    bool m_ResetTimers = false;
+
+    //vectors which will keep track of enter/leave changes
+    std::vector<std::tuple<EntityID, EntityID>> m_ETriggerTouchVector;
+    std::vector<std::tuple<EntityID, EntityID>> m_ETriggerLeaveVector;
+};
+
+#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(World* world, EventBroker* eventBroker)
+        : System(world, eventBroker)
+        , PureSystem("Transform")
+    {
+        EVENT_SUBSCRIBE_MEMBER(m_EInterpolate, &InterpolationSystem::OnInterpolate);
+    }
+    ~InterpolationSystem() { }
+    virtual void UpdateComponent(EntityWrapper& entity, ComponentWrapper& transform, double dt) override;
+private:
+    std::unordered_map<EntityID, Transform> m_NextTransform;
+    std::unordered_map<EntityID, Transform> m_LastReceivedTransform;
+
+    //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/PlayerSystem.h

@@ -1,34 +0,0 @@
-#ifndef PlayerSystem_h__
-#define PlayerSystem_h__
-
-#include <GLFW/glfw3.h>
-#include <glm/common.hpp>
-
-#include "Common.h"
-#include "Core/System.h"
-#include "Collision/ETrigger.h"
-
-class PlayerSystem : public PureSystem
-{
-public:
-    PlayerSystem(World* world, EventBroker* eventBroker)
-        : System(world, eventBroker)
-        , PureSystem("Player")
-    {
-        EVENT_SUBSCRIBE_MEMBER(m_ETouch, &PlayerSystem::OnTouch);
-        EVENT_SUBSCRIBE_MEMBER(m_EEnter, &PlayerSystem::OnEnter);
-        EVENT_SUBSCRIBE_MEMBER(m_ELeave, &PlayerSystem::OnLeave);
-    }
-
-    virtual void UpdateComponent(EntityWrapper& entity, ComponentWrapper& component, double dt) override;
-private:
-    float m_Speed = 5;
-    EventRelay<PlayerSystem, Events::TriggerEnter> m_EEnter;
-    bool OnEnter(const Events::TriggerEnter &event);
-    EventRelay<PlayerSystem, Events::TriggerTouch> m_ETouch;
-    bool PlayerSystem::OnTouch(const Events::TriggerTouch &event);
-    EventRelay<PlayerSystem, Events::TriggerLeave> m_ELeave;
-    bool PlayerSystem::OnLeave(const Events::TriggerLeave &event);
-};
-
-#endif