CPowerUpBrick + CPowerUp exists. Can drop from brick and be grabbed for MultiBall.

include/Core/Engine.h

@@ -42,8 +42,9 @@
 #include "Game/LevelSystem.h"
 #include "Game/PadSystem.h"
 #include "Game/CBall.h"
-#include "Game/CBrick.h"
 #include "Game/CPad.h"
+#include "Game/CBrick.h"
+#include "Game/Bricks/CPowerUpBrick.h"
 
 #include "Physics/PhysicsSystem.h"
 #include "Physics/CPhysics.h"
@@ -90,6 +91,10 @@ public:
 		m_World->ComponentFactory.Register<Components::Brick>();
 		m_World->ComponentFactory.Register<Components::Pad>();
 		m_World->ComponentFactory.Register<Components::Life>();
+
+		m_World->ComponentFactory.Register<Components::PowerUp>();
+		m_World->ComponentFactory.Register<Components::PowerUpBrick>();
+
         m_World->SystemFactory.Register<Systems::PhysicsSystem>(
                 [this]() { return new Systems::PhysicsSystem(m_World.get(), m_EventBroker); });
         m_World->AddSystem<Systems::PhysicsSystem>();

include/Game/Bricks/CPowerUpBrick.h

@@ -0,0 +1,25 @@
+//
+// Created by Administrator on 2015-09-22.
+//
+
+#ifndef DAYDREAM_CPOWERUPBRICK_H
+#define DAYDREAM_CPOWERUPBRICK_H
+
+#include "Core/Component.h"
+
+namespace dd
+{
+
+namespace Components
+{
+
+struct PowerUpBrick : Component
+{
+
+};
+
+}
+
+}
+
+#endif //DAYDREAM_CPOWERUPBRICK_H

include/Game/CPowerUp.h

@@ -0,0 +1,25 @@
+//
+// Created by Administrator on 2015-09-22.
+//
+
+#ifndef DAYDREAM_CPOWERUP_H
+#define DAYDREAM_CPOWERUP_H
+
+#include "Core/Component.h"
+
+namespace dd
+{
+
+namespace Components
+{
+
+struct PowerUp : Component
+{
+    int Type;
+};
+
+}
+
+}
+
+#endif //DAYDREAM_CPOWERUP_H

include/Game/ECreatePowerUp.h

@@ -0,0 +1,26 @@
+//
+// Created by Administrator on 2015-09-22.
+//
+
+#ifndef DAYDREAM_ECREATEPOWERUP_H
+#define DAYDREAM_ECREATEPOWERUP_H
+
+#include "Core/EventBroker.h"
+
+namespace dd
+{
+
+namespace Events
+{
+
+struct CreatePowerUp : Event
+{
+    glm::vec3 Position;
+
+};
+
+}
+
+}
+
+#endif //DAYDREAM_ECREATEPOWERUP_H

include/Game/EGameOver.h

@@ -0,0 +1,27 @@
+//
+// Created by Administrator on 2015-09-22.
+//
+
+#ifndef DAYDREAM_EGAMEOVER_H
+#define DAYDREAM_EGAMEOVER_H
+
+#include "Core/EventBroker.h"
+#include "Core/Entity.h"
+
+namespace dd
+{
+
+namespace Events
+{
+
+struct GameOver : Event
+{
+    EntityID Entity;
+
+};
+
+}
+
+}
+
+#endif //DAYDREAM_EGAMEOVER_H

include/Game/LevelSystem.h

@@ -7,24 +7,29 @@
 
 #include "Core/System.h"
 #include "Core/CTransform.h"
+#include "Core/EventBroker.h"
+#include "Core/World.h"
 #include "Rendering/CSprite.h"
 #include "Rendering/CModel.h"
 #include "Game/CBrick.h"
-#include "Core/EventBroker.h"
-#include "Core/World.h"
 #include "Game/CBall.h"
 #include "Game/CLife.h"
+#include "Game/CPowerUp.h"
 #include "Game/EStageCleared.h"
 #include "Game/ELifeLost.h"
 #include "Game/EResetBall.h"
 #include "Game/EScoreEvent.h"
 #include "Game/EMultiBall.h"
+#include "Game/EGameOver.h"
+#include "Game/ECreatePowerUp.h"
+#include "Game/Bricks/CPowerUpBrick.h"
 #include "Physics/CBoxShape.h"
 #include "Physics/CPhysics.h"
 #include "Physics/CCircleShape.h"
 #include "Physics/ESetImpulse.h"
 #include "Physics/EContact.h"
 #include "Sound/CCollisionSound.h"
+#include "Game/PadSystem.h"
 #include <fstream>
 #include <iostream>
 #include <intrin.h>
@@ -75,6 +80,8 @@ public:
     void SetLives(const int& lives) { m_Lives = lives; }
     int& PastLives() { return m_PastLives; }
     void SetPastLives(const int& pastLives) { m_PastLives = pastLives; }
+    int& MultiBalls() { return m_MultiBalls; }
+    void SetMultiBalls(const int& multiBalls) { m_MultiBalls = multiBalls; }
     int& Score() { return m_Score; }
     void SetScore(const int& score) { m_Score = score; }
     int& NumberOfBricks() { return m_NumberOfBricks; }
@@ -93,6 +100,7 @@ private:
     bool m_Initialized = false;
     int m_Lives = 3;
     int m_PastLives = 3;
+    int m_MultiBalls = 0;
     int m_Score = 0;
     int m_NumberOfBricks;
     int m_Rows = 7;
@@ -104,11 +112,13 @@ private:
     dd::EventRelay<LevelSystem, dd::Events::LifeLost> m_ELifeLost;
     dd::EventRelay<LevelSystem, dd::Events::ScoreEvent> m_EScoreEvent;
     dd::EventRelay<LevelSystem, dd::Events::MultiBall> m_EMultiBall;
+    dd::EventRelay<LevelSystem, dd::Events::CreatePowerUp> m_ECreatePowerUp;
 
     bool OnContact(const dd::Events::Contact &event);
-    bool LifeLost(const dd::Events::LifeLost &event);
-    bool ScoreEvent(const dd::Events::ScoreEvent &event);
-    bool MultiBall(const dd::Events::MultiBall &event);
+    bool OnLifeLost(const dd::Events::LifeLost &event);
+    bool OnScoreEvent(const dd::Events::ScoreEvent &event);
+    bool OnMultiBall(const dd::Events::MultiBall &event);
+    bool OnCreatePowerUp(const dd::Events::CreatePowerUp &event);
 };
 
 }

include/Game/PadSystem.h

@@ -21,8 +21,9 @@
 #include "Rendering/CSprite.h"
 #include "Rendering/CModel.h"
 #include "Game/CBall.h"
-#include "Game/EResetBall.h"
 #include "Game/CPad.h"
+#include "Game/CPowerUp.h"
+#include "Game/EResetBall.h"
 #include "Game/EMultiBall.h"
 
 
@@ -73,6 +74,7 @@ private:
     dd::EventRelay<PadSystem, dd::Events::KeyDown> m_EKeyDown;
     dd::EventRelay<PadSystem, dd::Events::KeyUp> m_EKeyUp;
     dd::EventRelay<PadSystem, dd::Events::Contact> m_EContact;
+    dd::EventRelay<PadSystem, dd::Events::Contact> m_EContactPowerUp;
     dd::EventRelay<PadSystem, dd::Events::ResetBall> m_EResetBall;
     dd::EventRelay<PadSystem, dd::Events::MultiBall> m_EMultiBall;
 
@@ -80,6 +82,7 @@ private:
     bool OnKeyUp(const dd::Events::KeyUp &event);
 
     bool OnContact(const dd::Events::Contact &event);
+    bool OnContactPowerUp(const dd::Events::Contact &event);
     bool OnResetBall(const dd::Events::ResetBall &event);
     bool OnMultiBall(const dd::Events::MultiBall &event);
 

src/game/CMakeLists.txt

@@ -87,7 +87,7 @@ set(SOURCE_FILES
     ${SOURCE_FILES_Transform}
     ${SOURCE_FILES_Physics}
     ${SOURCE_FILES_Game}
-    ${SOURCE_FILES_Sound})
+    ${SOURCE_FILES_Sound} ../../include/Game/EGameOver.h ../../include/Game/Bricks/CPowerUpBrick.h ../../include/Game/CPowerUp.h ../../include/Game/ECreatePowerUp.h)
 
 if(CMAKE_COMPILER_IS_GNUCXX)
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pthread")

src/game/Game/LevelSystem.cpp

@@ -10,9 +10,10 @@
 void dd::Systems::LevelSystem::Initialize()
 {
     EVENT_SUBSCRIBE_MEMBER(m_EContact, LevelSystem::OnContact);
-    EVENT_SUBSCRIBE_MEMBER(m_ELifeLost, LevelSystem::LifeLost);
-    EVENT_SUBSCRIBE_MEMBER(m_EScoreEvent, LevelSystem::ScoreEvent);
-    EVENT_SUBSCRIBE_MEMBER(m_EMultiBall, LevelSystem::MultiBall);
+    EVENT_SUBSCRIBE_MEMBER(m_ELifeLost, LevelSystem::OnLifeLost);
+    EVENT_SUBSCRIBE_MEMBER(m_EScoreEvent, LevelSystem::OnScoreEvent);
+    EVENT_SUBSCRIBE_MEMBER(m_EMultiBall, LevelSystem::OnMultiBall);
+    EVENT_SUBSCRIBE_MEMBER(m_ECreatePowerUp, LevelSystem::OnCreatePowerUp);
 
     for (int i = 0; i < Lives(); i++) {
         CreateLife(i);
@@ -46,6 +47,13 @@ void dd::Systems::LevelSystem::Update(double dt)
         CreateBasicLevel(Rows(), Lines(), SpaceBetweenBricks(), SpaceToEdge());
         m_Initialized = true;
     }
+
+    if (Lives() < 0)
+    {
+        Events::GameOver e;
+        EventBroker->Publish(e);
+        std::cout << "Game Over!" << std::endl;
+    }
 }
 
 void dd::Systems::LevelSystem::UpdateEntity(double dt, EntityID entity, EntityID parent)
@@ -55,7 +63,10 @@ void dd::Systems::LevelSystem::UpdateEntity(double dt, EntityID entity, EntityID
     if (ball != NULL) {
         auto transformBall = m_World->GetComponent<Components::Transform>(entity);
         if (transformBall->Position.y < -10) {
-            if (Lives() == PastLives()) {
+            if (MultiBalls() != 0) {
+                SetMultiBalls(MultiBalls() - 1);
+                m_World->RemoveEntity(entity);
+            } else if (Lives() == PastLives()) {
                 Events::LifeLost e;
                 e.Entity = entity;
                 EventBroker->Publish(e);
@@ -75,6 +86,21 @@ void dd::Systems::LevelSystem::UpdateEntity(double dt, EntityID entity, EntityID
             }
         }
     }
+    if (NumberOfBricks() <= 0) {
+        if (MultiBalls() <= 0) {
+            Events::ScoreEvent es;
+            es.Score = 500;
+            EventBroker->Publish(es);
+            Events::ResetBall e;
+            EventBroker->Publish(e);
+            CreateBasicLevel(Rows(), Lines(), SpaceBetweenBricks(), SpaceToEdge());
+        } else {
+            if (ball != NULL) {
+                SetMultiBalls(MultiBalls() - 1);
+                m_World->RemoveEntity(entity);
+            }
+        }
+    }
 }
 
 void dd::Systems::LevelSystem::CreateBasicLevel(int rows, int lines, glm::vec2 spacesBetweenBricks, int spaceToEdge)
@@ -107,6 +133,9 @@ void dd::Systems::LevelSystem::CreateBrick(int row, int line, glm::vec2 spacesBe
     fileName.append(".png");
     //sprite->SpriteFile =  fileName;
     model->ModelFile = "Models/Test/Brick/Brick.obj";
+    if (line == 1) {
+        std::shared_ptr<Components::PowerUpBrick> cPow = m_World->AddComponent<Components::PowerUpBrick>(brick);
+    }
     float x = spaceToEdge + line * spacesBetweenBricks.x;
     float y = spaceToEdge + row * spacesBetweenBricks.y;
     transform->Scale = glm::vec3(1.6, 0.35, 0.5);
@@ -141,50 +170,101 @@ void dd::Systems::LevelSystem::OnEntityRemoved(EntityID entity)
 
 bool dd::Systems::LevelSystem::OnContact(const dd::Events::Contact &event)
 {
-    EntityID entityBrick = event.Entity1;
-    auto brick = m_World->GetComponent<Components::Brick>(entityBrick);
+    EntityID entityBrick;
+    EntityID entityBall;
+    auto ball = m_World->GetComponent<Components::Ball>(event.Entity2);
+    auto brick = m_World->GetComponent<Components::Brick>(event.Entity1);
+    if (brick != NULL) {
+        entityBrick = event.Entity1;
+    } else {
+        brick = m_World->GetComponent<Components::Brick>(event.Entity2);
+        if (brick != NULL) {
+            entityBrick = event.Entity2;
+        } else {
+            return false;
+        }
+    }
+    if (ball != NULL) {
+        entityBall = event.Entity2;
+    } else {
+        ball = m_World->GetComponent<Components::Ball>(event.Entity1);
+        if (ball != NULL) {
+            entityBall = event.Entity1;
+        } else {
+            return false;
+        }
+    }
+
+    brick = m_World->GetComponent<Components::Brick>(entityBrick);
     if (brick == NULL) {
         return false;
     }
-    EntityID entityBall = event.Entity2;
 
-    m_World->RemoveEntity(entityBrick);
-
-    SetNumberOfBricks(NumberOfBricks() - 1);
-    if (NumberOfBricks() == 0) {
-        Events::ScoreEvent es;
-        es.Score = 500;
-        EventBroker->Publish(es);
-        Events::ResetBall e;
+    auto power = m_World->GetComponent<Components::PowerUpBrick>(entityBrick);
+    if (power != NULL) {
+        Events::CreatePowerUp e;
+        auto transform = m_World->GetComponent<Components::Transform>(entityBrick);
+        e.Position = transform->Position;
         EventBroker->Publish(e);
-        CreateBasicLevel(Rows(), Lines(), SpaceBetweenBricks(), SpaceToEdge());
     }
-    Events::ScoreEvent es;
-    es.Score = brick->Score;
-    EventBroker->Publish(es);
 
-    std::cout << "Score: " << Score() << std::endl;
+    if (ball)
+    {
+        m_World->RemoveEntity(entityBrick);
+
+        SetNumberOfBricks(NumberOfBricks() - 1);
+        Events::ScoreEvent es;
+        es.Score = brick->Score;
+        EventBroker->Publish(es);
+
+        std::cout << "Score: " << Score() << std::endl;
+    }
 
     return true;
 }
 
-bool dd::Systems::LevelSystem::LifeLost(const dd::Events::LifeLost &event)
+bool dd::Systems::LevelSystem::OnLifeLost(const dd::Events::LifeLost &event)
 {
     SetLives(Lives() - 1);
 
     return true;
 }
 
-bool dd::Systems::LevelSystem::ScoreEvent(const dd::Events::ScoreEvent &event)
+bool dd::Systems::LevelSystem::OnScoreEvent(const dd::Events::ScoreEvent &event)
 {
     SetScore(Score() += event.Score);
 
     return true;
 }
 
-bool dd::Systems::LevelSystem::MultiBall(const dd::Events::MultiBall &event)
+bool dd::Systems::LevelSystem::OnMultiBall(const dd::Events::MultiBall &event)
 {
+    SetMultiBalls(MultiBalls()+2);
+}
 
+bool dd::Systems::LevelSystem::OnCreatePowerUp(const dd::Events::CreatePowerUp &event)
+{
+    auto powerUp = m_World->CreateEntity();
+    std::shared_ptr<Components::Transform> transform = m_World->AddComponent<Components::Transform>(powerUp);
+    auto model = m_World->AddComponent<Components::Model>(powerUp);
+    std::shared_ptr<Components::CircleShape> cRec = m_World->AddComponent<Components::CircleShape>(powerUp);
+    std::shared_ptr<Components::Physics> cPhys = m_World->AddComponent<Components::Physics>(powerUp);
+    std::shared_ptr<Components::PowerUp> cPow = m_World->AddComponent<Components::PowerUp>(powerUp);
+    cPhys->Static = false;
+
+    transform->Position = event.Position;
+    transform->Scale = glm::vec3(0.25, 0.25, 0.25);
+
+    model->ModelFile = "Models/Test/Ball/Ballopus.obj";
+
+    m_World->CommitEntity(powerUp);
+
+    Events::SetImpulse e;
+    e.Entity = powerUp;
+    e.Impulse = glm::vec2(0, -0.25);
+    e.Point = glm::vec2(transform->Position.x, transform->Position.y);
+    EventBroker->Publish(e);
+    return true;
 }
 
 void dd::Systems::LevelSystem::EndLevel()

src/game/Game/PadSystem.cpp

@@ -25,6 +25,7 @@ void dd::Systems::PadSystem::Initialize()
     EVENT_SUBSCRIBE_MEMBER(m_EKeyDown, &PadSystem::OnKeyDown);
     EVENT_SUBSCRIBE_MEMBER(m_EKeyUp, &PadSystem::OnKeyUp);
     EVENT_SUBSCRIBE_MEMBER(m_EContact, &PadSystem::OnContact);
+    EVENT_SUBSCRIBE_MEMBER(m_EContactPowerUp, &PadSystem::OnContactPowerUp);
     EVENT_SUBSCRIBE_MEMBER(m_EResetBall, &PadSystem::OnResetBall);
     EVENT_SUBSCRIBE_MEMBER(m_EMultiBall, &PadSystem::OnMultiBall);
 }
@@ -209,6 +210,46 @@ bool dd::Systems::PadSystem::OnContact(const dd::Events::Contact &event)
     EventBroker->Publish(e);
 }
 
+bool dd::Systems::PadSystem::OnContactPowerUp(const dd::Events::Contact &event)
+{
+    EntityID entityPower;
+    EntityID entityPad;
+    auto powerUp = m_World->GetComponent<Components::PowerUp>(event.Entity1);
+    auto pad = m_World->GetComponent<Components::Pad>(event.Entity2);
+    if (powerUp != NULL) {
+        entityPower = event.Entity1;
+    } else {
+        powerUp = m_World->GetComponent<Components::PowerUp>(event.Entity2);
+        if (powerUp != NULL) {
+            entityPower = event.Entity2;
+        }
+    }
+    if (pad != NULL) {
+        entityPad = event.Entity2;
+    } else {
+        pad = m_World->GetComponent<Components::Pad>(event.Entity1);
+        if (pad != NULL) {
+            entityPad = event.Entity1;
+        }
+    }
+
+    if (entityPower == NULL || entityPad == NULL) {
+        return false;
+    }
+
+    pad = m_World->GetComponent<Components::Pad>(entityPad);
+    if (pad == NULL) {
+        return false;
+    }
+
+    m_World->RemoveEntity(entityPower);
+    Events::MultiBall e;
+    auto transform = m_World->GetComponent<Components::Transform>(entityPad);
+    e.padTransform = transform;
+    EventBroker->Publish(e);
+    return true;
+}
+
 bool dd::Systems::PadSystem::OnResetBall(const dd::Events::ResetBall &event)
 {
     SetReplaceBall(true);
@@ -222,8 +263,8 @@ bool dd::Systems::PadSystem::OnMultiBall(const dd::Events::MultiBall &event)
     auto transform1 = m_World->GetComponent<Components::Transform>(ent1);
     auto transform2 = m_World->GetComponent<Components::Transform>(ent2);
     auto padTransform = event.padTransform;
-    transform1->Position = glm::vec3(padTransform->Position.x - 4, -6, -10);
-    transform2->Position = glm::vec3(padTransform->Position.x + 4, -6, -10);
+    transform1->Position = glm::vec3(padTransform->Position.x - 4, -5, -10);
+    transform2->Position = glm::vec3(padTransform->Position.x + 4, -5, -10);
 
     Events::SetImpulse e1;
     e1.Entity = ent1;