Remove Components upon removing entities, a lot of strange experimenting to remove frozen squid bug.

include/Core/Engine.h

@@ -123,7 +123,7 @@ public:
         {
             auto ent = m_World->CreateEntity();
             std::shared_ptr<Components::Transform> transform = m_World->AddComponent<Components::Transform>(ent);
-            transform->Position = glm::vec3(-0.f, 0.f, -10.f);
+            transform->Position = glm::vec3(-0.f, 0.26f, -10.f);
 			transform->Scale = glm::vec3(0.5f, 0.5f, 0.5f);
 			transform->Velocity = glm::vec3(0.0f, -10.f, 0.f);
 
@@ -166,7 +166,7 @@ public:
 		{
 			auto topWall = m_World->CreateEntity();
 			std::shared_ptr<Components::Transform> transform = m_World->AddComponent<Components::Transform>(topWall);
-			transform->Position = glm::vec3(0.f, 5.5f, -10.f);
+			transform->Position = glm::vec3(0.f, 6.f, -10.f);
 			transform->Scale = glm::vec3(20.f, 0.5f, 1.f);
 
 			std::shared_ptr<Components::Sprite> sprite = m_World->AddComponent<Components::Sprite>(topWall);

include/Game/CBrick.h

@@ -18,6 +18,7 @@ struct Brick : Component
     int Points = 10;
     int Hits = 1;
     int Score = 50;
+    bool Removed = false;
 };
 
 }

include/Game/LevelSystem.h

@@ -75,6 +75,8 @@ public:
     void Update(double dt) override;
     void UpdateEntity(double dt, EntityID entity, EntityID parent) override;
 
+    bool Restarting() const { return m_Restarting; }
+    void SetRestarting(const bool& restarting) { m_Restarting = restarting; }
     bool Initialized() const { return m_Initialized; }
     void SetInitialized(const bool& initialized) { m_Initialized = initialized; }
     int& Lives() { return m_Lives; }
@@ -98,8 +100,13 @@ public:
 
     glm::vec2& SpaceBetweenBricks() { return m_SpaceBetweenBricks; }
     void SetSpaceBetweenBricks(const glm::vec2& spaceBetweenBricks) { m_SpaceBetweenBricks = spaceBetweenBricks; }
+    float& EdgeX() { return m_EdgeX; }
+    void SetEdgeX(const float& edgeX) { m_EdgeX = edgeX; }
+    float& EdgeY() { return m_EdgeY; }
+    void SetEdgeY(const float& edgeY) { m_EdgeY = edgeY; }
 
 private:
+    bool m_Restarting = false;
     bool m_Initialized = false;
     int m_Lives = 3;
     int m_PastLives = 3;
@@ -110,7 +117,9 @@ private:
     int m_Rows = 6;
     int m_Lines = 7;
     float m_SpaceToEdge = 0.25f;
-    glm::vec2 m_SpaceBetweenBricks = glm::vec2(1, 0.5);
+    glm::vec2 m_SpaceBetweenBricks = glm::vec2(1, 0.4);
+    float m_EdgeX = 3.2f;
+    float m_EdgeY = 5.2f;
 
     dd::EventRelay<LevelSystem, dd::Events::Contact> m_EContact;
     dd::EventRelay<LevelSystem, dd::Events::LifeLost> m_ELifeLost;
@@ -118,6 +127,7 @@ private:
     dd::EventRelay<LevelSystem, dd::Events::MultiBall> m_EMultiBall;
     dd::EventRelay<LevelSystem, dd::Events::CreatePowerUp> m_ECreatePowerUp;
     dd::EventRelay<LevelSystem, dd::Events::PowerUpTaken> m_EPowerUpTaken;
+    dd::EventRelay<LevelSystem, dd::Events::StageCleared> m_EStageCleared;
 
     bool OnContact(const dd::Events::Contact &event);
     bool OnLifeLost(const dd::Events::LifeLost &event);
@@ -125,6 +135,7 @@ private:
     bool OnMultiBall(const dd::Events::MultiBall &event);
     bool OnCreatePowerUp(const dd::Events::CreatePowerUp &event);
     bool OnPowerUpTaken(const dd::Events::PowerUpTaken &event);
+    bool OnStageCleared(const dd::Events::StageCleared &event);
 };
 
 }

include/Game/PadSystem.h

@@ -26,6 +26,7 @@
 #include "Game/EResetBall.h"
 #include "Game/EMultiBall.h"
 #include "Game/EPowerUpTaken.h"
+#include "Game/EStageCleared.h"
 
 
 namespace dd
@@ -78,6 +79,7 @@ private:
     dd::EventRelay<PadSystem, dd::Events::Contact> m_EContactPowerUp;
     dd::EventRelay<PadSystem, dd::Events::ResetBall> m_EResetBall;
     dd::EventRelay<PadSystem, dd::Events::MultiBall> m_EMultiBall;
+    dd::EventRelay<PadSystem, dd::Events::StageCleared> m_EStageCleared;
 
     bool OnKeyDown(const dd::Events::KeyDown &event);
     bool OnKeyUp(const dd::Events::KeyUp &event);
@@ -86,6 +88,7 @@ private:
     bool OnContactPowerUp(const dd::Events::Contact &event);
     bool OnResetBall(const dd::Events::ResetBall &event);
     bool OnMultiBall(const dd::Events::MultiBall &event);
+    bool OnStageCleared(const dd::Events::StageCleared &event);
 
     class PadSteeringInputController;
     std::array<std::shared_ptr<PadSteeringInputController>, 4> m_PadInputControllers;

src/game/Game/LevelSystem.cpp

@@ -15,6 +15,7 @@ void dd::Systems::LevelSystem::Initialize()
     EVENT_SUBSCRIBE_MEMBER(m_EMultiBall, LevelSystem::OnMultiBall);
     EVENT_SUBSCRIBE_MEMBER(m_ECreatePowerUp, LevelSystem::OnCreatePowerUp);
     EVENT_SUBSCRIBE_MEMBER(m_EPowerUpTaken, LevelSystem::OnPowerUpTaken);
+    EVENT_SUBSCRIBE_MEMBER(m_EStageCleared, LevelSystem::OnStageCleared);
 
     for (int i = 0; i < Lives(); i++) {
         CreateLife(i);
@@ -59,69 +60,98 @@ void dd::Systems::LevelSystem::UpdateEntity(double dt, EntityID entity, EntityID
 {
     auto ball = m_World->GetComponent<Components::Ball>(entity);
 
-    if (ball != NULL) {
+    if (ball != nullptr) {
         auto transformBall = m_World->GetComponent<Components::Transform>(entity);
-        if (transformBall->Position.y < -10) {
+        if (glm::abs(transformBall->Velocity.y) < 2) {
+            if (transformBall->Velocity.y > 0) {
+                transformBall->Velocity.y = 2;
+            } else {
+                transformBall->Velocity.y = -2;
+            }
+        }
+        if (transformBall->Position.y < -EdgeY() - 4) {
             if (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 if (Lives() == PastLives()) {
+                Events::ResetBall be;
+                EventBroker->Publish(be);
                 Events::LifeLost e;
                 e.Entity = entity;
                 EventBroker->Publish(e);
-                Events::ResetBall be;
-                EventBroker->Publish(be);
                 return;
             }
-        } else if (transformBall->Position.x > 3.2) {
+        } else if (transformBall->Position.x > EdgeX()) {
             if (transformBall->Velocity.x > 0) {
                 glm::vec2 reflectedVelocity = glm::reflect(glm::vec2(transformBall->Velocity.x, transformBall->Velocity.y), glm::vec2(1, 0));
                 transformBall->Velocity = glm::vec3(reflectedVelocity, 0.f);
             }
-        } else if (transformBall->Position.x < -3.2) {
+        } else if (transformBall->Position.x < -EdgeX()) {
             if (transformBall->Velocity.x < 0) {
                 glm::vec2 reflectedVelocity = glm::reflect(glm::vec2(transformBall->Velocity.x, transformBall->Velocity.y), glm::vec2(-1, 0));
                 transformBall->Velocity = glm::vec3(reflectedVelocity, 0.f);
             }
+        } else if (transformBall->Position.y > EdgeY()) {
+            if (transformBall->Velocity.y > 0) {
+                glm::vec2 reflectedVelocity = glm::reflect(glm::vec2(transformBall->Velocity.x, transformBall->Velocity.y), glm::vec2(0, 1));
+                transformBall->Velocity = glm::vec3(reflectedVelocity, 0.f);
+            }
         }
     }
 
     if (Lives() != PastLives()) {
         auto life = m_World->GetComponent<Components::Life>(entity);
-        if (life != NULL) {
+        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());
             }
         }
     }
     if (NumberOfBricks() <= 0) {
+        /*SetRestarting(true);
         if (MultiBalls() <= 0 && PowerUps() <= 0) {
+            Events::ResetBall e;
+            EventBroker->Publish(e);
             Events::ScoreEvent es;
             es.Score = 500;
             EventBroker->Publish(es);
-            Events::ResetBall e;
+            Events::StageCleared ec;
-            EventBroker->Publish(e);
+            EventBroker->Publish(ec);
             CreateBasicLevel(Rows(), Lines(), SpaceBetweenBricks(), SpaceToEdge());
         } else {
-            if (ball != NULL && MultiBalls() > 0) {
+            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);
+                auto transformBall = m_World->GetComponent<Components::Transform>(entity);
             } else {
                 auto powerUp = m_World->GetComponent<Components::PowerUp>(entity);
-                if (powerUp != NULL) {
+                if (powerUp != nullptr) {
                     SetPowerUps(PowerUps() - 1);
+                    m_World->RemoveComponent<Components::PowerUp>(entity);
+                    m_World->RemoveComponent<Components::Transform>(entity);
                     m_World->RemoveEntity(entity);
                 }
             }
-        }
+        }*/
     }
 }
 
 void dd::Systems::LevelSystem::CreateBasicLevel(int rows, int lines, glm::vec2 spacesBetweenBricks, float spaceToEdge)
 {
-    int num = 0;
     SetNumberOfBricks(rows * lines);
+    std::cout << "You're only doing this once, right?" << std::endl;
+    int num = 0;
     for (int i = 0; i < rows; i++) {
         num++;
         for (int j = 0; j < Lines(); j++) {
@@ -131,6 +161,8 @@ void dd::Systems::LevelSystem::CreateBasicLevel(int rows, int lines, glm::vec2 s
             num = 0;
     }
 
+    SetNumberOfBricks(rows * lines);
+    SetRestarting(false);
     return;
 }
 
@@ -173,13 +205,16 @@ void dd::Systems::LevelSystem::ProcessCollision()
 
 void dd::Systems::LevelSystem::OnEntityRemoved(EntityID entity)
 {
-    /*auto brick = m_World->GetComponent<Components::Brick>(entity);
+    auto brick = m_World->GetComponent<Components::Brick>(entity);
-    if (brick != NULL) {
+    if (brick != nullptr) {
-        numberOfBricks--;
+        SetNumberOfBricks(NumberOfBricks() - 1);
-        if (numberOfBricks < 1) {
+        Events::ScoreEvent es;
+        es.Score = brick->Score;
+        EventBroker->Publish(es);
+        /*if (numberOfBricks < 1) {
             EndLevel();
-        }
+        }*/
-    }*/
+    }
     return;
 }
 
@@ -189,21 +224,21 @@ bool dd::Systems::LevelSystem::OnContact(const dd::Events::Contact &event)
     EntityID entityBall;
     auto ball = m_World->GetComponent<Components::Ball>(event.Entity2);
     auto brick = m_World->GetComponent<Components::Brick>(event.Entity1);
-    if (brick != NULL) {
+    if (brick != nullptr) {
         entityBrick = event.Entity1;
     } else {
         brick = m_World->GetComponent<Components::Brick>(event.Entity2);
-        if (brick != NULL) {
+        if (brick != nullptr) {
             entityBrick = event.Entity2;
         } else {
             return false;
         }
     }
-    if (ball != NULL) {
+    if (ball != nullptr) {
         entityBall = event.Entity2;
     } else {
         ball = m_World->GetComponent<Components::Ball>(event.Entity1);
-        if (ball != NULL) {
+        if (ball != nullptr) {
             entityBall = event.Entity1;
         } else {
             return false;
@@ -211,27 +246,37 @@ bool dd::Systems::LevelSystem::OnContact(const dd::Events::Contact &event)
     }
 
     brick = m_World->GetComponent<Components::Brick>(entityBrick);
-    if (brick == NULL) {
+    if (brick == nullptr) {
         return false;
     }
 
     auto power = m_World->GetComponent<Components::PowerUpBrick>(entityBrick);
-    if (power != NULL) {
+    if (power != nullptr) {
         Events::CreatePowerUp e;
         auto transform = m_World->GetComponent<Components::Transform>(entityBrick);
         e.Position = transform->Position;
         EventBroker->Publish(e);
     }
 
-    if (ball != NULL) {
+    if (ball != nullptr && Restarting() == false) {
+        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);
 
         SetNumberOfBricks(NumberOfBricks() - 1);
+        if (NumberOfBricks() <= 0) {
+            SetMultiBalls(MultiBalls() + 1);
+        }
         Events::ScoreEvent es;
         es.Score = brick->Score;
         EventBroker->Publish(es);
 
-        std::cout << "Score: " << Score() << std::endl;
+        std::cout << NumberOfBricks() << std::endl;
+        //std::cout << "Score: " << Score() << std::endl;
     }
 
     return true;
@@ -269,16 +314,12 @@ bool dd::Systems::LevelSystem::OnCreatePowerUp(const dd::Events::CreatePowerUp &
 
     transform->Position = event.Position;
     transform->Scale = glm::vec3(0.2, 0.2, 0.2);
+    transform->Velocity = glm::vec3(0, -4, 0);
 
     model->ModelFile = "Models/Test/Ball/Ballopus.obj";
 
     m_World->CommitEntity(powerUp);
 
-    Events::SetImpulse e;
-    e.Entity = powerUp;
-    e.Impulse = glm::vec2(0, -0.05);
-    e.Point = glm::vec2(transform->Position.x, transform->Position.y);
-    EventBroker->Publish(e);
     return true;
 }
 
@@ -288,6 +329,11 @@ bool dd::Systems::LevelSystem::OnPowerUpTaken(const dd::Events::PowerUpTaken &ev
     return true;
 }
 
+bool dd::Systems::LevelSystem::OnStageCleared(const dd::Events::StageCleared &event)
+{
+    return true;
+}
+
 void dd::Systems::LevelSystem::EndLevel()
 {
     Events::StageCleared e;

src/game/Game/PadSystem.cpp

@@ -28,17 +28,18 @@ void dd::Systems::PadSystem::Initialize()
     EVENT_SUBSCRIBE_MEMBER(m_EContactPowerUp, &PadSystem::OnContactPowerUp);
     EVENT_SUBSCRIBE_MEMBER(m_EResetBall, &PadSystem::OnResetBall);
     EVENT_SUBSCRIBE_MEMBER(m_EMultiBall, &PadSystem::OnMultiBall);
+    EVENT_SUBSCRIBE_MEMBER(m_EStageCleared, &PadSystem::OnStageCleared);
 }
 
 void dd::Systems::PadSystem::UpdateEntity(double dt, EntityID entity, EntityID parent)
 {
     auto ball = m_World->GetComponent<Components::Ball>(entity);
-    if (ball != NULL) {
+    if (ball != nullptr) {
         if (ReplaceBall() == true) {
             SetReplaceBall(false);
 
             auto transform = m_World->GetComponent<Components::Transform>(entity);
-            transform->Position = glm::vec3(0.0f, 0.f, -10.f);
+            transform->Position = glm::vec3(0.0f, 0.26f, -10.f);
             transform->Velocity = glm::vec3(0.0f, -ball->Speed, 0.f);
         }
     }
@@ -98,7 +99,7 @@ EntityID dd::Systems::PadSystem::CreateBall()
 {
     auto ent = m_World->CreateEntity();
     std::shared_ptr<Components::Transform> transform = m_World->AddComponent<Components::Transform>(ent);
-    transform->Position = glm::vec3(0.5f, 0.f, -10.f);
+    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";
@@ -134,6 +135,8 @@ bool dd::Systems::PadSystem::OnKeyDown(const dd::Events::KeyDown &event)
         SetReplaceBall(true);
     } else if (val == GLFW_KEY_M) {
         SetMultiBall(true);
+    } else if (val == GLFW_KEY_D) {
+        return false;
     }
     return true;
 }
@@ -205,19 +208,19 @@ bool dd::Systems::PadSystem::OnContactPowerUp(const dd::Events::Contact &event)
     EntityID entityPad;
     auto powerUp = m_World->GetComponent<Components::PowerUp>(event.Entity1);
     auto pad = m_World->GetComponent<Components::Pad>(event.Entity2);
-    if (powerUp != NULL) {
+    if (powerUp != nullptr) {
         entityPower = event.Entity1;
     } else {
         powerUp = m_World->GetComponent<Components::PowerUp>(event.Entity2);
-        if (powerUp != NULL) {
+        if (powerUp != nullptr) {
             entityPower = event.Entity2;
         }
     }
-    if (pad != NULL) {
+    if (pad != nullptr) {
         entityPad = event.Entity2;
     } else {
         pad = m_World->GetComponent<Components::Pad>(event.Entity1);
-        if (pad != NULL) {
+        if (pad != nullptr) {
             entityPad = event.Entity1;
         }
     }
@@ -227,10 +230,13 @@ bool dd::Systems::PadSystem::OnContactPowerUp(const dd::Events::Contact &event)
     }
 
     pad = m_World->GetComponent<Components::Pad>(entityPad);
-    if (pad == NULL) {
+    if (pad == nullptr) {
         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";
@@ -255,23 +261,31 @@ bool dd::Systems::PadSystem::OnMultiBall(const dd::Events::MultiBall &event)
     auto ent2 = CreateBall();
     auto transform1 = m_World->GetComponent<Components::Transform>(ent1);
     auto transform2 = m_World->GetComponent<Components::Transform>(ent2);
+    auto ball1 = m_World->GetComponent<Components::Ball>(ent1);
+    auto ball2 = m_World->GetComponent<Components::Ball>(ent2);
     auto padTransform = event.padTransform;
-    float x1 = padTransform->Position.x - 3, x2 = padTransform->Position.x + 3;
+    float x1 = padTransform->Position.x - 2, x2 = padTransform->Position.x + 2;
-    if (x1 < -3.5) {
+    if (x1 < -3.1) {
-        x1 = 3.5;
+        x1 = 3;
     }
-    if (x2 > 3.5) {
+    if (x2 > 3.1) {
-        x2 = -3.5;
+        x2 = -3;
     }
-    transform1->Position = glm::vec3(x1, -5, -10);
+    transform1->Position = glm::vec3(x1, -5.5, -10);
-    transform2->Position = glm::vec3(x2, -5, -10);
+    transform2->Position = glm::vec3(x2, -5.5, -10);
 
-    transform1->Velocity = glm::vec3(5, 5, 0);
+    transform1->Velocity = glm::normalize(glm::vec3(5, 5 ,0.f)) * ball1->Speed;
-    transform2->Velocity = glm::vec3(-5, 5, 0);
+    transform2->Velocity = glm::normalize(glm::vec3(-5, 5 ,0.f)) * ball2->Speed;
 
     return true;
 }
 
+bool dd::Systems::PadSystem::OnStageCleared(const dd::Events::StageCleared &event)
+{
+    auto entity = CreateBall();
+    return true;
+}
+
 bool dd::Systems::PadSystem::PadSteeringInputController::OnCommand(const Events::InputCommand &event)
 {
     std::string command = event.Command;