Have fix the resizing errors

include/Engine/Core/EAmmoPickup.h

@@ -0,0 +1,18 @@
+#ifndef EAmmoPickup_h__
+#define EAmmoPickup_h__
+
+#include "EventBroker.h"
+#include "../Core/EntityWrapper.h"
+
+namespace Events
+{
+
+    struct AmmoPickup : Event
+    {
+        EntityWrapper Player;
+        int AmmoGain;
+    };
+
+}
+
+#endif

include/Engine/Core/ECaptured.h

@@ -1,13 +1,14 @@
 #ifndef ECaptured_h__
 #define ECaptured_h__
 
-#include "Core/EventBroker.h"
-#include "Core/Entity.h"
+#include "EventBroker.h"
+#include "../Core/Entity.h"
+#include "Engine/GLM.h"
 
 namespace Events
 {
 
-//triggers when a capturePoint has been taken over
+    //triggers when a capturePoint has been taken over
 struct Captured : Event
 {
     int TeamNumberThatCapturedCapturePoint;

include/Engine/Core/EPlayerHealthPickup.h

@@ -0,0 +1,18 @@
+#ifndef EPlayerHealthPickup_h__
+#define EPlayerHealthPickup_h__
+
+#include "EventBroker.h"
+#include "../Core/EntityWrapper.h"
+
+namespace Events
+{
+
+    struct PlayerHealthPickup : Event
+    {
+        EntityWrapper Player;
+        double HealthAmount;
+    };
+
+}
+
+#endif

include/Engine/Core/EWin.h

@@ -0,0 +1,20 @@
+#ifndef EWin_h__
+#define EWin_h__
+
+#include "EventBroker.h"
+#include "../Core/Entity.h"
+#include "Engine/GLM.h"
+
+namespace Events
+{
+
+    //triggers when a team has captured all capturePoints
+struct Win : Event
+{
+    //can be 0 = none, 1,2
+    int TeamThatWon;
+};
+
+}
+
+#endif

include/Engine/Core/EntitySystem.h

@@ -1,19 +0,0 @@
-#ifndef EntitySystem_h__
-#define EntitySystem_h__
-
-#include "World.h"
-#include "SystemPipeline.h"
-
-// An "EntitySystem" is defined as the combination of a World with a SystemPipeline
-template <typename WorldType>
-class EntitySystem : public WorldType, public SystemPipeline
-{
-    static_assert(std::is_base_of<World, WorldType>::value, "WorldType must inherit from World");
-public:
-    EntitySystem(EventBroker* eventBroker, bool isClient, bool isServer)
-        : WorldType(eventBroker)
-        , SystemPipeline(this, eventBroker, isClient, isServer)
-    { }
-};
-
-#endif

include/Engine/Rendering/SSAOPass.h

@@ -14,11 +14,14 @@ class SSAOPass
 {
 public:
 	SSAOPass(IRenderer* rendere);
-	~SSAOPass() { };
+	~SSAOPass() { 
+		delete m_DrawBloomPass;
+	};
 
 	void Draw(GLuint depthBuffer, Camera* camera);
 	void Setting(float radius, float bias, float contrast, float intensityScale, int numOfSamples, int NumOfTurns);
 	void ClearBuffer();
+	void OnWindowResize();
 
 	//Return the SSAO of the texture sent to Draw
 	GLuint SSAOTexture() const { return m_DrawBloomPass->GaussianTexture(); }
@@ -31,7 +34,6 @@ private:
 
 	void GenerateTexture(GLuint* texture, GLenum wrapping, GLenum filtering, glm::vec2 dimensions, GLint internalFormat, GLint format, GLenum type) const;
 
-	void ComputeAO(GLuint depthBuffer, Camera* camera);
 	//void blurHorizontal(GLuint depthBuffer);
 	//void blurVertical(GLuint depthBuffer);
 

include/Game/CapturePointsEntitySystem.h

@@ -1,18 +0,0 @@
-#include "Core/EntitySystem.h"
-#include "Rendering/IRenderer.h"
-#include "Core/Octree.h"
-#include "Collision/EntityAABB.h"
-
-class CapturePointsEntitySystem : public EntitySystem<World>
-{
-public:
-    CapturePointsEntitySystem(EventBroker* eventBroker, bool isClient, bool isServer, IRenderer* renderer, RenderFrame* renderFrame);
-    ~CapturePointsEntitySystem();
-
-private:
-    IRenderer* m_Renderer;
-    RenderFrame* m_RenderFrame;
-    Octree<EntityAABB>* m_OctreeCollision = nullptr;
-    Octree<EntityAABB>* m_OctreeTrigger = nullptr;
-    Octree<EntityAABB>* m_OctreeFrustrumCulling = nullptr;
-};

include/Game/Events/EAmmoPickup.h

@@ -1,18 +0,0 @@
-#ifndef EAmmoPickup_h__
-#define EAmmoPickup_h__
-
-#include "Core/EventBroker.h"
-#include "Core/EntityWrapper.h"
-
-namespace Events
-{
-
-struct AmmoPickup : Event
-{
-    EntityWrapper Player;
-    int AmmoGain;
-};
-
-}
-
-#endif

include/Game/Events/EGameEnd.h

@@ -1,16 +0,0 @@
-#ifndef EGameEnd_h__
-#define EGameEnd_h__
-
-#include "Core/Event.h"
-
-namespace Events
-{
-
-struct GameEnd : Event
-{
-
-};
-
-}
-
-#endif

include/Game/Events/EGameStart.h

@@ -1,16 +0,0 @@
-#ifndef EGameStart_h__
-#define EGameStart_h__
-
-#include "Core/Event.h"
-
-namespace Events
-{
-
-struct GameStart : Event
-{
-
-};
-
-}
-
-#endif

include/Game/Events/EPlayerHealthPickup.h

@@ -1,18 +0,0 @@
-#ifndef EPlayerHealthPickup_h__
-#define EPlayerHealthPickup_h__
-
-#include "Core/EventBroker.h"
-#include "Core/EntityWrapper.h"
-
-namespace Events
-{
-
-struct PlayerHealthPickup : Event
-{
-    EntityWrapper Player;
-    double HealthAmount;
-};
-
-}
-
-#endif

include/Game/Events/EWin.h

@@ -1,19 +0,0 @@
-#ifndef EWin_h__
-#define EWin_h__
-
-#include "Core/EventBroker.h"
-#include "Core/Entity.h"
-
-namespace Events
-{
-
-//triggers when a team has captured all capturePoints
-struct Win : Event
-{
-    // The winning team corresponding to TeamEnum
-    ComponentInfo::EnumType Team;
-};
-
-}
-
-#endif

include/Game/Game.h

@@ -12,16 +12,18 @@
 #include "Input/InputProxy.h"
 #include "Input/KeyboardInputHandler.h"
 #include "Input/MouseInputHandler.h"
+#include "Core/EKeyDown.h"
 #include "Core/EntityFilePreprocessor.h"
-#include "Core/EntitySystem.h"
+#include "Core/SystemPipeline.h"
 #include "Systems/ExplosionEffectSystem.h"
 #include "Editor/EditorSystem.h"
 #include "Core/EntityFile.h"
+#include "Rendering/RenderSystem.h"
 #include "Core/EntityFileParser.h"
 #include "Core/Octree.h"
 #include "Rendering/Font.h"
+#include "Systems/InterpolationSystem.h"
 #include "Collision/EntityAABB.h"
-
 // Network
 #include <boost/thread.hpp>
 #include "Network/Network.h"
@@ -53,7 +55,11 @@ private:
 	IRenderer* m_Renderer;
 	InputManager* m_InputManager;
     InputProxy* m_InputProxy;
-    EntitySystem<World>* m_EntitySystem;
+    World* m_World;
+    Octree<EntityAABB>* m_OctreeCollision;
+    Octree<EntityAABB>* m_OctreeTrigger;
+    Octree<EntityAABB>* m_OctreeFrustrumCulling;
+    SystemPipeline* m_SystemPipeline;
     RenderFrame* m_RenderFrame;
     Client* m_NetworkClient = nullptr;
     Server* m_NetworkServer = nullptr;

include/Game/Systems/AmmoPickupSystem.h

@@ -5,8 +5,8 @@
 #include "Core/Transform.h"
 #include "Core/ResourceManager.h"
 #include "Core/EntityFileParser.h"
-#include "Events/EPickupSpawned.h"
-#include "Events/EAmmoPickup.h"
+#include "Core/EPickupSpawned.h"
+#include "Core/EAmmoPickup.h"
 #include "Engine/Collision/ETrigger.h"
 #include "Common.h"
 

include/Game/Systems/CapturePointSystem.h

@@ -7,7 +7,8 @@
 #include "Common.h"
 #include "Core/System.h"
 #include "Engine/Collision/ETrigger.h"
-#include "Events/ECaptured.h"
+#include "Core/ECaptured.h"
+#include "Core/EWin.h"
 
 #include <tuple>
 #include <vector>

include/Game/Systems/CapturePointsGamemode.h

@@ -1,27 +0,0 @@
-#include "Core/System.h"
-#include "Events/EGameStart.h"
-#include "Events/EGameEnd.h"
-#include "Events/ECaptured.h"
-#include "Events/EWin.h"
-
-class CapturePointsGamemode : public ImpureSystem
-{
-public:
-    CapturePointsGamemode(SystemParams params);
-
-    virtual void Update(double dt) override;
-
-private:
-    bool m_GameRuning = false;
-    double m_GameTime = 0.0;
-
-    EventRelay<CapturePointsGamemode, Events::GameStart> m_EGameStart;
-    bool OnGameStart(const Events::GameStart& e);
-    EventRelay<CapturePointsGamemode, Events::Captured> m_ECaptured;
-    bool OnCaptured(const Events::Captured& e);
-
-    boost::optional<ComponentWrapper> currentGamemode();
-    bool isCurrentGamemode();
-    boost::optional<ComponentInfo::EnumType> winCondition();
-    void setRunning(bool running);
-};

include/Game/Systems/HealthSystem.h

@@ -7,8 +7,8 @@
 #include "Common.h"
 #include "Core/System.h"
 #include "Core/EPlayerDamage.h"
+#include "Core/EPlayerHealthPickup.h"
 #include "Core/EPlayerDeath.h"
-#include "Events/EPlayerHealthPickup.h"
 #include "Core/ConfigFile.h"
 #include "Input/EInputCommand.h"
 

include/Game/Systems/PickupSpawnSystem.h

@@ -5,8 +5,8 @@
 #include "Core/Transform.h"
 #include "Core/ResourceManager.h"
 #include "Core/EntityFileParser.h"
-#include "Events/EPickupSpawned.h"
-#include "Events/EPlayerHealthPickup.h"
+#include "Core/EPickupSpawned.h"
+#include "Core/EPlayerHealthPickup.h"
 #include "Engine/Collision/ETrigger.h"
 #include "Common.h"
 #include <tuple>

include/Game/Systems/SoundSystem.h

@@ -13,10 +13,10 @@
 #include "../Engine/Core/EShoot.h"
 #include "../Engine/Core/EPlayerSpawned.h"
 #include "../Engine/Input/EInputCommand.h"
-#include "Events/ECaptured.h"
+#include "../Engine/Core/ECaptured.h"
 #include "../Engine/Core/EPlayerDamage.h"
 #include "../Engine/Core/EPlayerDeath.h"
-#include "Events/EPlayerHealthPickup.h"
+#include "../Engine/Core/EPlayerHealthPickup.h"
 #include "../Engine/Collision/ETrigger.h"
 #include "../Engine/Sound/EPlaySoundOnEntity.h"
 #include "../Engine/Sound/EPlayBackgroundMusic.h"

resources/Schema/Components.xsd

@@ -45,5 +45,4 @@
 	<xs:include schemaLocation="Components/KillFeed.xsd"/>
 	<xs:include schemaLocation="Components/Page.xsd"/>
 	<xs:include schemaLocation="Components/Button.xsd"/>
-	<xs:include schemaLocation="Components/Gamemode.xsd"/>
 </xs:schema>

resources/Schema/Components/Gamemode.xml

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
-<Gamemode xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="Gamemode.xsd">
-	<Gamemode><CapturePoints/></Gamemode>
-	<RoundTime>0</RoundTime>
-	<Running>false</Running>
-</Gamemode>

resources/Schema/Components/Gamemode.xsd

@@ -1,25 +0,0 @@
-<?xml version="1.0"?>
-
-<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:t="types">
-	<xs:import schemaLocation="../Types.xsd" namespace="types"/>
-
-	<xs:complexType name="GamemodeEnum" mixed="true">
-		<xs:complexContent>
-			<xs:extension base="t:enum">
-				<xs:choice>
-					<xs:element name="CapturePoints" type="t:int" fixed="1" minOccurs="0"/>
-				</xs:choice>
-			</xs:extension>
-		</xs:complexContent>
-	</xs:complexType>
-	
-	<xs:element name="Gamemode">
-		<xs:complexType>
-			<xs:all>
-				<xs:element name="Gamemode" type="GamemodeEnum" minOccurs="0"/>
-				<xs:element name="RoundTime" type="t:double" minOccurs="0"/>
-				<xs:element name="Running" type="t:bool" minOccurs="0"/>
-			</xs:all>
-		</xs:complexType>
-	</xs:element>
-</xs:schema>

resources/Schema/Types/Entity.xsd

@@ -50,7 +50,6 @@
 							<xs:element ref="c:Menu" minOccurs="0"/>
 							<xs:element ref="c:Page" minOccurs="0"/>
 							<xs:element ref="c:Button" minOccurs="0"/>
-							<xs:element ref="c:Gamemode" minOccurs="0"/>
 						</xs:all>
 					</xs:complexType>
 				</xs:element>

src/Engine/Rendering/PickingPass.cpp

@@ -21,23 +21,13 @@ void PickingPass::InitializeTextures()
 {
     GenerateTexture(&m_PickingTexture, GL_CLAMP_TO_BORDER, GL_LINEAR,
         glm::vec2(m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height), GL_RG8, GL_RG, GL_UNSIGNED_BYTE);
+
+	GenerateTexture(&m_DepthBuffer, GL_CLAMP_TO_BORDER, GL_NEAREST,
+		glm::vec2(m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height), GL_DEPTH24_STENCIL8, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8);
 }
 
 void PickingPass::InitializeFrameBuffers()
 {
-   /* glGenRenderbuffers(1, &m_DepthBuffer);
-    glBindRenderbuffer(GL_RENDERBUFFER, m_DepthBuffer);
-    glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);*/
-
-	glGenTextures(1, &m_DepthBuffer);
-
-	glBindTexture(GL_TEXTURE_2D, m_DepthBuffer);
-	glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH24_STENCIL8, (int)(m_Renderer->GetViewportSize().Width), (int)(m_Renderer->GetViewportSize().Height), 0, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8, nullptr);
-	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
-	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
-
     m_PickingBuffer.AddResource(std::shared_ptr<BufferResource>(new Texture2D(&m_DepthBuffer, GL_DEPTH_ATTACHMENT)));
     m_PickingBuffer.AddResource(std::shared_ptr<BufferResource>(new Texture2D(&m_PickingTexture, GL_COLOR_ATTACHMENT0)));
     m_PickingBuffer.Generate();
@@ -382,8 +372,6 @@ void PickingPass::ClearPicking()
 void PickingPass::OnWindowResize()
 {
     InitializeTextures();
-    glBindRenderbuffer(GL_RENDERBUFFER, m_DepthBuffer);
-    glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
     m_PickingBuffer.Generate();
 }
 

src/Engine/Rendering/Renderer.cpp

@@ -30,6 +30,7 @@ void Renderer::glfwFrameBufferCallback(GLFWwindow* window, int width, int height
     currentRenderer->m_LightCullingPass->OnWindowResize();
     currentRenderer->m_PickingPass->OnWindowResize();
     currentRenderer->m_DrawBloomPass->OnWindowResize();
+	currentRenderer->m_SSAOPass->OnWindowResize();
 }
 
 void Renderer::InitializeWindow()
@@ -126,6 +127,7 @@ void Renderer::Draw(RenderFrame& frame)
     m_PickingPass->ClearPicking();
     m_DrawFinalPass->ClearBuffer();
     m_DrawBloomPass->ClearBuffer();
+	m_SSAOPass->ClearBuffer();
     PerformanceTimer::StopTimer("Renderer-ClearBuffers");
 	for (auto scene : frame.RenderScenes) {
 		PerformanceTimer::StartTimer("Renderer-Depth");

src/Engine/Rendering/SSAOPass.cpp

@@ -6,6 +6,7 @@ SSAOPass::SSAOPass(IRenderer* renderer)
 
 	m_ScreenQuad = ResourceManager::Load<Model>("Models/Core/ScreenQuad.mesh");
 
+	InitializeTexture();
 	InitializeBuffer();
 	InitializeShaderProgram();
 	Setting(0.1f, 0.012f, 1.0f, 1.0f, 13, 7);
@@ -28,16 +29,16 @@ void SSAOPass::InitializeShaderProgram()
 	m_SSAOViewSpaceZProgram->Link();
 }
 
+void SSAOPass::InitializeTexture() {
+	GenerateTexture(&m_SSAOTexture, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height), GL_R8, GL_RED, GL_FLOAT);
+	GenerateTexture(&m_SSAOViewSpaceZTexture, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height), GL_R32F, GL_RED, GL_FLOAT);
+}
 
 void SSAOPass::InitializeBuffer()
 {
-	GenerateTexture(&m_SSAOTexture, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height), GL_R8, GL_RED, GL_FLOAT);
-
 	m_SSAOFramBuffer.AddResource(std::shared_ptr<BufferResource>(new Texture2D(&m_SSAOTexture, GL_COLOR_ATTACHMENT0)));
 	m_SSAOFramBuffer.Generate();
 
-	GenerateTexture(&m_SSAOViewSpaceZTexture, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height), GL_R32F, GL_RED, GL_FLOAT);
-
 	m_SSAOViewSpaceZFramBuffer.AddResource(std::shared_ptr<BufferResource>(new Texture2D(&m_SSAOViewSpaceZTexture, GL_COLOR_ATTACHMENT0)));
 	m_SSAOViewSpaceZFramBuffer.Generate();
 }
@@ -45,12 +46,12 @@ void SSAOPass::InitializeBuffer()
 void SSAOPass::ClearBuffer()
 {
 	m_SSAOFramBuffer.Bind();
-	glClearColor(0.f, 0.f, 0.f, 0.f);
+	glClearColor(1.f, 1.f, 1.f, 1.f);
 	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 	m_SSAOFramBuffer.Unbind();
 
 	m_SSAOViewSpaceZFramBuffer.Bind();
-	glClearColor(0.f, 0.f, 0.f, 0.f);
+	glClearColor(1.f, 1.f, 1.f, 1.f);
 	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 	m_SSAOViewSpaceZFramBuffer.Unbind();
 }
@@ -136,6 +137,9 @@ void SSAOPass::Draw(GLuint depthBuffer, Camera* camera)
 	m_DrawBloomPass->Draw(m_SSAOTexture);
 }
 
-void ComputeAO(GLuint depthBuffer, Camera* camera) {
-
+void SSAOPass::OnWindowResize() {
+	m_DrawBloomPass->OnWindowResize();
+	InitializeTexture();
+	m_SSAOFramBuffer.Generate();
+	m_SSAOViewSpaceZFramBuffer.Generate();
 }

src/Game/CMakeLists.txt

@@ -33,16 +33,10 @@ file(GLOB SOURCE_FILES_Network
 	"Network/*.cpp"
 )
 source_group(Network FILES ${SOURCE_FILES_Network})
-
-file(GLOB SOURCE_FILES
-    "${INCLUDE_PATH}/*.h"
-    "*.cpp"
-)
-list(REMOVE_ITEM SOURCE_FILES "${CMAKE_CURRENT_SOURCE_DIR}/main.cpp")
-source_group(Game FILES ${SOURCE_FILES})
-
 set(SOURCE_FILES
     ${SOURCE_FILES}
+    "Game.cpp"
+	"MiniDump.cpp"
     ${SOURCE_FILES_Systems}
     ${SOURCE_FILES_Systems_Weapon}
     ${SOURCE_FILES_Events}

src/Game/CapturePointsEntitySystem.cpp

@@ -1,98 +0,0 @@
-#include "CapturePointsEntitySystem.h"
-#include "Systems/InterpolationSystem.h"
-#include "Systems/SoundSystem.h"
-#include "Systems/RaptorCopterSystem.h"
-#include "Systems/ExplosionEffectSystem.h"
-#include "Systems/HealthSystem.h"
-#include "Systems/PlayerMovementSystem.h"
-#include "Systems/SpawnerSystem.h"
-#include "Systems/PlayerSpawnSystem.h"
-#include "Systems/Weapon/WeaponSystem.h"
-#include "Systems/LifetimeSystem.h"
-#include "Systems/CapturePointSystem.h"
-#include "Systems/CapturePointHUDSystem.h"
-#include "Systems/PickupSpawnSystem.h"
-#include "Systems/AmmoPickupSystem.h"
-#include "Systems/DamageIndicatorSystem.h"
-#include "Systems/AmmunitionHUDSystem.h"
-#include "Systems/KillFeedSystem.h"
-#include "GUI/ButtonSystem.h"
-#include "GUI/MainMenuSystem.h"
-#include "Collision/FillOctreeSystem.h"
-#include "Collision/FillFrustumOctreeSystem.h"
-#include "Rendering/AnimationSystem.h"
-#include "Core/UniformScaleSystem.h"
-#include "Systems/HealthHUDSystem.h"
-#include "Systems/PlayerDeathSystem.h"
-#include "Rendering/BoneAttachmentSystem.h"
-#include "Collision/CollisionSystem.h"
-#include "Collision/TriggerSystem.h"
-#include "Rendering/RenderSystem.h"
-#include "Editor/EditorSystem.h"
-
-CapturePointsEntitySystem::CapturePointsEntitySystem(EventBroker* eventBroker, bool isClient, bool isServer, IRenderer* renderer, RenderFrame* renderFrame)
-    : EntitySystem(eventBroker, isClient, isServer)
-    , m_Renderer(renderer)
-    , m_RenderFrame(renderFrame)
-{
-    // Create Octrees
-    // TODO: Perhaps the world bounds should be set in some non-arbitrary way instead of this.
-    AABB boxContainingTheWorld(glm::vec3(-300), glm::vec3(300));
-    m_OctreeCollision = new Octree<EntityAABB>(boxContainingTheWorld, 4);
-    m_OctreeTrigger = new Octree<EntityAABB>(boxContainingTheWorld, 4);
-    m_OctreeFrustrumCulling = new Octree<EntityAABB>(boxContainingTheWorld, 4);
-    
-    // All systems with orderlevel 0 will be updated first.
-    unsigned int updateOrderLevel = 0;
-    AddSystem<InterpolationSystem>(updateOrderLevel);
-    ++updateOrderLevel;
-    AddSystem<SoundSystem>(updateOrderLevel);
-    AddSystem<RaptorCopterSystem>(updateOrderLevel);
-    AddSystem<ExplosionEffectSystem>(updateOrderLevel);
-    AddSystem<HealthSystem>(updateOrderLevel);
-    AddSystem<PlayerMovementSystem>(updateOrderLevel);
-    AddSystem<SpawnerSystem>(updateOrderLevel);
-    AddSystem<PlayerSpawnSystem>(updateOrderLevel);
-    AddSystem<WeaponSystem>(updateOrderLevel, m_Renderer, m_OctreeCollision);
-    AddSystem<LifetimeSystem>(updateOrderLevel);
-    AddSystem<CapturePointSystem>(updateOrderLevel);
-    AddSystem<CapturePointHUDSystem>(updateOrderLevel);
-    AddSystem<PickupSpawnSystem>(updateOrderLevel);
-    AddSystem<AmmoPickupSystem>(updateOrderLevel);
-    AddSystem<DamageIndicatorSystem>(updateOrderLevel);
-    AddSystem<AmmunitionHUDSystem>(updateOrderLevel);
-    AddSystem<KillFeedSystem>(updateOrderLevel);
-    AddSystem<ButtonSystem>(updateOrderLevel, m_Renderer);
-    AddSystem<MainMenuSystem>(updateOrderLevel, m_Renderer);
-    // Populate Octree with collidables
-    ++updateOrderLevel;
-    AddSystem<FillOctreeSystem>(updateOrderLevel, m_OctreeCollision, "Collidable");
-    AddSystem<FillOctreeSystem>(updateOrderLevel, m_OctreeTrigger, "Player");
-    AddSystem<FillFrustumOctreeSystem>(updateOrderLevel, m_OctreeFrustrumCulling);
-    AddSystem<AnimationSystem>(updateOrderLevel);
-    AddSystem<UniformScaleSystem>(updateOrderLevel);
-    AddSystem<HealthHUDSystem>(updateOrderLevel);
-    AddSystem<PlayerDeathSystem>(updateOrderLevel);
-    // Collision and TriggerSystem should update after player.
-    ++updateOrderLevel;
-    AddSystem<BoneAttachmentSystem>(updateOrderLevel);
-    AddSystem<CollisionSystem>(updateOrderLevel, m_OctreeCollision);
-    AddSystem<TriggerSystem>(updateOrderLevel, m_OctreeTrigger);
-    ++updateOrderLevel;
-    AddSystem<RenderSystem>(updateOrderLevel, m_Renderer, m_RenderFrame, m_OctreeFrustrumCulling);
-    ++updateOrderLevel;
-    AddSystem<EditorSystem>(updateOrderLevel, m_Renderer, m_RenderFrame);
-}
-
-CapturePointsEntitySystem::~CapturePointsEntitySystem()
-{
-    if (m_OctreeFrustrumCulling != nullptr) {
-        delete m_OctreeFrustrumCulling;
-    }
-    if (m_OctreeCollision != nullptr) {
-        delete m_OctreeCollision;
-    }
-    if (m_OctreeTrigger != nullptr) {
-        delete m_OctreeTrigger;
-    }
-}

src/Game/Game.cpp

@@ -1,8 +1,34 @@
 #include "Game.h"
-#include "Core/EntityFileWriter.h"
-#include "Network/MultiplayerSnapshotFilter.h"
+#include "Collision/FillOctreeSystem.h"
+#include "Collision/FillFrustumOctreeSystem.h"
+#include "Collision/EntityAABB.h"
+#include "Collision/TriggerSystem.h"
+#include "Collision/CollisionSystem.h"
+#include "Systems/RaptorCopterSystem.h"
+#include "Systems/HealthSystem.h"
+#include "Systems/PlayerMovementSystem.h"
+#include "Systems/SpawnerSystem.h"
 #include "Systems/PlayerSpawnSystem.h"
-#include "CapturePointsEntitySystem.h"
+#include "Systems/PlayerDeathSystem.h"
+#include "Core/EntityFileWriter.h"
+#include "Game/Systems/CapturePointSystem.h"
+#include "Game/Systems/CapturePointHUDSystem.h"
+#include "Game/Systems/PickupSpawnSystem.h"
+#include "Game/Systems/AmmoPickupSystem.h"
+#include "Game/Systems/DamageIndicatorSystem.h"
+#include "Game/Systems/Weapon/WeaponSystem.h"
+#include "Rendering/AnimationSystem.h"
+#include "Game/Systems/HealthHUDSystem.h"
+#include "Rendering/BoneAttachmentSystem.h"
+#include "Game/Systems/LifetimeSystem.h"
+#include "../Engine/Core/UniformScaleSystem.h"
+#include "Rendering/AnimationSystem.h"
+#include "Network/MultiplayerSnapshotFilter.h"
+#include "Game/Systems/AmmunitionHUDSystem.h"
+#include "Game/Systems/KillFeedSystem.h"
+#include "GUI/ButtonSystem.h"
+#include "GUI/MainMenuSystem.h"
+
 
 Game::Game(int argc, char* argv[])
 {
@@ -22,7 +48,6 @@ Game::Game(int argc, char* argv[])
     ResourceManager::UseThreading = m_Config->Get<bool>("Multithreading.ResourceLoading", true);
     DisableMemoryPool::Value = m_Config->Get<bool>("Debug.DisableMemoryPool", false);
     LOG_LEVEL = static_cast<_LOG_LEVEL>(m_Config->Get<int>("Debug.LogLevel", 1));
-    // HACK: This shouldn't be a config variable
     PlayerSpawnSystem::SetRespawnTime(m_Config->Get<float>("Debug.RespawnTime", 15.0f));
 
     // Create the core event broker
@@ -49,30 +74,91 @@ Game::Game(int argc, char* argv[])
     m_InputProxy->AddHandler<MouseInputHandler>();
     m_InputProxy->LoadBindings("Input.ini");
 
-    // Create the sound manager
-    //m_SoundManager = new SoundManager(m_World, m_EventBroker);
+    // Create a world
+    m_World = new World(m_EventBroker);
+    std::string mapToLoad = m_Config->Get<std::string>("Debug.LoadMap", "");
+    if (!mapToLoad.empty()) {
+        auto file = ResourceManager::Load<EntityFile>(mapToLoad);
+        EntityFilePreprocessor fpp(file);
+        fpp.RegisterComponents(m_World);
+        EntityFileParser fp(file);
+        fp.MergeEntities(m_World);
+    }
 
-    // Create an entity system
-    m_EntitySystem = new CapturePointsEntitySystem(m_EventBroker, m_IsClient, m_IsServer, m_Renderer, m_RenderFrame);
+    // Create the sound manager
+    m_SoundManager = new SoundManager(m_World, m_EventBroker);
 
     // Initialize network
     if (m_Config->Get<bool>("Networking.StartNetwork", false)) {
         if (m_IsServer) {
-            m_NetworkServer = new Server(m_EntitySystem, m_EventBroker, m_NetworkPort);
+            m_NetworkServer = new Server(m_World, m_EventBroker, m_NetworkPort);
             m_Renderer->SetWindowTitle(m_Renderer->WindowTitle() + " SERVER");
         } else if (m_IsClient) {
-            m_NetworkClient = new Client(m_EntitySystem, m_EventBroker, std::make_unique<MultiplayerSnapshotFilter>(m_EventBroker));
+            m_NetworkClient = new Client(m_World, m_EventBroker, std::make_unique<MultiplayerSnapshotFilter>(m_EventBroker));
             m_NetworkClient->Connect(m_NetworkAddress, m_NetworkPort);
             m_Renderer->SetWindowTitle(m_Renderer->WindowTitle() + " CLIENT");
         }
     }
 
+    // Create Octrees
+    // TODO: Perhaps the world bounds should be set in some non-arbitrary way instead of this.
+    AABB boxContainingTheWorld(glm::vec3(-300), glm::vec3(300));
+    m_OctreeCollision = new Octree<EntityAABB>(boxContainingTheWorld, 4);
+    m_OctreeTrigger = new Octree<EntityAABB>(boxContainingTheWorld, 4);
+    m_OctreeFrustrumCulling = new Octree<EntityAABB>(boxContainingTheWorld, 4);
+    // Create system pipeline
+    m_SystemPipeline = new SystemPipeline(m_World, m_EventBroker, m_IsClient, m_IsServer);
+
+    // All systems with orderlevel 0 will be updated first.
+    unsigned int updateOrderLevel = 0;
+    m_SystemPipeline->AddSystem<InterpolationSystem>(updateOrderLevel);
+    ++updateOrderLevel;
+    m_SystemPipeline->AddSystem<SoundSystem>(updateOrderLevel);
+    m_SystemPipeline->AddSystem<RaptorCopterSystem>(updateOrderLevel);
+    m_SystemPipeline->AddSystem<ExplosionEffectSystem>(updateOrderLevel);
+    m_SystemPipeline->AddSystem<HealthSystem>(updateOrderLevel);
+    m_SystemPipeline->AddSystem<PlayerMovementSystem>(updateOrderLevel);
+    m_SystemPipeline->AddSystem<SpawnerSystem>(updateOrderLevel);
+    m_SystemPipeline->AddSystem<PlayerSpawnSystem>(updateOrderLevel);
+    m_SystemPipeline->AddSystem<WeaponSystem>(updateOrderLevel, m_Renderer, m_OctreeCollision);
+    m_SystemPipeline->AddSystem<LifetimeSystem>(updateOrderLevel);
+    m_SystemPipeline->AddSystem<CapturePointSystem>(updateOrderLevel);
+    m_SystemPipeline->AddSystem<CapturePointHUDSystem>(updateOrderLevel);
+    m_SystemPipeline->AddSystem<PickupSpawnSystem>(updateOrderLevel);
+    m_SystemPipeline->AddSystem<AmmoPickupSystem>(updateOrderLevel);
+    m_SystemPipeline->AddSystem<DamageIndicatorSystem>(updateOrderLevel);
+    m_SystemPipeline->AddSystem<AmmunitionHUDSystem>(updateOrderLevel);
+    m_SystemPipeline->AddSystem<KillFeedSystem>(updateOrderLevel);
+    m_SystemPipeline->AddSystem<ButtonSystem>(updateOrderLevel, m_Renderer);
+    m_SystemPipeline->AddSystem<MainMenuSystem>(updateOrderLevel, m_Renderer);
+    // Populate Octree with collidables
+    ++updateOrderLevel;
+    m_SystemPipeline->AddSystem<FillOctreeSystem>(updateOrderLevel, m_OctreeCollision, "Collidable");
+    m_SystemPipeline->AddSystem<FillOctreeSystem>(updateOrderLevel, m_OctreeTrigger, "Player");
+    m_SystemPipeline->AddSystem<FillFrustumOctreeSystem>(updateOrderLevel, m_OctreeFrustrumCulling);
+    m_SystemPipeline->AddSystem<AnimationSystem>(updateOrderLevel);
+    m_SystemPipeline->AddSystem<UniformScaleSystem>(updateOrderLevel);
+    m_SystemPipeline->AddSystem<HealthHUDSystem>(updateOrderLevel);
+    m_SystemPipeline->AddSystem<PlayerDeathSystem>(updateOrderLevel);
+    // Collision and TriggerSystem should update after player.
+    ++updateOrderLevel;
+    m_SystemPipeline->AddSystem<BoneAttachmentSystem>(updateOrderLevel);
+    m_SystemPipeline->AddSystem<CollisionSystem>(updateOrderLevel, m_OctreeCollision);
+    m_SystemPipeline->AddSystem<TriggerSystem>(updateOrderLevel, m_OctreeTrigger);
+    ++updateOrderLevel;
+    m_SystemPipeline->AddSystem<RenderSystem>(updateOrderLevel, m_Renderer, m_RenderFrame, m_OctreeFrustrumCulling);
+    ++updateOrderLevel;
+    m_SystemPipeline->AddSystem<EditorSystem>(updateOrderLevel, m_Renderer, m_RenderFrame);
+
     m_LastTime = glfwGetTime();
 }
 
 Game::~Game()
 {
-    delete m_EntitySystem;
+    delete m_SystemPipeline;
+    delete m_OctreeFrustrumCulling;
+    delete m_OctreeCollision;
+    delete m_OctreeTrigger;
     delete m_SoundManager;
     if (m_NetworkClient != nullptr) {
         delete m_NetworkClient;
@@ -80,6 +166,7 @@ Game::~Game()
     if (m_NetworkServer != nullptr) {
         delete m_NetworkServer;
     }
+    delete m_World;
     delete m_InputProxy;
     delete m_InputManager;
     delete m_RenderFrame;
@@ -108,7 +195,7 @@ void Game::Tick()
     m_EventBroker->Swap();
 
     PerformanceTimer::StartTimerAndStopPrevious("SoundManager");
-    //m_SoundManager->Update(dt);
+    m_SoundManager->Update(dt);
 
     // Update network
     PerformanceTimer::StartTimerAndStopPrevious("Network");
@@ -122,9 +209,9 @@ void Game::Tick()
     //m_SoundManager->Update(dt);
 
     // Iterate through systems and update world!
-    PerformanceTimer::StartTimerAndStopPrevious("EntitySystem");
+    PerformanceTimer::StartTimerAndStopPrevious("SystemPipeline");
     m_EventBroker->Process<SystemPipeline>();
-    m_EntitySystem->Update(dt);
+    m_SystemPipeline->Update(dt);
     PerformanceTimer::StartTimerAndStopPrevious("RendererUpdate");
     m_Renderer->Update(dt);
     PerformanceTimer::StartTimerAndStopPrevious("RendererDraw");

src/Game/Systems/CapturePointSystem.cpp

@@ -192,6 +192,27 @@ void CapturePointSystem::UpdateComponent(EntityWrapper& capturePointEntity, Comp
             //NextPossibleCapturePoint will be calculated in the next update...
         }
     }
+
+    //check for possible winCondition = check if the homebase is owned by the other team
+    bool checkForWinner = false;
+    if (capturePointNumber == m_RedTeamHomeCapturePoint && ownedBy != redTeam)
+    {
+        checkForWinner = true;
+    }
+    if (capturePointNumber == m_BlueTeamHomeCapturePoint && ownedBy != blueTeam)
+    {
+        checkForWinner = true;
+    }
+
+    if (checkForWinner && !m_WinnerWasFound)
+    {
+        //publish Win event
+        Events::Win e;
+        e.TeamThatWon = ownedBy;
+        m_EventBroker->Publish(e);
+        m_WinnerWasFound = true;
+    }
+
 }
 
 bool CapturePointSystem::OnTriggerTouch(const Events::TriggerTouch& e)

src/Game/Systems/CapturePointsGamemode.cpp

@@ -1,117 +0,0 @@
-#include "Systems/CapturePointsGamemode.h"
-
-CapturePointsGamemode::CapturePointsGamemode(SystemParams params)
-    : System(params)
-{
-    EVENT_SUBSCRIBE_MEMBER(m_ECaptured, &CapturePointsGamemode::OnCaptured);
-    EVENT_SUBSCRIBE_MEMBER(m_EGameStart, &CapturePointsGamemode::OnGameStart);
-}
-
-void CapturePointsGamemode::Update(double dt)
-{
-    if (!m_GameRuning) {
-        return;
-    }
-
-    auto cGamemode = currentGamemode();
-    if (!cGamemode) {
-        setRunning(false);
-        return;
-    }
-
-    m_GameTime += dt;
-    (double&)(*cGamemode)["RoundTime"] = m_GameTime;
-}
-
-bool CapturePointsGamemode::OnGameStart(const Events::GameStart& e)
-{
-    if (!isCurrentGamemode()) {
-        return false;
-    }
-
-    setRunning(true);
-
-    return true;
-}
-
-bool CapturePointsGamemode::OnCaptured(const Events::Captured& e)
-{
-    if (!m_GameRuning) {
-        return false;
-    }
-
-    auto cGamemode = currentGamemode();
-    if (!cGamemode) {
-        return false;
-    }
-
-    auto winningTeam = winCondition();
-    if (winningTeam) {
-        setRunning(false);
-
-        Events::Win e;
-        e.Team = *winningTeam;
-        m_EventBroker->Publish(e);
-    }
-
-    return true;
-}
-
-boost::optional<ComponentWrapper> CapturePointsGamemode::currentGamemode()
-{
-    auto cGamemodes = m_World->GetComponents("Gamemode");
-    if (cGamemodes->begin() == cGamemodes->end()) {
-        return boost::none;
-    }
-    return *cGamemodes->begin();
-}
-
-bool CapturePointsGamemode::isCurrentGamemode()
-{
-    auto cGamemode = currentGamemode();
-    if (!cGamemode) {
-        return false;
-    }
-
-    // Check that we're the current gamemode
-    if ((ComponentInfo::EnumType)(*cGamemode)["Gamemode"] == (*cGamemode)["Gamemode"].Enum("CapturePoints")) {
-        return true;
-    } else {
-        return false;
-    }
-}
-
-boost::optional<ComponentInfo::EnumType> CapturePointsGamemode::winCondition()
-{
-    auto cCapturePoints = m_World->GetComponents("CapturePoint");
-    
-    // If all capture points are owned by the same team, they won
-    ComponentInfo::EnumType winningTeam = -1;
-    for (auto& c : *cCapturePoints) {
-        EntityWrapper e(m_World, c.EntityID);
-        ComponentInfo::EnumType team = e["Team"]["Team"];
-        if (winningTeam != -1 && winningTeam != team) {
-            return boost::none;
-        } else {
-            winningTeam = team;
-        }
-    }
-
-    return winningTeam;
-}
-
-void CapturePointsGamemode::setRunning(bool running)
-{
-    m_GameRuning = running;
-    if (running) {
-        m_GameTime = 0.0;
-    }
-
-    auto cGamemode = currentGamemode();
-    if (cGamemode) {
-        m_GameRuning = running;
-        if (running) {
-            (*cGamemode)["RoundTime"] = 0.0;
-        }
-    }
-}

src/Game/Systems/SoundSystem.cpp

@@ -14,7 +14,6 @@ SoundSystem::SoundSystem(SystemParams params)
         EVENT_SUBSCRIBE_MEMBER(m_EPlayerDamage, &SoundSystem::OnPlayerDamage);
         EVENT_SUBSCRIBE_MEMBER(m_ECaptured, &SoundSystem::OnCaptured);
         EVENT_SUBSCRIBE_MEMBER(m_ETriggerTouch, &SoundSystem::OnTriggerTouch);
-        EVENT_SUBSCRIBE_MEMBER(m_EPlayerHealthPickup, &SoundSystem::OnPlayerHealthPickup);
     }
 }