Implemented GetNextLevel function with hard-coded levels.

include/Game/BallSystem.h

@@ -21,6 +21,7 @@
 #include "Game/EMultiBallLost.h"
 #include "Game/EGameOver.h"
 #include "Game/EPause.h"
+#include "Game/EHitPad.h"
 
 namespace dd
 {

include/Game/EHitPad.h

@@ -0,0 +1,21 @@
+//
+// Created by Administrator on 2015-10-05.
+//
+
+#ifndef DAYDREAM_EHITPAD_H
+#define DAYDREAM_EHITPAD_H
+
+#include "Core/EventBroker.h"
+
+namespace dd
+{
+namespace Events
+{
+struct HitPad : Event
+{
+
+};
+}
+}
+
+#endif //DAYDREAM_EHITPAD_H

include/Game/LevelSystem.h

@@ -21,6 +21,7 @@
 #include "Game/EResetBall.h"
 #include "Game/EScoreEvent.h"
 #include "Game/EComboEvent.h"
+#include "Game/EHitPad.h"
 #include "Game/EMultiBall.h"
 #include "Game/EMultiBallLost.h"
 #include "Game/EPause.h"
@@ -45,15 +46,15 @@ namespace Systems
 {
 
     // Me trying things out.
-class Level
+/*class Level
 {
 public:
-    int levelRows;
+    int levelRows = 6;
-    int levelLines;
+    int levelLines = 7;
-    int levelSpaceBetweenBricks;
+    glm::vec2 levelSpaceBetweenBricks = glm::vec2(1, 0.4);
-    int levelSpaceToEdge;
+    float levelSpaceToEdge = 0.25f;
-    int bricks[];
+    std::array<int, 42> bricks;
-};
+};*/
 
 class LevelSystem : public System
 {
@@ -65,10 +66,8 @@ public:
     void Initialize() override;
 
     void CreateBasicLevel(int, int, glm::vec2, float);
-    void SaveLevel(int, int, glm::vec2, int); // Shouldn't be here, but I'm experimenting.
+    void CreateLevel();
-    void LoadLevel(char[20]);
+    void CreateBrick(int, int, glm::vec2, float, int, int);
-    void CreateBrick(int, int, glm::vec2, float, int);
-    void ProcessCollision();
 
     void OnEntityRemoved(EntityID entity);
 
@@ -104,9 +103,12 @@ public:
     void SetNotResettingTheStage(const float& notResettingTheStage) { m_NotResettingTheStage = notResettingTheStage; }
 
 private:
+    bool m_Cleared = false;
     bool m_Restarting = false;
     bool m_Initialized = false;
     bool m_Pause = false;
+    int m_CurrentCluster = 2;
+    int m_CurrentLevel = 1;
     int m_MultiBalls = 0;
     int m_PowerUps = 0;
     int m_Score = 0;
@@ -117,6 +119,8 @@ private:
     glm::vec2 m_SpaceBetweenBricks = glm::vec2(1, 0.4);
     float m_NotResettingTheStage = 5.f;
 
+    std::array<int, 42> m_Bricks;
+
     dd::EventRelay<LevelSystem, dd::Events::Contact> m_EContact;
     dd::EventRelay<LevelSystem, dd::Events::ScoreEvent> m_EScoreEvent;
     dd::EventRelay<LevelSystem, dd::Events::MultiBall> m_EMultiBall;
@@ -125,6 +129,7 @@ private:
     dd::EventRelay<LevelSystem, dd::Events::PowerUpTaken> m_EPowerUpTaken;
     dd::EventRelay<LevelSystem, dd::Events::StageCleared> m_EStageCleared;
     dd::EventRelay<LevelSystem, dd::Events::Pause> m_EPause;
+    dd::EventRelay<LevelSystem, dd::Events::HitPad> m_EHitPad;
 
     bool OnContact(const dd::Events::Contact &event);
     bool OnScoreEvent(const dd::Events::ScoreEvent &event);
@@ -134,6 +139,9 @@ private:
     bool OnPowerUpTaken(const dd::Events::PowerUpTaken &event);
     bool OnStageCleared(const dd::Events::StageCleared &event);
     bool OnPause(const dd::Events::Pause &event);
+    bool OnHitPad(const dd::Events::HitPad &event);
+
+    void GetNextLevel();
 };
 
 }

src/game/Game/BallSystem.cpp

@@ -116,10 +116,6 @@ void dd::Systems::BallSystem::UpdateEntity(double dt, EntityID entity, EntityID
         }
         if (transformBall->Position.y < -EdgeY() - 4) {
             if (MultiBalls() != 0) {
-//                m_World->RemoveComponent<Components::Ball>(entity);
-//                m_World->RemoveComponent<Components::Transform>(entity);
-//                m_World->RemoveComponent<Components::CircleShape>(entity);
-//                m_World->RemoveComponent<Components::Physics>(entity);
                 m_World->RemoveEntity(entity);
                 Events::MultiBallLost e;
                 EventBroker->Publish(e);
@@ -153,8 +149,6 @@ void dd::Systems::BallSystem::UpdateEntity(double dt, EntityID entity, EntityID
         auto life = m_World->GetComponent<Components::Life>(entity);
         if (life != nullptr) {
             if (life->Number + 1 == PastLives()) {
-                m_World->RemoveComponent<Components::Life>(entity);
-                m_World->RemoveComponent<Components::Transform>(entity);
                 m_World->RemoveEntity(entity);
                 SetPastLives(Lives());
             }
@@ -236,6 +230,9 @@ bool dd::Systems::BallSystem::Contact(const Events::Contact &event)
     glm::vec2 ballVelocity = glm::vec2(ballTransform->Velocity.x, ballTransform->Velocity.y);
 
     if (m_World->GetProperty<std::string>(otherEntitiy, "Name") == "Pad"){
+        Events::HitPad e;
+        EventBroker->Publish(e);
+
         auto padTransform = m_World->GetComponent<Components::Transform>(otherEntitiy);
         float x = (ballTransform->Position.x - padTransform->Position.x) * XMovementMultiplier();
 
@@ -263,25 +260,6 @@ EntityID dd::Systems::BallSystem::CreateBall()
 
     m_World->RemoveComponent<Components::Template>(ent);
 
-   /* auto ent = m_World->CreateEntity();
-    std::shared_ptr<Components::Transform> transform = m_World->AddComponent<Components::Transform>(ent);
-    transform->Position = glm::vec3(0.5f, 0.26f, -10.f);
-    transform->Scale = glm::vec3(0.5f, 0.5f, 0.5f);
-    auto model = m_World->AddComponent<Components::Model>(ent);
-    model->ModelFile = "Models/Test/Ball/Ballopus.obj";
-    //auto pointlight = m_World->AddComponent<Components::PointLight>(ent);
-    std::shared_ptr<Components::CircleShape> circleShape = m_World->AddComponent<Components::CircleShape>(ent);
-    std::shared_ptr<Components::Ball> cball = m_World->AddComponent<Components::Ball>(ent);
-    std::shared_ptr<Components::Physics> physics = m_World->AddComponent<Components::Physics>(ent);
-    physics->Static = false;
-    physics->Category = CollisionLayer::Type::Ball;
-    physics->Mask = CollisionLayer::Type::Pad | CollisionLayer::Type::Brick | CollisionLayer::Type::Wall;
-    physics->Calculate = true;
-    cball->Speed = 5.f;
-
-    auto plight = m_World->AddComponent<Components::PointLight>(ent);
-    plight->Radius = 2.f;*/
-
     m_World->CommitEntity(ent);
 
     return ent;

src/game/Game/LevelSystem.cpp

@@ -17,6 +17,7 @@ void dd::Systems::LevelSystem::Initialize()
     EVENT_SUBSCRIBE_MEMBER(m_EPowerUpTaken, &LevelSystem::OnPowerUpTaken);
     EVENT_SUBSCRIBE_MEMBER(m_EStageCleared, &LevelSystem::OnStageCleared);
     EVENT_SUBSCRIBE_MEMBER(m_EPause, &LevelSystem::OnPause);
+    EVENT_SUBSCRIBE_MEMBER(m_EHitPad, &LevelSystem::OnHitPad);
 
     return;
 }
@@ -24,7 +25,9 @@ void dd::Systems::LevelSystem::Initialize()
 void dd::Systems::LevelSystem::Update(double dt)
 {
     if (!m_Initialized) {
-        CreateBasicLevel(Rows(), Lines(), SpaceBetweenBricks(), SpaceToEdge());
+        //CreateBasicLevel(Rows(), Lines(), SpaceBetweenBricks(), SpaceToEdge());
+        GetNextLevel();
+        CreateLevel();
         m_Initialized = true;
     }
 }
@@ -38,36 +41,20 @@ void dd::Systems::LevelSystem::UpdateEntity(double dt, EntityID entity, EntityID
     if (templateCheck != nullptr){ return; }
 
     auto ball = m_World->GetComponent<Components::Ball>(entity);
-    SetNotResettingTheStage(NotResettingTheStage() + 0.01 * dt);
 
-    if (NumberOfBricks() <= 0 && Restarting() == false) {
+    if (NumberOfBricks() <= 0 && !Restarting()) {
         if (MultiBalls() <= 0 && PowerUps() <= 0) {
-            if (NotResettingTheStage() > 5) {
+            Events::StageCleared ec;
-                SetRestarting(true);
+            EventBroker->Publish(ec);
-                Events::ResetBall e;
+            //CreateBasicLevel(Rows(), Lines(), SpaceBetweenBricks(), SpaceToEdge());
-                EventBroker->Publish(e);
-                Events::ScoreEvent es;
-                es.Score = 500;
-                EventBroker->Publish(es);
-                Events::StageCleared ec;
-                EventBroker->Publish(ec);
-                SetNotResettingTheStage(0);
-                //CreateBasicLevel(Rows(), Lines(), SpaceBetweenBricks(), SpaceToEdge());
-            }
         } else {
             if (ball != nullptr && MultiBalls() > 0) {
                 SetMultiBalls(MultiBalls()-1);
-                m_World->RemoveComponent<Components::Ball>(entity);
-                m_World->RemoveComponent<Components::Transform>(entity);
-                m_World->RemoveComponent<Components::CircleShape>(entity);
-                m_World->RemoveComponent<Components::Physics>(entity);
                 m_World->RemoveEntity(entity);
             } else {
                 auto powerUp = m_World->GetComponent<Components::PowerUp>(entity);
                 if (powerUp != nullptr) {
                     SetPowerUps(PowerUps() - 1);
-                    m_World->RemoveComponent<Components::PowerUp>(entity);
-                    m_World->RemoveComponent<Components::Transform>(entity);
                     m_World->RemoveEntity(entity);
                 }
             }
@@ -97,7 +84,7 @@ void dd::Systems::LevelSystem::CreateBasicLevel(int rows, int lines, glm::vec2 s
     for (int i = 0; i < rows; i++) {
         num--;
         for (int j = 0; j < Lines(); j++) {
-            CreateBrick(i, j, spacesBetweenBricks, spaceToEdge, num);
+            CreateBrick(i, j, spacesBetweenBricks, spaceToEdge, num, 1);
         }
         if (num == 1)
             num = Lines();
@@ -108,8 +95,31 @@ void dd::Systems::LevelSystem::CreateBasicLevel(int rows, int lines, glm::vec2 s
     return;
 }
 
-void dd::Systems::LevelSystem::CreateBrick(int row, int line, glm::vec2 spacesBetweenBricks, float spaceToEdge, int num)
+void dd::Systems::LevelSystem::CreateLevel()
 {
+    std::cout << "Loading level: " << m_CurrentLevel << std::endl;
+    SetNumberOfBricks(Rows() * Lines());
+    int num = Lines();
+    int getter = 0;
+
+    for (int i = 0; i < Rows(); i++) {
+        num--;
+        for (int j = 0; j < Lines(); j++) {
+            CreateBrick(i, j, SpaceBetweenBricks(), SpaceToEdge(), num, m_Bricks[getter]);
+            getter++;
+        }
+        if (num == 1)
+            num = Lines();
+    }
+    SetRestarting(false);
+}
+
+void dd::Systems::LevelSystem::CreateBrick(int row, int line, glm::vec2 spacesBetweenBricks, float spaceToEdge, int num, int typeInt)
+{
+    if (typeInt == 0) {
+        SetNumberOfBricks(NumberOfBricks() - 1);
+        return;
+    }
     auto brick = m_World->CreateEntity();
     std::shared_ptr<Components::Transform> transform = m_World->AddComponent<Components::Transform>(brick);
     auto model = m_World->AddComponent<Components::Model>(brick);
@@ -121,12 +131,11 @@ void dd::Systems::LevelSystem::CreateBrick(int row, int line, glm::vec2 spacesBe
     cPhys->Category = CollisionLayer::Type::Brick;
     cPhys->Mask = CollisionLayer::Type::Ball;
 
-    /*std::string fileName = "Textures/Bricks/";
-    fileName.append(std::to_string(num));
-    fileName.append(".png");*/
-    //sprite->SpriteFile =  fileName;
     model->ModelFile = "Models/Test/Brick/Brick.obj";
-    if ((line == 1 && row == 4) || (line == 3 && row == 2) || (line == 5 && row == 2)) {
+    /*if ((line == 1 && row == 4) || (line == 3 && row == 2) || (line == 5 && row == 2)) {
+        std::shared_ptr<Components::PowerUpBrick> cPow = m_World->AddComponent<Components::PowerUpBrick>(brick);
+    }*/
+    if (typeInt == 2) {
         std::shared_ptr<Components::PowerUpBrick> cPow = m_World->AddComponent<Components::PowerUpBrick>(brick);
     }
     float x = line * spacesBetweenBricks.x;
@@ -143,25 +152,9 @@ void dd::Systems::LevelSystem::CreateBrick(int row, int line, glm::vec2 spacesBe
     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 != nullptr) {
-        SetNumberOfBricks(NumberOfBricks() - 1);
-        Events::ScoreEvent es;
-        es.Score = brick->Score;
-        EventBroker->Publish(es);
-        if (numberOfBricks < 1) {
-            EndLevel();
-        }
-    }
-    return;*/
 }
 
 bool dd::Systems::LevelSystem::OnContact(const dd::Events::Contact &event)
@@ -204,7 +197,7 @@ bool dd::Systems::LevelSystem::OnContact(const dd::Events::Contact &event)
         EventBroker->Publish(e);
     }
 
-    if (ball != nullptr && Restarting() == false) {
+    if (!Restarting()) {
         ball->Combo += 1;
         Events::ComboEvent ec;
         ec.Combo = ball->Combo;
@@ -213,12 +206,6 @@ bool dd::Systems::LevelSystem::OnContact(const dd::Events::Contact &event)
 
         auto ballTransform = m_World->GetComponent<Components::Transform>(entityBall);
 
-//        m_World->RemoveComponent<Components::Brick>(entityBrick);
-//        m_World->RemoveComponent<Components::Transform>(entityBrick);
-//        m_World->RemoveComponent<Components::RectangleShape>(entityBrick);
-//        m_World->RemoveComponent<Components::Physics>(entityBrick);
-//        m_World->RemoveEntity(entityBrick);
-
         auto physicsComponent = m_World->GetComponent<Components::Physics>(entityBrick);
         physicsComponent->GravityScale = 1.f;
         physicsComponent->Mask = CollisionLayer::Type::Water | CollisionLayer::Type::Wall;
@@ -239,17 +226,14 @@ bool dd::Systems::LevelSystem::OnContact(const dd::Events::Contact &event)
 
 
         SetNumberOfBricks(NumberOfBricks() - 1);
-        if (NumberOfBricks() <= 0) {
-            //SetMultiBalls(MultiBalls() + 1);
-        }
         Events::ScoreEvent es;
         es.Score = brick->Score * ball->Combo;
         EventBroker->Publish(es);
 
-        std::cout << "Combo: " << ball->Combo << std::endl;
+        //std::cout << "Combo: " << ball->Combo << std::endl;
         //std::cout << NumberOfBricks() << std::endl;
         //std::cout << "Brick Score: " << brick->Score  << std::endl;
-        std::cout << "Score: " << Score() << std::endl;
+        //std::cout << "Score: " << Score() << std::endl;
     }
 
     return true;
@@ -265,14 +249,12 @@ bool dd::Systems::LevelSystem::OnScoreEvent(const dd::Events::ScoreEvent &event)
 bool dd::Systems::LevelSystem::OnMultiBall(const dd::Events::MultiBall &event)
 {
     SetMultiBalls(MultiBalls()+2);
-    std::cout << MultiBalls() << std::endl;
     return true;
 }
 
 bool dd::Systems::LevelSystem::OnMultiBallLost(const dd::Events::MultiBallLost &event)
 {
     SetMultiBalls(MultiBalls()-1);
-    std::cout << MultiBalls() << std::endl;
     return true;
 }
 
@@ -290,7 +272,6 @@ bool dd::Systems::LevelSystem::OnCreatePowerUp(const dd::Events::CreatePowerUp &
 
     std::shared_ptr<Components::PowerUp> cPow = m_World->AddComponent<Components::PowerUp>(powerUp);
 
-
     transform->Position = event.Position;
     transform->Scale = glm::vec3(0.2, 0.2, 0.2);
     transform->Velocity = glm::vec3(0, -4, 0);
@@ -310,13 +291,119 @@ bool dd::Systems::LevelSystem::OnPowerUpTaken(const dd::Events::PowerUpTaken &ev
 
 bool dd::Systems::LevelSystem::OnStageCleared(const dd::Events::StageCleared &event)
 {
+    if (!m_Cleared) {
+        m_Cleared = true;
+        SetRestarting(true);
+        Events::ResetBall e;
+        EventBroker->Publish(e);
+        Events::ScoreEvent es;
+        es.Score = 500;
+        EventBroker->Publish(es);
+        m_CurrentLevel++;
+        if (m_CurrentLevel < 6) {
+            GetNextLevel();
+            CreateLevel();
+        }
+    }
     return true;
 }
 
-void dd::Systems::LevelSystem::EndLevel()
+void dd::Systems::LevelSystem::GetNextLevel()
 {
-    Events::StageCleared e;
+    std::array<int, 42> level;
-    EventBroker->Publish(e);
+    if (m_CurrentCluster == 1) {
-    return;
+        if (m_CurrentLevel == 1) {
+            level =
+                    {0, 0, 0, 0, 0, 0, 0,
+                     0, 0, 0, 0, 0, 0, 0,
+                     0, 0, 0, 1, 0, 0, 0,
+                     0, 0, 0, 0, 0, 0, 0,
+                     0, 0, 0, 0, 0, 0, 0,
+                     0, 0, 0, 0, 0, 0, 0};
+        } else if (m_CurrentLevel == 2) {
+            level =
+                    {1, 0, 0, 0, 0, 0, 0,
+                     0, 0, 0, 0, 0, 0, 0,
+                     0, 0, 0, 0, 0, 0, 0,
+                     0, 0, 0, 0, 0, 0, 0,
+                     0, 0, 0, 0, 0, 0, 0,
+                     0, 0, 0, 0, 0, 0, 0};
+        } else if (m_CurrentLevel == 3) {
+            level =
+                    {0, 0, 0, 0, 0, 0, 1,
+                     0, 0, 0, 0, 0, 0, 0,
+                     0, 0, 0, 0, 0, 0, 0,
+                     0, 0, 0, 0, 0, 0, 0,
+                     0, 0, 0, 0, 0, 0, 0,
+                     0, 0, 0, 0, 0, 0, 0};
+        } else if (m_CurrentLevel == 4) {
+            level =
+                    {0, 0, 0, 0, 0, 0, 0,
+                     0, 0, 0, 0, 0, 0, 0,
+                     0, 0, 0, 0, 0, 0, 0,
+                     0, 0, 0, 0, 0, 0, 0,
+                     0, 0, 0, 0, 0, 0, 0,
+                     1, 0, 0, 0, 0, 0, 0};
+        } else if (m_CurrentLevel == 5) {
+            level =
+                    {0, 0, 0, 0, 0, 0, 0,
+                     0, 0, 0, 0, 0, 0, 0,
+                     0, 0, 0, 0, 0, 0, 0,
+                     0, 0, 0, 0, 0, 0, 0,
+                     0, 0, 0, 0, 0, 0, 0,
+                     0, 0, 0, 0, 0, 0, 1};
+        }
+    } else if (m_CurrentCluster == 2) {
+        if (m_CurrentLevel == 1) {
+            level =
+                    {1, 1, 0, 0, 0, 1, 1,
+                     1, 1, 1, 0, 1, 1, 1,
+                     1, 1, 1, 1, 1, 1, 1,
+                     1, 2, 1, 2, 1, 2, 1,
+                     1, 1, 0, 0, 0, 1, 1,
+                     1, 0, 0, 0, 0, 0, 1};
+        } else if (m_CurrentLevel == 2) {
+            level =
+                    {1, 0, 0, 0, 0, 0, 1,
+                     0, 1, 0, 0, 0, 1, 0,
+                     0, 0, 2, 2, 2, 0, 0,
+                     0, 0, 0, 1, 0, 0, 0,
+                     0, 0, 0, 0, 0, 0, 0,
+                     0, 0, 0, 0, 0, 0, 0};
+        } else if (m_CurrentLevel == 3) {
+            level =
+                    {2, 0, 0, 0, 0, 0, 2,
+                     0, 1, 0, 0, 0, 1, 0,
+                     1, 2, 1, 1, 1, 2, 1,
+                     1, 0, 1, 1, 1, 0, 1,
+                     1, 0, 1, 1, 1, 0, 1,
+                     1, 0, 1, 1, 1, 0, 1};
+        } else if (m_CurrentLevel == 4) {
+            level =
+                    {1, 2, 1, 1, 1, 2, 1,
+                     1, 0, 1, 1, 1, 0, 1,
+                     1, 2, 1, 1, 1, 2, 1,
+                     1, 0, 1, 1, 1, 0, 1,
+                     1, 0, 0, 0, 0, 0, 1,
+                     0, 1, 1, 0, 1, 1, 0};
+        } else if (m_CurrentLevel == 5) {
+            level =
+                    {1, 0, 1, 0, 1, 0, 1,
+                     0, 1, 0, 1, 0, 1, 0,
+                     2, 0, 1, 0, 1, 0, 2,
+                     0, 1, 0, 2, 0, 1, 0,
+                     1, 0, 1, 0, 1, 0, 1,
+                     0, 1, 0, 1, 0, 1, 0};
+        }
+    } else if (m_CurrentCluster == 3) {
+
+    }
+
+    std::copy(std::begin(level), std::end(level), std::begin(m_Bricks));
 }
 
+bool dd::Systems::LevelSystem::OnHitPad(const dd::Events::HitPad &event)
+{
+    m_Cleared = false;
+    return true;
+}

src/game/Game/PadSystem.cpp

@@ -252,9 +252,6 @@ bool dd::Systems::PadSystem::OnContactPowerUp(const dd::Events::Contact &event)
         return false;
     }
 
-//    m_World->RemoveComponent<Components::PowerUp>(entityPower);
-//    m_World->RemoveComponent<Components::CircleShape>(entityPower);
-//    m_World->RemoveComponent<Components::Physics>(entityPower);
     m_World->RemoveEntity(entityPower);
     Events::PowerUpTaken ep;
     ep.Name = "Something";