Merge branch 'Rendering' into TextRendering

# Conflicts:
#	include/Engine/Rendering/RenderQueue.h
#	include/Engine/Rendering/RenderQueueFactory.h
#	include/Engine/Rendering/Renderer.h
#	include/Engine/Rendering/ShaderProgram.h
#	include/Game/Game.h
#	resources/Schema/Components.xsd
#	resources/Schema/Entities/Test.xml
#	resources/Schema/Types/Entity.xsd
#	src/Engine/Rendering/RenderQueueFactory.cpp
#	src/Engine/Rendering/Renderer.cpp
#	src/Game/Game.cpp

include/Game/Game.h

@@ -8,13 +8,27 @@
 #include "Core/InputManager.h"
 #include "GUI/Frame.h"
 #include "Core/World.h"
-#include "Rendering/RenderQueueFactory.h"
+#include "Input/InputProxy.h"
+#include "Input/KeyboardInputHandler.h"
+#include "Input/MouseInputHandler.h"
 #include "Core/EKeyDown.h"
-#include "Core/EntityXMLFile.h"
+#include "Core/EntityFilePreprocessor.h"
 #include "Core/SystemPipeline.h"
 #include "RaptorCopterSystem.h"
+#include "PlayerSystem.h"
+#include "Editor/EditorSystem.h"
+#include "Core/EntityFile.h"
+#include "Rendering/RenderSystem.h"
+#include "Core/EntityFileParser.h"
 #include "Rendering/Font.h"
 
+// Network
+#include <boost/thread.hpp>
+#include "Network/Network.h"
+#include "Network/Server.h"
+#include "Network/Client.h"
+
+
 class Game
 {
 public:
@@ -30,16 +44,26 @@ private:
 	EventBroker* m_EventBroker;
 	IRenderer* m_Renderer;
 	InputManager* m_InputManager;
+    InputProxy* m_InputProxy;
 	GUI::Frame* m_FrameStack;
     World* m_World;
     SystemPipeline* m_SystemPipeline;
-    RenderQueueFactory* m_RenderQueueFactory;
+    RenderFrame* m_RenderFrame;
+    // Network variables
+    boost::thread m_NetworkThread;
 
-    EventRelay<Game, Events::KeyUp> m_EKeyUp;
-    bool testOnKeyUp(const Events::KeyUp& e);
+    // Network methods
+    void networkFunction();
+    Network* m_ClientOrServer;
+    bool m_IsClientOrServer = false;
+
+    EventRelay<Game, Events::InputCommand> m_EInputCommand;
+    bool debugOnInputCommand(const Events::InputCommand& e);
+
+    void debugInitialize();
+    void debugTick(double dt);
+	EventRelay<Client, Events::KeyDown> m_EKeyDown;
 
-    void testIntialize();
-    void testTick(double dt);
 };
 
 #endif

include/Game/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, ComponentWrapper& health, 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/PlayerSystem.h

@@ -0,0 +1,33 @@
+#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(EventBroker* eventBroker)
+        : PureSystem(eventBroker, "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(World* world, ComponentWrapper& player, 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

include/Game/RaptorCopterSystem.h

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