Created "EntitySystem" class as means to group a World with a SystemPipeline

include/Engine/Core/EAmmoPickup.h

@@ -1,18 +0,0 @@
-#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/EPlayerHealthPickup.h

@@ -1,18 +0,0 @@
-#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

@@ -1,20 +0,0 @@
-#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

@@ -0,0 +1,19 @@
+#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/Game/CapturePointsEntitySystem.h

@@ -0,0 +1,18 @@
+#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

@@ -0,0 +1,18 @@
+#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/ECaptured.h

@@ -1,14 +1,13 @@
 #ifndef ECaptured_h__
 #define ECaptured_h__
 
-#include "EventBroker.h"
+#include "Core/EventBroker.h"
-#include "../Core/Entity.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/Game/Events/EGameEnd.h

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

include/Game/Events/EGameStart.h

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

include/Game/Events/EPlayerHealthPickup.h

@@ -0,0 +1,18 @@
+#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

@@ -0,0 +1,19 @@
+#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,18 +12,16 @@
 #include "Input/InputProxy.h"
 #include "Input/KeyboardInputHandler.h"
 #include "Input/MouseInputHandler.h"
-#include "Core/EKeyDown.h"
 #include "Core/EntityFilePreprocessor.h"
-#include "Core/SystemPipeline.h"
+#include "Core/EntitySystem.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"
@@ -55,11 +53,7 @@ private:
 	IRenderer* m_Renderer;
 	InputManager* m_InputManager;
     InputProxy* m_InputProxy;
-    World* m_World;
+    EntitySystem<World>* m_EntitySystem;
-    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 "Core/EPickupSpawned.h"
+#include "Events/EPickupSpawned.h"
-#include "Core/EAmmoPickup.h"
+#include "Events/EAmmoPickup.h"
 #include "Engine/Collision/ETrigger.h"
 #include "Common.h"
 

include/Game/Systems/CapturePointSystem.h

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

include/Game/Systems/CapturePointsGamemode.h

@@ -0,0 +1,27 @@
+#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 "Core/EPickupSpawned.h"
+#include "Events/EPickupSpawned.h"
-#include "Core/EPlayerHealthPickup.h"
+#include "Events/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 "../Engine/Core/ECaptured.h"
+#include "Events/ECaptured.h"
 #include "../Engine/Core/EPlayerDamage.h"
 #include "../Engine/Core/EPlayerDeath.h"
-#include "../Engine/Core/EPlayerHealthPickup.h"
+#include "Events/EPlayerHealthPickup.h"
 #include "../Engine/Collision/ETrigger.h"
 #include "../Engine/Sound/EPlaySoundOnEntity.h"
 #include "../Engine/Sound/EPlayBackgroundMusic.h"

resources/Schema/Components.xsd

@@ -45,4 +45,5 @@
 	<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

@@ -0,0 +1,6 @@
+<?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

@@ -0,0 +1,25 @@
+<?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,6 +50,7 @@
 							<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/Game/CMakeLists.txt

@@ -33,10 +33,16 @@ 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

@@ -0,0 +1,98 @@
+#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,34 +1,8 @@
 #include "Game.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 "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 "Systems/PlayerSpawnSystem.h"
-#include "Game/Systems/KillFeedSystem.h"
+#include "CapturePointsEntitySystem.h"
-#include "GUI/ButtonSystem.h"
-#include "GUI/MainMenuSystem.h"
-
 
 Game::Game(int argc, char* argv[])
 {
@@ -48,6 +22,7 @@ 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
@@ -74,91 +49,30 @@ Game::Game(int argc, char* argv[])
     m_InputProxy->AddHandler<MouseInputHandler>();
     m_InputProxy->LoadBindings("Input.ini");
 
-    // 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 the sound manager
-    m_SoundManager = new SoundManager(m_World, m_EventBroker);
+    //m_SoundManager = new SoundManager(m_World, m_EventBroker);
+
+    // Create an entity system
+    m_EntitySystem = new CapturePointsEntitySystem(m_EventBroker, m_IsClient, m_IsServer, m_Renderer, m_RenderFrame);
 
     // Initialize network
     if (m_Config->Get<bool>("Networking.StartNetwork", false)) {
         if (m_IsServer) {
-            m_NetworkServer = new Server(m_World, m_EventBroker, m_NetworkPort);
+            m_NetworkServer = new Server(m_EntitySystem, m_EventBroker, m_NetworkPort);
             m_Renderer->SetWindowTitle(m_Renderer->WindowTitle() + " SERVER");
         } else if (m_IsClient) {
-            m_NetworkClient = new Client(m_World, m_EventBroker, std::make_unique<MultiplayerSnapshotFilter>(m_EventBroker));
+            m_NetworkClient = new Client(m_EntitySystem, 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_SystemPipeline;
+    delete m_EntitySystem;
-    delete m_OctreeFrustrumCulling;
-    delete m_OctreeCollision;
-    delete m_OctreeTrigger;
     delete m_SoundManager;
     if (m_NetworkClient != nullptr) {
         delete m_NetworkClient;
@@ -166,7 +80,6 @@ Game::~Game()
     if (m_NetworkServer != nullptr) {
         delete m_NetworkServer;
     }
-    delete m_World;
     delete m_InputProxy;
     delete m_InputManager;
     delete m_RenderFrame;
@@ -195,7 +108,7 @@ void Game::Tick()
     m_EventBroker->Swap();
 
     PerformanceTimer::StartTimerAndStopPrevious("SoundManager");
-    m_SoundManager->Update(dt);
+    //m_SoundManager->Update(dt);
 
     // Update network
     PerformanceTimer::StartTimerAndStopPrevious("Network");
@@ -209,9 +122,9 @@ void Game::Tick()
     //m_SoundManager->Update(dt);
 
     // Iterate through systems and update world!
-    PerformanceTimer::StartTimerAndStopPrevious("SystemPipeline");
+    PerformanceTimer::StartTimerAndStopPrevious("EntitySystem");
     m_EventBroker->Process<SystemPipeline>();
-    m_SystemPipeline->Update(dt);
+    m_EntitySystem->Update(dt);
     PerformanceTimer::StartTimerAndStopPrevious("RendererUpdate");
     m_Renderer->Update(dt);
     PerformanceTimer::StartTimerAndStopPrevious("RendererDraw");

src/Game/Systems/CapturePointSystem.cpp

@@ -192,27 +192,6 @@ 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

@@ -0,0 +1,117 @@
+#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,6 +14,7 @@ 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);
     }
 }