Merge master

include/Game/LevelSystem.h

@@ -7,22 +7,30 @@
 
 #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 "Physics/CRectangleShape.h"
+#include "Game/EMultiBall.h"
+#include "Game/EGameOver.h"
+#include "Game/ECreatePowerUp.h"
+#include "Game/EPowerUpTaken.h"
+#include "Game/Bricks/CPowerUpBrick.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>
@@ -53,11 +61,11 @@ public:
 
     void Initialize() override;
 
-    void CreateBasicLevel(int, int, glm::vec2, int);
+    void CreateBasicLevel(int, int, glm::vec2, float);
     void CreateLife(int);
     void SaveLevel(int, int, glm::vec2, int); // Shouldn't be here, but I'm experimenting.
     void LoadLevel(char[20]);
-    void CreateBrick(int, int, glm::vec2, int, int);
+    void CreateBrick(int, int, glm::vec2, float, int);
     void ProcessCollision();
 
     void OnEntityRemoved(EntityID entity);
@@ -67,12 +75,18 @@ 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; }
     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& PowerUps() { return m_PowerUps; }
+    void SetPowerUps(const int& powerUps) { m_PowerUps = powerUps; }
     int& Score() { return m_Score; }
     void SetScore(const int& score) { m_Score = score; }
     int& NumberOfBricks() { return m_NumberOfBricks; }
@@ -81,30 +95,47 @@ public:
     void SetRows(const int& rows) { m_Rows = rows; }
     int& Lines() { return m_Lines; }
     void SetLines(const int& lines) { m_Lines = lines; }
-    int& SpaceToEdge() { return m_SpaceToEdge; }
-    void SetSpaceToEdge(const int& spaceToEdge) { m_SpaceToEdge = spaceToEdge; }
+    float& SpaceToEdge() { return m_SpaceToEdge; }
+    void SetSpaceToEdge(const float& spaceToEdge) { m_SpaceToEdge = spaceToEdge; }
 
     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;
+    int m_MultiBalls = 0;
+    int m_PowerUps = 0;
     int m_Score = 0;
     int m_NumberOfBricks;
-    int m_Rows = 7;
-    int m_Lines = 8;
-    int m_SpaceToEdge = 0;
-    glm::vec2 m_SpaceBetweenBricks = glm::vec2(2, 0.5);
+    int m_Rows = 6;
+    int m_Lines = 7;
+    float m_SpaceToEdge = 0.25f;
+    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;
     dd::EventRelay<LevelSystem, dd::Events::ScoreEvent> m_EScoreEvent;
+    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 LifeLost(const dd::Events::LifeLost &event);
-    bool ScoreEvent(const dd::Events::ScoreEvent &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);
+    bool OnPowerUpTaken(const dd::Events::PowerUpTaken &event);
+    bool OnStageCleared(const dd::Events::StageCleared &event);
 };
 
 }