Merge remote-tracking branch 'origin/master' into Sound

Conflicts:
	src/game/Sound/SoundSystem.cpp

src/game/Game/BallSystem.cpp

@@ -60,9 +60,10 @@ bool dd::Systems::BallSystem::Contact(const Events::Contact &event)
         return false;
     }
 
-    //Which is the ball?
+
     EntityID ballEntity, otherEntitiy;
 
+    //Which is the ball?
     if (ballComponent1 != nullptr) {
         ballEntity = event.Entity1;
         otherEntitiy = event.Entity2;
@@ -78,6 +79,8 @@ bool dd::Systems::BallSystem::Contact(const Events::Contact &event)
         //TODO: Add support for power-up collisions
     }
 
+    //if this is a brick thats dead do not collide :)
+
     auto ballTransform = m_World->GetComponent<Components::Transform>(ballEntity);
     glm::vec2 ballVelocity = glm::vec2(ballTransform->Velocity.x, ballTransform->Velocity.y);
 
@@ -85,7 +88,6 @@ bool dd::Systems::BallSystem::Contact(const Events::Contact &event)
         auto padTransform = m_World->GetComponent<Components::Transform>(otherEntitiy);
         float x = ballTransform->Position.x - padTransform->Position.x;
 
-        float movementMultiplier = 5.0f;
         float y = glm::cos((abs(x) / (1.6f)) * glm::pi<float>() / 2.f) + 1.f;
 
         ballTransform->Velocity = glm::normalize(glm::vec3(x, y ,0.f)) * ballComponent->Speed;

src/game/Game/LevelSystem.cpp

@@ -72,10 +72,10 @@ void dd::Systems::LevelSystem::UpdateEntity(double dt, EntityID entity, EntityID
         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->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;
@@ -107,8 +107,8 @@ void dd::Systems::LevelSystem::UpdateEntity(double dt, EntityID entity, EntityID
         auto life = m_World->GetComponent<Components::Life>(entity);
         if (life != nullptr) {
             if (life->Number + 1 == PastLives()) {
-                m_World->RemoveComponent<Components::Life>(entity);
-                m_World->RemoveComponent<Components::Transform>(entity);
+//                m_World->RemoveComponent<Components::Life>(entity);
+//                m_World->RemoveComponent<Components::Transform>(entity);
                 m_World->RemoveEntity(entity);
                 SetPastLives(Lives());
             }
@@ -170,11 +170,15 @@ void dd::Systems::LevelSystem::CreateBrick(int row, int line, glm::vec2 spacesBe
 {
     auto brick = m_World->CreateEntity();
     std::shared_ptr<Components::Transform> transform = m_World->AddComponent<Components::Transform>(brick);
-    //std::shared_ptr<Components::Sprite> sprite = m_World->AddComponent<Components::Sprite>(brick);
     auto model = m_World->AddComponent<Components::Model>(brick);
     std::shared_ptr<Components::Brick> cBrick = m_World->AddComponent<Components::Brick>(brick);
     std::shared_ptr<Components::RectangleShape> cRec = m_World->AddComponent<Components::RectangleShape>(brick);
     std::shared_ptr<Components::Physics> cPhys = m_World->AddComponent<Components::Physics>(brick);
+    cPhys->Static = false;
+    cPhys->GravityScale = 0.f;
+    cPhys->Category = CollisionLayer::Type::Brick;
+    cPhys->Mask = CollisionLayer::Type::Ball;
+
     std::string fileName = "Textures/Bricks/";
     fileName.append(std::to_string(num));
     fileName.append(".png");
@@ -261,11 +265,29 @@ bool dd::Systems::LevelSystem::OnContact(const dd::Events::Contact &event)
     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);
+//        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);
+
+        auto physicsComponent = m_World->GetComponent<Components::Physics>(entityBrick);
+        physicsComponent->GravityScale = 1.f;
+        physicsComponent->Mask = CollisionLayer::Type::Water | CollisionLayer::Type::Wall;
+
+        auto transformComponentBrick = m_World->GetComponent<Components::Transform>(entityBrick);
+        auto transformComponentBall = m_World->GetComponent<Components::Transform>(entityBall);
+
+        Events::SetImpulse e;
+        e.Entity = entityBrick;
+
+        glm::vec2 point = glm::vec2(transformComponentBrick->Position.x + ((transformComponentBall->Position.x - transformComponentBrick->Position.x )/4),
+                                    transformComponentBrick->Position.y  + ((transformComponentBall->Position.y - transformComponentBrick->Position.y)/4));
+
+        e.Impulse = glm::normalize(point)*5.f;///2.f;
+        e.Point = point;
+        EventBroker->Publish(e);
+        //TODO: Bricks dont collide with walls D=
 
         SetNumberOfBricks(NumberOfBricks() - 1);
         if (NumberOfBricks() <= 0) {
@@ -275,7 +297,7 @@ bool dd::Systems::LevelSystem::OnContact(const dd::Events::Contact &event)
         es.Score = brick->Score;
         EventBroker->Publish(es);
 
-        //std::cout << NumberOfBricks() << std::endl;
+       // std::cout << NumberOfBricks() << std::endl;
         //std::cout << "Score: " << Score() << std::endl;
     }
 
@@ -309,8 +331,12 @@ bool dd::Systems::LevelSystem::OnCreatePowerUp(const dd::Events::CreatePowerUp &
     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;
+    cPhys->Category = CollisionLayer::Type::PowerUp;
+    cPhys->Mask = CollisionLayer::Type::Pad;
+
+    std::shared_ptr<Components::PowerUp> cPow = m_World->AddComponent<Components::PowerUp>(powerUp);
+
 
     transform->Position = event.Position;
     transform->Scale = glm::vec3(0.2, 0.2, 0.2);

src/game/Game/LevelSystem.cpp.orig

@@ -0,0 +1,372 @@
+//
+// Created by Adniklastrator on 2015-09-09.
+//
+
+
+#include "PrecompiledHeader.h"
+#include "Game/LevelSystem.h"
+
+
+void dd::Systems::LevelSystem::Initialize()
+{
+    EVENT_SUBSCRIBE_MEMBER(m_EContact, LevelSystem::OnContact);
+    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);
+    EVENT_SUBSCRIBE_MEMBER(m_EPowerUpTaken, LevelSystem::OnPowerUpTaken);
+    EVENT_SUBSCRIBE_MEMBER(m_EStageCleared, LevelSystem::OnStageCleared);
+
+    for (int i = 0; i < Lives(); i++) {
+        CreateLife(i);
+    }
+
+    return;
+}
+
+void dd::Systems::LevelSystem::CreateLife(int number)
+{
+    auto life = m_World->CreateEntity();
+    std::shared_ptr<Components::Transform> transform = m_World->AddComponent<Components::Transform>(life);
+    transform->Position = glm::vec3(-1.5f + number * 0.15f, -2.f, -5.f);
+    transform->Scale = glm::vec3(0.1f, 0.1f, 0.1f);
+
+    std::shared_ptr<Components::Life> lifeNr = m_World->AddComponent<Components::Life>(life);
+    lifeNr->Number = number;
+
+    auto model = m_World->AddComponent<Components::Model>(life);
+    model->ModelFile = "Models/Test/Ball/Ballopus.obj";
+
+
+    m_World->CommitEntity(life);
+}
+
+void dd::Systems::LevelSystem::Update(double dt)
+{
+    if (!m_Initialized) {
+        CreateBasicLevel(Rows(), Lines(), SpaceBetweenBricks(), SpaceToEdge());
+        m_Initialized = true;
+    }
+
+    if (Lives() < 0)
+    {
+        SetLives(3);
+        Events::GameOver e;
+        EventBroker->Publish(e);
+    }
+}
+
+void dd::Systems::LevelSystem::UpdateEntity(double dt, EntityID entity, EntityID parent)
+{
+    auto ball = m_World->GetComponent<Components::Ball>(entity);
+
+    if (ball != nullptr) {
+        auto transformBall = m_World->GetComponent<Components::Transform>(entity);
+        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);
+                return;
+            }
+        } 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 < -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 != 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::StageCleared ec;
+            EventBroker->Publish(ec);
+            CreateBasicLevel(Rows(), Lines(), SpaceBetweenBricks(), SpaceToEdge());
+        } else {
+            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 != 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)
+{
+    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++) {
+            CreateBrick(i, j, spacesBetweenBricks, spaceToEdge, num);
+        }
+        if (num == 7)
+            num = 0;
+    }
+
+    SetNumberOfBricks(rows * lines);
+    SetRestarting(false);
+    return;
+}
+
+void dd::Systems::LevelSystem::CreateBrick(int row, int line, glm::vec2 spacesBetweenBricks, float spaceToEdge, int num)
+{
+    auto brick = m_World->CreateEntity();
+    std::shared_ptr<Components::Transform> transform = m_World->AddComponent<Components::Transform>(brick);
+    auto model = m_World->AddComponent<Components::Model>(brick);
+    std::shared_ptr<Components::Brick> cBrick = m_World->AddComponent<Components::Brick>(brick);
+    std::shared_ptr<Components::RectangleShape> cRec = m_World->AddComponent<Components::RectangleShape>(brick);
+    std::shared_ptr<Components::Physics> cPhys = m_World->AddComponent<Components::Physics>(brick);
+    cPhys->Static = false;
+    cPhys->GravityScale = 0.f;
+    cPhys->Category = CollisionLayer::Type::Brick;
+    cPhys->Mask = CollisionLayer::Type::Ball;
+
+    std::string fileName = "Textures/Bricks/";
+    fileName.append(std::to_string(num));
+    fileName.append(".png");
+    //sprite->SpriteFile =  fileName;
+    model->ModelFile = "Models/Test/Brick/Brick.obj";
+    if ((line == 1 && row == 4) || (line == 3 && row == 2) || (line == 6 && row == 6)) {
+        std::shared_ptr<Components::PowerUpBrick> cPow = m_World->AddComponent<Components::PowerUpBrick>(brick);
+    }
+    float x = line * spacesBetweenBricks.x;
+    float y = row * spacesBetweenBricks.y;
+    transform->Scale = glm::vec3(0.8, 0.2, 0.2);
+    transform->Position = glm::vec3(x - 3, 5 - spaceToEdge - y , -10.f);
+    cBrick->Score = 10 * num;
+
+    //sound
+    auto collisionSound = m_World->AddComponent<Components::CollisionSound>(brick);
+    collisionSound->filePath = "Sounds/Brick/shortbrickbreak.wav";
+
+    m_World->CommitEntity(brick);
+    return;
+}
+
+void dd::Systems::LevelSystem::ProcessCollision()
+{
+    // Like, go into brick component and check what it does upon collision. Maybe not done here?
+    return;
+}
+
+void dd::Systems::LevelSystem::OnEntityRemoved(EntityID entity)
+{
+    auto brick = m_World->GetComponent<Components::Brick>(entity);
+    if (brick != nullptr) {
+        SetNumberOfBricks(NumberOfBricks() - 1);
+        Events::ScoreEvent es;
+        es.Score = brick->Score;
+        EventBroker->Publish(es);
+        /*if (numberOfBricks < 1) {
+            EndLevel();
+        }*/
+    }
+    return;
+}
+
+bool dd::Systems::LevelSystem::OnContact(const dd::Events::Contact &event)
+{
+    EntityID entityBrick;
+    EntityID entityBall;
+    auto ball = m_World->GetComponent<Components::Ball>(event.Entity2);
+    auto brick = m_World->GetComponent<Components::Brick>(event.Entity1);
+    if (brick != nullptr) {
+        entityBrick = event.Entity1;
+    } else {
+        brick = m_World->GetComponent<Components::Brick>(event.Entity2);
+        if (brick != nullptr) {
+            entityBrick = event.Entity2;
+        } else {
+            return false;
+        }
+    }
+    if (ball != nullptr) {
+        entityBall = event.Entity2;
+    } else {
+        ball = m_World->GetComponent<Components::Ball>(event.Entity1);
+        if (ball != nullptr) {
+            entityBall = event.Entity1;
+        } else {
+            return false;
+        }
+    }
+
+    brick = m_World->GetComponent<Components::Brick>(entityBrick);
+    if (brick == nullptr) {
+        return false;
+    }
+
+    auto power = m_World->GetComponent<Components::PowerUpBrick>(entityBrick);
+    if (power != nullptr) {
+        Events::CreatePowerUp e;
+        auto transform = m_World->GetComponent<Components::Transform>(entityBrick);
+        e.Position = transform->Position;
+        EventBroker->Publish(e);
+    }
+
+    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);
+
+        auto physicsComponent = m_World->GetComponent<Components::Physics>(entityBrick);
+        physicsComponent->GravityScale = 1.f;
+        physicsComponent->Mask = CollisionLayer::Type::Water | CollisionLayer::Type::Wall;
+
+        auto transformComponentBrick = m_World->GetComponent<Components::Transform>(entityBrick);
+        auto transformComponentBall = m_World->GetComponent<Components::Transform>(entityBall);
+
+        Events::SetImpulse e;
+        e.Entity = entityBrick;
+
+        glm::vec2 point = glm::vec2(transformComponentBrick->Position.x + ((transformComponentBrick->Position.x - transformComponentBall->Position.x)/4), transformComponentBrick->Position.y  + ((transformComponentBrick->Position.y - transformComponentBall->Position.y )/4));
+
+        e.Impulse = glm::normalize(point)/2.f;
+        e.Point = point;
+        EventBroker->Publish(e);
+        //TODO: Bricks dont collide with walls D=
+
+        SetNumberOfBricks(NumberOfBricks() - 1);
+        if (NumberOfBricks() <= 0) {
+            SetMultiBalls(MultiBalls() + 1);
+        }
+        Events::ScoreEvent es;
+        es.Score = brick->Score;
+        EventBroker->Publish(es);
+
+<<<<<<< HEAD
+       // std::cout << NumberOfBricks() << std::endl;
+=======
+        //std::cout << NumberOfBricks() << std::endl;
+>>>>>>> origin/master
+        //std::cout << "Score: " << Score() << std::endl;
+    }
+
+    return true;
+}
+
+bool dd::Systems::LevelSystem::OnLifeLost(const dd::Events::LifeLost &event)
+{
+    SetLives(Lives() - 1);
+
+    return true;
+}
+
+bool dd::Systems::LevelSystem::OnScoreEvent(const dd::Events::ScoreEvent &event)
+{
+    SetScore(Score() += event.Score);
+
+    return true;
+}
+
+bool dd::Systems::LevelSystem::OnMultiBall(const dd::Events::MultiBall &event)
+{
+    SetMultiBalls(MultiBalls()+2);
+}
+
+bool dd::Systems::LevelSystem::OnCreatePowerUp(const dd::Events::CreatePowerUp &event)
+{
+    SetPowerUps(PowerUps() + 1);
+    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);
+    cPhys->Static = false;
+    cPhys->Category = CollisionLayer::Type::PowerUp;
+    cPhys->Mask = CollisionLayer::Type::Pad;
+
+    std::shared_ptr<Components::PowerUp> cPow = m_World->AddComponent<Components::PowerUp>(powerUp);
+
+
+    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);
+
+    return true;
+}
+
+bool dd::Systems::LevelSystem::OnPowerUpTaken(const dd::Events::PowerUpTaken &event)
+{
+    SetPowerUps(PowerUps() - 1);
+    return true;
+}
+
+bool dd::Systems::LevelSystem::OnStageCleared(const dd::Events::StageCleared &event)
+{
+    return true;
+}
+
+void dd::Systems::LevelSystem::EndLevel()
+{
+    Events::StageCleared e;
+    EventBroker->Publish(e);
+    return;
+}
+

src/game/Game/PadSystem.cpp

@@ -72,6 +72,7 @@ void dd::Systems::PadSystem::Update(double dt)
     transform->Velocity += acceleration  * (float)dt;
     transform->Velocity -= transform->Velocity * pad->SlowdownModifier * (float)dt;
 
+
     if (Left()) {
         acceleration.x = -pad->AccelerationSpeed;
     } else if (Right()) {
@@ -108,7 +109,9 @@ EntityID dd::Systems::PadSystem::CreateBall()
     std::shared_ptr<Components::Ball> cball = m_World->AddComponent<Components::Ball>(ent);
     std::shared_ptr<Components::Physics> physics = m_World->AddComponent<Components::Physics>(ent);
     physics->Static = false;
-
+    physics->Category = CollisionLayer::Type::Ball;
+    physics->Mask = CollisionLayer::Type::Pad | CollisionLayer::Type::Brick | CollisionLayer::Type::Wall;
+    physics->Calculate = true;
     cball->Speed = 5.f;
 
     m_World->CommitEntity(ent);
@@ -188,10 +191,9 @@ bool dd::Systems::PadSystem::OnContact(const dd::Events::Contact &event)
 
     //float movementX = (event.ContactPoint.x - transformPad->Position.x) * movementMultiplier;
     float movementY = glm::cos((abs(movementX) / ((1.6f) * movementMultiplier)) * 3.14159265359f / 2)+ 0.2;
-
     //std::cout << movementX << " " << movementY << std::endl;
-
     float len = glm::length<float>(transformBall->Velocity);
+    //auto pointlight = m_World->AddComponent<Components::PointLight>(ent);
 
 
     transformBall->Velocity += glm::vec3(transformPad->Velocity.x, 0, 0);
@@ -234,9 +236,9 @@ bool dd::Systems::PadSystem::OnContactPowerUp(const dd::Events::Contact &event)
         return false;
     }
 
-    m_World->RemoveComponent<Components::PowerUp>(entityPower);
-    m_World->RemoveComponent<Components::CircleShape>(entityPower);
-    m_World->RemoveComponent<Components::Physics>(entityPower);
+//    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";

src/game/Game/PadSystem.cpp.orig

@@ -0,0 +1,313 @@
+//
+// Created by Adniklastrator on 2015-09-10.
+//
+
+#include "PrecompiledHeader.h"
+#include "Game/PadSystem.h"
+#include "Core/World.h"
+#include <iostream>
+#include <Game/CPad.h>
+#include <Rendering/CPointLight.h>
+
+
+void dd::Systems::PadSystem::Initialize()
+{
+    Events::BindKey r;
+    r.KeyCode = GLFW_KEY_RIGHT;
+    r.Command = "right";
+    EventBroker->Publish(r);
+
+    Events::BindKey l;
+    l.KeyCode = GLFW_KEY_LEFT;
+    l.Command = "left";
+    EventBroker->Publish(l);
+
+    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);
+    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 != nullptr) {
+        if (ReplaceBall() == true) {
+            SetReplaceBall(false);
+
+            auto transform = m_World->GetComponent<Components::Transform>(entity);
+            transform->Position = glm::vec3(0.0f, 0.26f, -10.f);
+            transform->Velocity = glm::vec3(0.0f, -ball->Speed, 0.f);
+        }
+    }
+}
+
+void dd::Systems::PadSystem::Update(double dt)
+{
+    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") {
+                SetEntity(it->first);
+                SetTransform(m_World->GetComponent<Components::Transform>(Entity()));
+                SetPad(m_World->GetComponent<Components::Pad>(Entity()));
+                break;
+            }
+        }
+    }
+
+    auto transform = Transform();
+    auto pad = Pad();
+    auto acceleration = Acceleration();
+
+    if (transform->Velocity.x < -pad->MaxSpeed) {
+        transform->Velocity.x = -pad->MaxSpeed;
+    }
+    else if (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;
+
+
+    if (Left()) {
+        acceleration.x = -pad->AccelerationSpeed;
+<<<<<<< HEAD
+    }
+    else if (Right()) {
+=======
+    } else if (Right()) {
+>>>>>>> 72413dc0a93bd3a2f6ab9fa7e19bbc3b846232db
+        acceleration.x = pad->AccelerationSpeed;
+    } else {
+        acceleration.x = 0.f;
+    }
+
+    SetTransform(transform);
+    SetPad(pad);
+    SetAcceleration(acceleration);
+
+    if (MultiBall() == true) {
+        SetMultiBall(false);
+
+        Events::MultiBall e;
+        e.padTransform = transform;
+        EventBroker->Publish(e);
+    }
+
+    return;
+}
+
+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.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";
+    //auto pointlight = m_World->AddComponent<Components::PointLight>(ent);
+    std::shared_ptr<Components::CircleShape> circleShape = m_World->AddComponent<Components::CircleShape>(ent);
+    std::shared_ptr<Components::Ball> cball = m_World->AddComponent<Components::Ball>(ent);
+    std::shared_ptr<Components::Physics> physics = m_World->AddComponent<Components::Physics>(ent);
+    physics->Static = false;
+
+    cball->Speed = 10;
+
+    m_World->CommitEntity(ent);
+
+    return ent;
+}
+
+bool dd::Systems::PadSystem::OnKeyDown(const dd::Events::KeyDown &event)
+{
+    int val = event.KeyCode;
+    if (val == GLFW_KEY_UP) {
+        //std::cout << "Up!" << std::endl;
+    } else if (val == GLFW_KEY_DOWN) {
+        //std::cout << "Down!" << std::endl;
+    } else if (val == GLFW_KEY_LEFT) {
+        //std::cout << "Left!" << std::endl;
+        //acceleration.x = -0.01f;
+        SetLeft(true);
+    } else if (val == GLFW_KEY_RIGHT) {
+        //std::cout << "Right!" << std::endl;
+        //acceleration.x = 0.01f;
+        SetRight(true);
+    } else if (val == GLFW_KEY_R) {
+        SetReplaceBall(true);
+    } else if (val == GLFW_KEY_M) {
+        SetMultiBall(true);
+    } else if (val == GLFW_KEY_D) {
+        return false;
+    }
+    return true;
+}
+
+bool dd::Systems::PadSystem::OnKeyUp(const dd::Events::KeyUp &event)
+{
+    int val = event.KeyCode;
+    if (val == GLFW_KEY_UP) {
+
+    } else if (val == GLFW_KEY_DOWN) {
+
+    } else if (val == GLFW_KEY_LEFT) {
+        SetLeft(false);
+    } else if (val == GLFW_KEY_RIGHT) {
+        SetRight(false);
+    }
+    return true;
+}
+
+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) {
+        return false;
+    }
+    EntityID entityPad = event.Entity1;
+    auto pad = m_World->GetComponent<Components::Pad>(entityPad);
+    if (pad == NULL) {
+        return false;
+    }
+    auto transformBall = m_World->GetComponent<Components::Transform>(entityBall);
+    auto transformPad = m_World->GetComponent<Components::Transform>(entityPad);
+
+    float movementMultiplier = 0.5f;
+
+    //float movementX = (event.ContactPoint.x - transformPad->Position.x) * movementMultiplier;
+    //float movementY = glm::cos((abs(movementX) / (3.2f * movementMultiplier)) * 3.14159265359f / 2) * 2.f;
+    if (whatX > 0) {
+        movementX = movementMultiplier * whatX;
+        //std::cout << "Right!" << std::endl;
+    } else {
+        movementX = movementMultiplier * whatX;
+        //std::cout << "Left!" << std::endl;
+    }
+
+   // std::cout << movementX << " " << movementY << std::endl;
+
+    //float movementX = (event.ContactPoint.x - transformPad->Position.x) * movementMultiplier;
+<<<<<<< HEAD
+    float movementY = glm::cos((abs(movementX) / ((1.6f) * movementMultiplier)) * 3.14159265359f / 2) + 1;
+=======
+    float movementY = glm::cos((abs(movementX) / ((1.6f) * movementMultiplier)) * 3.14159265359f / 2)+ 0.2;
+>>>>>>> 72413dc0a93bd3a2f6ab9fa7e19bbc3b846232db
+
+    //std::cout << movementX << " " << movementY << std::endl;
+
+    float len = glm::length<float>(transformBall->Velocity);
+    //auto pointlight = m_World->AddComponent<Components::PointLight>(ent);
+
+
+    transformBall->Velocity += glm::vec3(transformPad->Velocity.x, 0, 0);
+    transformBall->Velocity = glm::normalize(transformBall->Velocity) * len;
+
+
+    //transform->Velocity = glm::vec3(movementX, movementY, 0.f);
+     */
+}
+
+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 != nullptr) {
+        entityPower = event.Entity1;
+    } else {
+        powerUp = m_World->GetComponent<Components::PowerUp>(event.Entity2);
+        if (powerUp != nullptr) {
+            entityPower = event.Entity2;
+        }
+    }
+    if (pad != nullptr) {
+        entityPad = event.Entity2;
+    } else {
+        pad = m_World->GetComponent<Components::Pad>(event.Entity1);
+        if (pad != nullptr) {
+            entityPad = event.Entity1;
+        }
+    }
+
+    if (entityPower == NULL || entityPad == NULL) {
+        return false;
+    }
+
+    pad = m_World->GetComponent<Components::Pad>(entityPad);
+    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";
+    EventBroker->Publish(ep);
+
+    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);
+    return true;
+}
+
+bool dd::Systems::PadSystem::OnMultiBall(const dd::Events::MultiBall &event)
+{
+    auto ent1 = CreateBall();
+    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 - 2, x2 = padTransform->Position.x + 2;
+    if (x1 < -3.1) {
+        x1 = 3;
+    }
+    if (x2 > 3.1) {
+        x2 = -3;
+    }
+    transform1->Position = glm::vec3(x1, -5.5, -10);
+    transform2->Position = glm::vec3(x2, -5.5, -10);
+
+    transform1->Velocity = glm::normalize(glm::vec3(5, 5 ,0.f)) * ball1->Speed;
+    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;
+
+    std::cout << "Command!" << std::endl;
+
+    if (command == "right") {
+        std::cout << "Right!" << std::endl;
+    } else if (command == "left") {
+        std::cout << "Left!" << std::endl;
+    }
+
+    return true;
+}