StyleGuide Fix

include/Game/CBall.h

@@ -15,7 +15,7 @@ namespace Components
 
 struct Ball : Component
 {
-    int number = 0;
+    int Number = 0;
 };
 
 }

include/Game/CLife.h

@@ -15,7 +15,7 @@ namespace Components
 
 struct Life : Component {
 
-    int number = 0;
+    int Number = 0;
 
 };
 

include/Game/CPad.h

@@ -20,9 +20,9 @@ struct Pad : Component
     int Lives;
     int Points;
 
-    float slowdownModifier = 5.f;
+    float SlowdownModifier = 5.f;
-    float accelerationSpeed = 80.f;
+    float AccelerationSpeed = 80.f;
-    float maxSpeed = 40.f;
+    float MaxSpeed = 40.f;
 };
 
 }

include/Game/EScoreEvent.h

@@ -15,7 +15,7 @@ namespace Events
 
 struct ScoreEvent : Event
 {
-    int score = 0;
+    int Score = 0;
 };
 
 }

include/Game/LevelSystem.h

@@ -65,12 +65,38 @@ public:
 
     void Update(double dt) override;
     void UpdateEntity(double dt, EntityID entity, EntityID parent) override;
-    int lives = 3;
-    int pastLives = 3;
 
-    int score = 0;
+    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& 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; }
+    int& SpaceToEdge() { return m_SpaceToEdge; }
+    void SetSpaceToEdge(const int& spaceToEdge) { m_SpaceToEdge = spaceToEdge; }
+
+    glm::vec2& SpaceBetweenBricks() { return m_SpaceBetweenBricks; }
+    void SetSpaceBetweenBricks(const glm::vec2& spaceBetweenBricks) { m_SpaceBetweenBricks = spaceBetweenBricks; }
 
 private:
+    bool m_Initialized = false;
+    int m_Lives = 3;
+    int m_PastLives = 3;
+    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);
+
     dd::EventRelay<LevelSystem, dd::Events::Contact> m_EContact;
     dd::EventRelay<LevelSystem, dd::Events::LifeLost> m_ELifeLost;
     dd::EventRelay<LevelSystem, dd::Events::ScoreEvent> m_EScoreEvent;
@@ -78,16 +104,6 @@ private:
     bool OnContact(const dd::Events::Contact &event);
     bool LifeLost(const dd::Events::LifeLost &event);
     bool ScoreEvent(const dd::Events::ScoreEvent &event);
-
-    bool m_Initialized = false;
-
-    int numberOfBricks;
-    int tRows = 7;
-    int tLines = 8;
-    glm::vec2 tSpaceBetweenBricks = glm::vec2(2, 0.5);
-    int tSpaceToEdge = 0;
-
-    EntityID entityToRemove = NULL;
 };
 
 }

include/Game/PadSystem.h

@@ -34,14 +34,36 @@ class PadSystem : public System
 {
 public:
     PadSystem(World* world, std::shared_ptr<dd::EventBroker> eventBroker)
-    : System(world, eventBroker)
+    : System(world, eventBroker) { }
-    { }
 
     void Initialize() override;
     void Update(double dt) override;
     void UpdateEntity(double dt, EntityID entity, EntityID parent) override;
 
+    EntityID& Entity() { return m_Entity; }
+    void SetEntity(const EntityID& ent) { m_Entity = ent; }
+    glm::vec3 Acceleration() const { return m_Acceleration; }
+    void SetAcceleration(const glm::vec3& acceleration) { m_Acceleration = acceleration; }
+
+    bool Left() const { return m_Left; }
+    void SetLeft(const bool& left) { m_Left = left; }
+    bool Right() const { return m_Right; }
+    void SetRight(const bool& right) { m_Right = right; }
+    bool ReplaceBall() const { return m_ReplaceBall; }
+    void SetReplaceBall(const bool& replaceBall) { m_ReplaceBall = replaceBall; }
+
+    Components::Transform* Transform() const { return m_Transform; }
+    void SetTransform(const Components::Transform* transform) { m_Transform = transform; }
+    Components::Pad* Pad() const { return m_Pad; }
+    void SetPad(const 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;
+    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;
@@ -50,22 +72,11 @@ private:
     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);
 
-    EntityID removeThisObject = NULL;
-
-
     class PadSteeringInputController;
     std::array<std::shared_ptr<PadSteeringInputController>, 4> m_PadInputControllers;
-
-    EntityID ent = 0;
-    Components::Transform* transform;
-    Components::Pad* pad;
-    glm::vec3 acceleration = glm::vec3(0.f, 0.f, 0.f);
-    bool left = false, right = false, replaceBall = false;
 };
 
 class PadSystem::PadSteeringInputController : InputController<PadSystem>

src/game/Game/LevelSystem.cpp

@@ -13,8 +13,7 @@ void dd::Systems::LevelSystem::Initialize()
     EVENT_SUBSCRIBE_MEMBER(m_ELifeLost, LevelSystem::LifeLost);
     EVENT_SUBSCRIBE_MEMBER(m_EScoreEvent, LevelSystem::ScoreEvent);
 
-    for (int i = 0; i < lives; i++)
+    for (int i = 0; i < Lives(); i++) {
-    {
         CreateLife(i);
     }
 
@@ -29,7 +28,7 @@ void dd::Systems::LevelSystem::CreateLife(int number)
     transform->Scale = glm::vec3(0.5f, 0.5f, 0.5f);
 
     std::shared_ptr<Components::Life> lifeNr = m_World->AddComponent<Components::Life>(life);
-    lifeNr->number = number;
+    lifeNr->Number = number;
 
     std::shared_ptr<Components::Sprite> sprite = m_World->AddComponent<Components::Sprite>(life);
     sprite->SpriteFile = "Textures/Ball.png";
@@ -40,7 +39,7 @@ void dd::Systems::LevelSystem::CreateLife(int number)
 void dd::Systems::LevelSystem::Update(double dt)
 {
     if (!m_Initialized) {
-        CreateBasicLevel(tRows, tLines, tSpaceBetweenBricks, tSpaceToEdge);
+        CreateBasicLevel(Rows(), Lines(), SpaceBetweenBricks(), SpaceToEdge());
         m_Initialized = true;
     }
 }
@@ -49,13 +48,10 @@ void dd::Systems::LevelSystem::UpdateEntity(double dt, EntityID entity, EntityID
 {
     auto ball = m_World->GetComponent<Components::Ball>(entity);
 
-    if (ball != NULL)
+    if (ball != NULL) {
-    {
         auto transformBall = m_World->GetComponent<Components::Transform>(entity);
-        if (transformBall->Position.y < -10)
+        if (transformBall->Position.y < -10) {
-        {
+            if (Lives() == PastLives()) {
-            if (lives == pastLives)
-            {
                 Events::LifeLost e;
                 e.Entity = entity;
                 EventBroker->Publish(e);
@@ -66,14 +62,12 @@ void dd::Systems::LevelSystem::UpdateEntity(double dt, EntityID entity, EntityID
         }
     }
 
-    if (lives != pastLives)
+    if (Lives() != PastLives()) {
-    {
         auto life = m_World->GetComponent<Components::Life>(entity);
-        if (life != NULL)
+        if (life != NULL) {
-        {
+            if (life->Number + 1 == PastLives()) {
-            if (life->number + 1 == pastLives) {
                 m_World->RemoveEntity(entity);
-                pastLives = lives;
+                SetPastLives(Lives());
             }
         }
     }
@@ -82,12 +76,10 @@ void dd::Systems::LevelSystem::UpdateEntity(double dt, EntityID entity, EntityID
 void dd::Systems::LevelSystem::CreateBasicLevel(int rows, int lines, glm::vec2 spacesBetweenBricks, int spaceToEdge)
 {
     int num = 0;
-    numberOfBricks = rows * lines;
+    SetNumberOfBricks(rows * lines);
-    for (int i = 0; i < rows; i++)
+    for (int i = 0; i < rows; i++) {
-    {
         num++;
-        for (int j = 0; j < lines; j++)
+        for (int j = 0; j < Lines(); j++) {
-        {
             CreateBrick(i, j, spacesBetweenBricks, spaceToEdge, num);
         }
         if (num == 7)
@@ -127,11 +119,9 @@ void dd::Systems::LevelSystem::ProcessCollision()
 void dd::Systems::LevelSystem::OnEntityRemoved(EntityID entity)
 {
     /*auto brick = m_World->GetComponent<Components::Brick>(entity);
-    if (brick != NULL)
+    if (brick != NULL) {
-    {
         numberOfBricks--;
-        if (numberOfBricks < 1)
+        if (numberOfBricks < 1) {
-        {
             EndLevel();
         }
     }*/
@@ -142,43 +132,41 @@ bool dd::Systems::LevelSystem::OnContact(const dd::Events::Contact &event)
 {
     EntityID entityBrick = event.Entity1;
     auto brick = m_World->GetComponent<Components::Brick>(entityBrick);
-    if (brick == NULL)
+    if (brick == NULL) {
-    {
         return false;
     }
     EntityID entityBall = event.Entity2;
 
     m_World->RemoveEntity(entityBrick);
 
-    numberOfBricks--;
+    SetNumberOfBricks(NumberOfBricks() - 1);
-    if (numberOfBricks == 0)
+    if (NumberOfBricks() == 0) {
-    {
         Events::ScoreEvent es;
-        es.score = 500;
+        es.Score = 500;
         EventBroker->Publish(es);
         Events::ResetBall e;
         EventBroker->Publish(e);
-        CreateBasicLevel(tRows, tLines, tSpaceBetweenBricks, tSpaceToEdge);
+        CreateBasicLevel(Rows(), Lines(), SpaceBetweenBricks(), SpaceToEdge());
     }
     Events::ScoreEvent es;
-    es.score = brick->Score;
+    es.Score = brick->Score;
     EventBroker->Publish(es);
 
-    std::cout << "Score: " << score << std::endl;
+    std::cout << "Score: " << Score() << std::endl;
 
     return true;
 }
 
 bool dd::Systems::LevelSystem::LifeLost(const dd::Events::LifeLost &event)
 {
-    lives--;
+    SetLives(Lives() - 1);
 
     return true;
 }
 
 bool dd::Systems::LevelSystem::ScoreEvent(const dd::Events::ScoreEvent &event)
 {
-    score += event.score;
+    SetScore(Score() += event.Score);
 
     return true;
 }

src/game/Game/PadSystem.cpp

@@ -33,8 +33,8 @@ void dd::Systems::PadSystem::UpdateEntity(double dt, EntityID entity, EntityID p
 {
     auto ball = m_World->GetComponent<Components::Ball>(entity);
     if (ball != NULL) {
-        if (replaceBall == true) {
+        if (ReplaceBall() == true) {
-            replaceBall = false;
+            SetReplaceBall(false);
 
             auto transformEntity = m_World->GetComponent<Components::Transform>(entity);
             transformEntity->Position = glm::vec3(20, 20, -10);
@@ -65,71 +65,65 @@ void dd::Systems::PadSystem::UpdateEntity(double dt, EntityID entity, EntityID p
 
 void dd::Systems::PadSystem::Update(double dt)
 {
-    if (ent == 0) {
+    if (Entity() == 0) {
         for (auto it = m_World->GetEntities()->begin(); it != m_World->GetEntities()->end(); it++) {
             if (m_World->GetProperty<std::string>(it->first, "Name") == "Pad") {
-                ent = it->first;
+                SetEntity(it->first);
-                transform = m_World->GetComponent<Components::Transform>(ent);
+                SetTransform(m_World->GetComponent<Components::Transform>(Entity()));
-                pad = m_World->GetComponent<Components::Pad>(ent);
+                SetPad(m_World->GetComponent<Components::Pad>(Entity()));
                 break;
             }
         }
     }
 
-    if (transform->Velocity.x < -pad->maxSpeed)
+    auto transform = Transform();
-    {
+    auto pad = Pad();
-        transform->Velocity.x = -pad->maxSpeed;
+    auto acceleration = Acceleration();
+
+    if (transform->Velocity.x < -pad->MaxSpeed) {
+        transform->Velocity.x = -pad->MaxSpeed;
     }
-    else if (transform->Velocity.x > pad->maxSpeed)
+    else if (transform->Velocity.x > pad->MaxSpeed) {
-    {
+        transform->Velocity.x = pad->MaxSpeed;
-        transform->Velocity.x = pad->maxSpeed;
     }
     transform->Position += transform->Velocity * (float)dt;
     transform->Velocity += acceleration * (float)dt;
-    transform->Velocity -= transform->Velocity * pad->slowdownModifier * (float)dt;
+    transform->Velocity -= transform->Velocity * pad->SlowdownModifier * (float)dt;
 
-    if (left)
+    if (Left()) {
-    {
+        acceleration.x = -pad->AccelerationSpeed;
-        acceleration.x = -pad->accelerationSpeed;
     }
-    else if (right)
+    else if (Right()) {
-    {
+        acceleration.x = pad->AccelerationSpeed;
-        acceleration.x = pad->accelerationSpeed;
     }
-    else
+    else {
-    {
         acceleration.x = 0.f;
     }
 
+    SetTransform(transform);
+    SetPad(pad);
+    SetAcceleration(acceleration);
+
     return;
 }
 
 bool dd::Systems::PadSystem::OnKeyDown(const dd::Events::KeyDown &event)
 {
     int val = event.KeyCode;
-    if (val == GLFW_KEY_UP)
+    if (val == GLFW_KEY_UP) {
-    {
         //std::cout << "Up!" << std::endl;
-    }
+    } else if (val == GLFW_KEY_DOWN) {
-    else if (val == GLFW_KEY_DOWN)
-    {
         //std::cout << "Down!" << std::endl;
-    }
+    } else if (val == GLFW_KEY_LEFT) {
-    else if (val == GLFW_KEY_LEFT)
-    {
         //std::cout << "Left!" << std::endl;
         //acceleration.x = -0.01f;
-        left = true;
+        SetLeft(true);
-    }
+    } else if (val == GLFW_KEY_RIGHT) {
-    else if (val == GLFW_KEY_RIGHT)
-    {
         //std::cout << "Right!" << std::endl;
         //acceleration.x = 0.01f;
-        right = true;
+        SetRight(true);
-    }
+    } else if (val == GLFW_KEY_R) {
-    else if (val == GLFW_KEY_R)
+        SetReplaceBall(true);
-    {
-        replaceBall = true;
     }
     return true;
 }
@@ -137,21 +131,14 @@ bool dd::Systems::PadSystem::OnKeyDown(const dd::Events::KeyDown &event)
 bool dd::Systems::PadSystem::OnKeyUp(const dd::Events::KeyUp &event)
 {
     int val = event.KeyCode;
-    if (val == GLFW_KEY_UP)
+    if (val == GLFW_KEY_UP) {
-    {
 
-    }
+    } else if (val == GLFW_KEY_DOWN) {
-    else if (val == GLFW_KEY_DOWN)
-    {
 
-    }
+    } else if (val == GLFW_KEY_LEFT) {
-    else if (val == GLFW_KEY_LEFT)
+        SetLeft(false);
-    {
+    } else if (val == GLFW_KEY_RIGHT) {
-        left = false;
+        SetRight(false);
-    }
-    else if (val == GLFW_KEY_RIGHT)
-    {
-        right = false;
     }
     return true;
 }
@@ -160,14 +147,12 @@ bool dd::Systems::PadSystem::OnContact(const dd::Events::Contact &event)
 {
     EntityID entityBall = event.Entity2;
     auto ball = m_World->GetComponent<Components::Ball>(entityBall);
-    if (ball == NULL)
+    if (ball == NULL) {
-    {
         return false;
     }
     EntityID entityPad = event.Entity1;
     auto pad = m_World->GetComponent<Components::Pad>(entityPad);
-    if (pad == NULL)
+    if (pad == NULL) {
-    {
         return false;
     }
     auto transformBall = m_World->GetComponent<Components::Transform>(entityBall);
@@ -177,13 +162,10 @@ bool dd::Systems::PadSystem::OnContact(const dd::Events::Contact &event)
 
     float whatX = transformBall->Position.x - transformPad->Position.x;
     float movementX;
-    if (whatX > 0)
+    if (whatX > 0) {
-    {
         movementX = movementMultiplier * whatX;
         //std::cout << "Right!" << std::endl;
-    }
+    } else {
-    else
-    {
         movementX = movementMultiplier * whatX;
         //std::cout << "Left!" << std::endl;
     }
@@ -219,7 +201,7 @@ bool dd::Systems::PadSystem::OnContact(const dd::Events::Contact &event)
 
 bool dd::Systems::PadSystem::ResetBall(const dd::Events::ResetBall &event)
 {
-    replaceBall = true;
+    SetReplaceBall(true);
     return true;
 }
 
@@ -229,12 +211,9 @@ bool dd::Systems::PadSystem::PadSteeringInputController::OnCommand(const Events:
 
     std::cout << "Command!" << std::endl;
 
-    if (command == "right")
+    if (command == "right") {
-    {
         std::cout << "Right!" << std::endl;
-    }
+    } else if (command == "left") {
-    else if (command == "left")
-    {
         std::cout << "Left!" << std::endl;
     }