Merge master

include/Game/BallSystem.h

@@ -3,10 +3,11 @@
 
 #include "Core/System.h"
 #include "Core/World.h"
+#include "Core/EventBroker.h"
 #include "Core/CTransform.h"
 #include "Physics/EContact.h"
-#include "Core/EventBroker.h"
 #include "Game/CBall.h"
+#include "Game/CPowerUp.h"
 
 namespace dd {
 

include/Game/Bricks/CPowerUpBrick.h

@@ -0,0 +1,25 @@
+//
+// Created by Adniklastrator 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/CBall.h

@@ -16,6 +16,7 @@ namespace Components
 struct Ball : Component
 {
     int Number = 0;
+    float Speed = 5.f;
 };
 
 }

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/CPad.h

@@ -21,8 +21,8 @@ struct Pad : Component
     int Points;
 
     float SlowdownModifier = 5.f;
-    float AccelerationSpeed = 80.f;
-    float MaxSpeed = 40.f;
+    float AccelerationSpeed = 40.f;
+    float MaxSpeed = 20.f;
 };
 
 }

include/Game/CPowerUp.h

@@ -0,0 +1,25 @@
+//
+// Created by Adniklastrator 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 Adniklastrator 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 Adniklastrator 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/EMultiBall.h

@@ -0,0 +1,26 @@
+//
+// Created by Adniklastrator on 2015-09-17.
+//
+
+#ifndef DAYDREAM_EMULTIBALL_H
+#define DAYDREAM_EMULTIBALL_H
+
+#include "Core/EventBroker.h"
+#include "Core/Entity.h"
+
+namespace dd
+{
+
+namespace Events
+{
+
+struct MultiBall : Event
+{
+    Components::Transform* padTransform;
+};
+
+}
+
+}
+
+#endif //DAYDREAM_EMULTIBALL_H

include/Game/EPowerUpTaken.h

@@ -0,0 +1,25 @@
+//
+// Created by Adniklastrator on 2015-09-23.
+//
+
+#ifndef DAYDREAM_EPOWERUPTAKEN_H
+#define DAYDREAM_EPOWERUPTAKEN_H
+
+#include "Core/EventBroker.h"
+
+namespace dd
+{
+
+namespace Events
+{
+
+struct PowerUpTaken : Event
+{
+    std::string Name = "Name";
+};
+
+}
+
+}
+
+#endif //DAYDREAM_EPOWERUPTAKEN_H

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);
 };
 
 }

include/Game/LevelSystem.h.orig

@@ -0,0 +1,149 @@
+//
+// Created by Adniklastrator on 2015-09-09.
+//
+
+#ifndef DAYDREAM_LEVELSYSTEM_H
+#define DAYDREAM_LEVELSYSTEM_H
+
+#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 "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"
+<<<<<<< HEAD
+#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/CBoxShape.h"
+>>>>>>> 72413dc0a93bd3a2f6ab9fa7e19bbc3b846232db
+#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>
+
+namespace dd
+{
+
+namespace Systems
+{
+
+    // Me trying things out.
+class Level
+{
+public:
+    int levelRows;
+    int levelLines;
+    int levelSpaceBetweenBricks;
+    int levelSpaceToEdge;
+    int bricks[];
+};
+
+class LevelSystem : public System
+{
+public:
+    LevelSystem(World* world, std::shared_ptr<dd::EventBroker> eventBroker)
+    : System(world, eventBroker)
+    { }
+
+    void Initialize() override;
+
+    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, float, int);
+    void ProcessCollision();
+
+    void OnEntityRemoved(EntityID entity);
+
+    void EndLevel();
+
+    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; }
+    void SetNumberOfBricks(const int& numberOfBricks) { m_NumberOfBricks = numberOfBricks; }
+    int& Rows() { return m_Rows; }
+    void SetRows(const int& rows) { m_Rows = rows; }
+    int& Lines() { return m_Lines; }
+    void SetLines(const int& lines) { m_Lines = lines; }
+    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 = 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 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);
+};
+
+}
+
+}
+
+#endif //DAYDREAM_LEVELSYSTEM_H

include/Game/PadSystem.h

@@ -21,8 +21,12 @@
 #include "Rendering/CSprite.h"
 #include "Rendering/CModel.h"
 #include "Game/CBall.h"
+#include "Game/CPad.h"
+#include "Game/CPowerUp.h"
 #include "Game/EResetBall.h"
-#include "CPad.h"
+#include "Game/EMultiBall.h"
+#include "Game/EPowerUpTaken.h"
+#include "Game/EStageCleared.h"
 
 
 namespace dd
@@ -41,6 +45,8 @@ public:
     void Update(double dt) override;
     void UpdateEntity(double dt, EntityID entity, EntityID parent) override;
 
+    EntityID CreateBall();
+
     EntityID& Entity() { return m_Entity; }
     void SetEntity(const EntityID& ent) { m_Entity = ent; }
     glm::vec3 Acceleration() const { return m_Acceleration; }
@@ -52,29 +58,37 @@ public:
     void SetRight(const bool& right) { m_Right = right; }
     bool ReplaceBall() const { return m_ReplaceBall; }
     void SetReplaceBall(const bool& replaceBall) { m_ReplaceBall = replaceBall; }
+    bool MultiBall() const { return m_MultiBall; }
+    void SetMultiBall(const bool& multiBall) { m_MultiBall = multiBall; }
 
     Components::Transform* Transform() const { return m_Transform; }
-    void SetTransform(const Components::Transform* transform) { m_Transform = transform; }
+    void SetTransform(Components::Transform* transform) { m_Transform = transform; }
     Components::Pad* Pad() const { return m_Pad; }
-    void SetPad(const Components::Pad* pad) { m_Pad = pad; }
+    void SetPad(Components::Pad* pad) { m_Pad = pad; }
 
 private:
     EntityID m_Entity = 0;
     glm::vec3 m_Acceleration = glm::vec3(0.f, 0.f, 0.f);
-    bool m_Left = false, m_Right = false, m_ReplaceBall = false;
+    bool m_Left = false, m_Right = false, m_ReplaceBall = false, m_MultiBall = false;
     Components::Transform* m_Transform;
     Components::Pad* m_Pad;
 
     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;
+    dd::EventRelay<PadSystem, dd::Events::StageCleared> m_EStageCleared;
 
     bool OnKeyDown(const dd::Events::KeyDown &event);
     bool OnKeyUp(const dd::Events::KeyUp &event);
 
     bool OnContact(const dd::Events::Contact &event);
-    bool ResetBall(const dd::Events::ResetBall &event);
+    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;