I developed a LevelSystem class, along with a CBrick component for use in it and an EStageCleared event that is triggered upon all the bricks being removed.

The class currently creates a 8x8 grid of entities with Transform components.

include/Core/Engine.h

@@ -33,6 +33,7 @@
 #include "Rendering/CModel.h"
 #include "CTemplate.h"
 #include "Transform/TransformSystem.h"
+#include "Game/LevelSystem.h"
 
 namespace dd
 {
@@ -42,24 +43,26 @@ class Engine
 public:
 	Engine(int argc, char* argv[])
 	{
-//		m_EventBroker = std::make_shared<EventBroker>();
+		m_EventBroker = std::make_shared<EventBroker>();
 
 		m_Renderer = std::make_shared<BGFXRenderer>();
 		m_Renderer->SetFullscreen(false);
 		m_Renderer->SetResolution(Rectangle(0, 0, 1280, 720));
 		m_Renderer->Initialize();
 
-//		m_InputManager = std::make_shared<InputManager>(m_Renderer->Window(), m_EventBroker);
+		m_InputManager = std::make_shared<InputManager>(m_Renderer->Window(), m_EventBroker);
-//
+
-//		m_World = std::make_shared<World>(m_EventBroker);
+		m_World = std::make_shared<World>(m_EventBroker);
-//
+
-//		//TODO: Move this out of engine.h
+		//TODO: Move this out of engine.h
-//		m_World->ComponentFactory.Register<Components::Transform>();
+		m_World->ComponentFactory.Register<Components::Transform>();
-//		m_World->SystemFactory.Register<Systems::TransformSystem>([this]() { return new Systems::TransformSystem(m_World.get(), m_EventBroker); });
+		m_World->SystemFactory.Register<Systems::TransformSystem>([this]() { return new Systems::TransformSystem(m_World.get(), m_EventBroker); });
-//		m_World->AddSystem<Systems::TransformSystem>();
+		m_World->AddSystem<Systems::TransformSystem>();
-//		m_World->ComponentFactory.Register<Components::Model>();
+		m_World->SystemFactory.Register<Systems::LevelSystem>([this]() { return new Systems::LevelSystem(m_World.get(), m_EventBroker); });
-//		m_World->ComponentFactory.Register<Components::Template>();
+		m_World->AddSystem<Systems::LevelSystem>();
-//		m_World->Initialize();
+		m_World->ComponentFactory.Register<Components::Model>();
+		m_World->ComponentFactory.Register<Components::Template>();
+		m_World->Initialize();
 
 //		auto ent = m_World->CreateEntity();
 //		std::shared_ptr<Components::Transform> transform = m_World->AddComponent<Components::Transform>(ent);
@@ -79,31 +82,32 @@ public:
 		double dt = currentTime - m_LastTime;
 		m_LastTime = currentTime;
 
-//		ResourceManager::Update();
+		ResourceManager::Update();
-//
+
-//		// Update input
+		// Update input
-//		m_InputManager->Update(dt);
+		m_InputManager->Update(dt);
-//
+
-//		m_World->Update(dt);
+		m_World->Update(dt);
 //
 //		if (glfwGetKey(m_Renderer->Window(), GLFW_KEY_R)) {
 //			ResourceManager::Reload("Shaders/Deferred/3/Fragment.glsl");
 //		}
 //
-//		//TODO Fill up the renderQueue with models (Temp fix)
+		//TODO Fill up the renderQueue with models (Temp fix)
 //		TEMPAddToRenderQueue();
-//
+
-//		// Render scene
+		// Render scene
-//		//TODO send renderqueue to draw.
+		//TODO send renderqueue to draw.
-		m_Renderer->Draw(m_RendererQueue);
+//		m_Renderer->Draw(m_RendererQueue);
 
 		// Swap event queues
-//		m_EventBroker->Clear();
+		m_EventBroker->Clear();
 
 		glfwPollEvents();
 	}
 
 	std::shared_ptr<Systems::TransformSystem> m_TransformSystem;
+	std::shared_ptr<Systems::LevelSystem> m_LevelSystem;
 
 	//TODO: Get this out of engine.h
 	void TEMPAddToRenderQueue()

include/Game/CBrick.h

@@ -0,0 +1,26 @@
+//
+// Created by Adniklastrator on 2015-09-09.
+//
+
+#ifndef DAYDREAM_CBRICK_H
+#define DAYDREAM_CBRICK_H
+
+#include "Core/Component.h"
+
+namespace dd
+{
+
+namespace Components
+{
+
+struct Brick : Component
+{
+    int Points = 10;
+    int Hits = 1;
+};
+
+}
+
+}
+
+#endif //DAYDREAM_CBRICK_H

include/Game/EStageCleared.h

@@ -0,0 +1,21 @@
+//
+// Created by Adniklastrator on 2015-09-09.
+//
+
+#ifndef DAYDREAM_ESTAGECLEARED_H
+#define DAYDREAM_ESTAGECLEARED_H
+
+#include "Core/EventBroker.h"
+
+namespace dd
+{
+namespace Events
+{
+struct StageCleared : Event
+{
+
+};
+}
+}
+
+#endif //DAYDREAM_ESTAGECLEARED_H

include/Game/LevelSystem.h

@@ -0,0 +1,51 @@
+//
+// Created by Adniklastrator on 2015-09-09.
+//
+
+#ifndef DAYDREAM_LEVELSYSTEM_H
+#define DAYDREAM_LEVELSYSTEM_H
+
+#include "Core/System.h"
+#include "Core/CTransform.h"
+//#include "Rendering/CSprite.h"
+#include "Core/EventBroker.h"
+
+namespace dd
+{
+
+namespace Systems
+{
+
+class LevelSystem : public System
+{
+public:
+    LevelSystem(World* world, std::shared_ptr<dd::EventBroker> eventBroker)
+    : System(world, eventBroker)
+    { }
+
+    void Initialize() override;
+
+    void CreateBasicLevel(int, int, int, int);
+    void CreateBrick(int, int, int, int);
+    void ProcessCollision();
+
+    void OnEntityRemoved(EntityID entity);
+
+    void EndLevel();
+
+
+
+private:
+    int numberOfBricks;
+    EntityID bricks[];
+    int tRows = 8;
+    int tLines = 8;
+    int tSpaceBetweenBricks = 30;
+    int tSpaceToEdge = 30;
+};
+
+}
+
+}
+
+#endif //DAYDREAM_LEVELSYSTEM_H

src/game/CMakeLists.txt

@@ -67,7 +67,7 @@ set(SOURCE_FILES
     ${SOURCE_FILES_Rendering}
     ${SOURCE_FILES_Transform}
     ${SOURCE_FILES_Game}
-)
+        ../../include/Game/CBrick.h ../../include/Game/EStageCleared.h)
 
 if(CMAKE_COMPILER_IS_GNUCXX)
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pthread")

src/game/Game/LevelSystem.cpp

@@ -0,0 +1,69 @@
+//
+// Created by Adniklastrator on 2015-09-09.
+//
+
+
+#include "PrecompiledHeader.h"
+#include "Game/CBrick.h"
+#include "Game/LevelSystem.h"
+#include "Core/World.h"
+#include "Game/EStageCleared.h"
+
+void dd::Systems::LevelSystem::Initialize()
+{
+    CreateBasicLevel(tRows, tLines, tSpaceBetweenBricks, tSpaceToEdge);
+    return;
+}
+
+void dd::Systems::LevelSystem::CreateBasicLevel(int rows, int lines, int spacesBetweenBricks, int spaceToEdge)
+{
+    numberOfBricks = rows * lines;
+    for (int i = 0; i < rows; i++)
+    {
+        for (int j = 0; j < lines; j++)
+        {
+            CreateBrick(i, j, spacesBetweenBricks, spaceToEdge);
+        }
+    }
+
+    return;
+}
+
+void dd::Systems::LevelSystem::CreateBrick(int row, int line, int spacesBetweenBricks, int spaceToEdge)
+{
+    auto brick = m_World->CreateEntity();
+    std::shared_ptr<Components::Transform> transform = m_World->AddComponent<Components::Transform>(brick);
+    //std::shared_ptr<Components::Sprite> sprite = m_World->AddComponent<Components::Sprite>(brick);
+    float x = spaceToEdge + line * spacesBetweenBricks;
+    float y = spaceToEdge + line * spacesBetweenBricks;
+    transform->Position = glm::vec3(x, y, 0.f);
+    //sprite->Color = glm::vec4(1.f, 1.f, 1.f, 1.f);
+    return;
+}
+
+void dd::Systems::LevelSystem::ProcessCollision()
+{
+    // Like, go into brick component and check what it does upon collision. Maybe not done here?
+    return;
+}
+
+void dd::Systems::LevelSystem::OnEntityRemoved(EntityID entity)
+{
+    auto brick = m_World->GetComponent<Components::Brick>(entity);
+    if (brick != NULL)
+    {
+        numberOfBricks--;
+        if (numberOfBricks < 1)
+        {
+            EndLevel();
+        }
+    }
+    return;
+}
+
+void dd::Systems::LevelSystem::EndLevel()
+{
+    Events::StageCleared e;
+    EventBroker->Publish(e);
+    return;
+}