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

src/game/Game/BallSystem.cpp

@@ -41,7 +41,7 @@ void dd::Systems::BallSystem::Initialize()
         std::shared_ptr<Components::Template> ballTemplate = m_World->AddComponent<Components::Template>(ent);
         physics->CollisionType = CollisionType::Type::Dynamic;
         physics->Category = CollisionLayer::Type::Ball;
-        physics->Mask = static_cast<CollisionLayer::Type>(CollisionLayer::Type::Pad | CollisionLayer::Type::Brick | CollisionLayer::Type::Wall);
+		physics->Mask = static_cast<CollisionLayer::Type>(CollisionLayer::Type::Pad | CollisionLayer::Type::Brick | CollisionLayer::Type::Wall | CollisionLayer::LifeBuoy);
         physics->Calculate = true;
         transform->Sticky = true;
 
@@ -247,13 +247,13 @@ bool dd::Systems::BallSystem::Contact(const Events::Contact &event)
     }
     else {
         return false;
-        //TODO: Add support for power-up collisions
     }
 
-
+	
     auto ballTransform = m_World->GetComponent<Components::Transform>(ballEntity);
     glm::vec2 ballVelocity = glm::vec2(ballTransform->Velocity.x, ballTransform->Velocity.y);
 
+
     if (m_World->GetProperty<std::string>(otherEntitiy, "Name") == "Pad") {
 		auto padTransform = m_World->GetComponent<Components::Transform>(otherEntitiy);
 
@@ -294,8 +294,11 @@ bool dd::Systems::BallSystem::Contact(const Events::Contact &event)
         ec.Ball = ballEntity;
         EventBroker->Publish(ec);
         //std::cout << "Combo: " << ballComponent->Combo << std::endl;
-    }
-    else {
+	}	// Lifebuoy should always reflect the ball upwards
+	else if (m_World->GetProperty<std::string>(otherEntitiy, "Name") == "Lifebuoy"){
+		ballTransform->Velocity = glm::vec3(ballTransform->Velocity.x,  abs(ballTransform->Velocity.y), ballTransform->Velocity.z);
+
+	} else {
         auto it = m_Contacts.find(ballEntity);
         if (it == m_Contacts.end()) {
             std::list<glm::vec2> normalList;
@@ -316,20 +319,13 @@ void dd::Systems::BallSystem::ResolveContacts()
 {
 
     for (auto c : m_Contacts) {
-        int count = 0;
         EntityID entity = c.first;
         std::list<glm::vec2> contactNormals = c.second;
         glm::vec2 finalNormal = glm::vec2(0.f);
         for (auto it = contactNormals.begin(); it != contactNormals.end(); it++) {
             finalNormal = finalNormal + (*it);
-            count++;
         }
         finalNormal = glm::normalize(finalNormal);
-
-        if (count > 1) {
-            LOG_INFO("MultiCollision %i", count);
-        }
-
         auto transform = m_World->GetComponent<Components::Transform>(entity);
         glm::vec2 velocity = glm::vec2(transform->Velocity.x, transform->Velocity.y);
         glm::vec2 reflectedVelocity = glm::reflect(velocity, finalNormal);

src/game/Game/LevelSystem.cpp

@@ -30,7 +30,7 @@ void dd::Systems::LevelSystem::Initialize()
     cPhys->CollisionType = CollisionType::Type::Static;
     cPhys->GravityScale = 0.f;
     cPhys->Category = CollisionLayer::Type::Brick;
-    cPhys->Mask = static_cast<CollisionLayer::Type>(CollisionLayer::Type::Ball | CollisionLayer::Type::Projectile);
+    cPhys->Mask = static_cast<CollisionLayer::Type>(CollisionLayer::Type::Ball | CollisionLayer::Type::Projectile | CollisionLayer::Type::Wall | CollisionLayer::LifeBuoy);
     transform->Sticky = false;
 
     model->ModelFile = "Models/Brick/WhiteBrick.obj";

src/game/Game/LifebuoySystem.cpp

@@ -21,16 +21,16 @@ void dd::Systems::LifebuoySystem::Initialize()
 		ctransform->Position = glm::vec3(50.f, -4.8f, -10.f);
 		auto rectangleShape = m_World->AddComponent<Components::RectangleShape>(ent);
 		auto lifebuoyTemplate = m_World->AddComponent<Components::Template>(ent);
-		rectangleShape->Dimensions = glm::vec2(1.f, 0.1f);
+		rectangleShape->Dimensions = glm::vec2(0.9f, 0.19f);
 		auto physics = m_World->AddComponent<Components::Physics>(ent);
 		physics->CollisionType = CollisionType::Type::Static;
-		physics->Category = CollisionLayer::Type::Other;
-		physics->Mask = static_cast<CollisionLayer::Type>(CollisionLayer::Ball | CollisionLayer::Pad | CollisionLayer::Wall | CollisionLayer::Water);
-		physics->Density = 0.001;
+		physics->Category = CollisionLayer::LifeBuoy;
+		physics->Mask = static_cast<CollisionLayer::Type>(CollisionLayer::Ball | CollisionLayer::Brick | CollisionLayer::LifeBuoy | CollisionLayer::Pad | CollisionLayer::Water);
+		physics->Density = 1.0f;
 		physics->GravityScale = 1;
 		ctransform->Sticky = true;
 		auto cModel = m_World->AddComponent<Components::Model>(ent);
-		cModel->ModelFile = "Models/Ship/Ship.obj";
+		cModel->ModelFile = "Models/Lifebuoy/Lifebuoy.obj";
 		auto lifebuoy = m_World->AddComponent<Components::Lifebuoy>(ent);
 
 		m_World->CommitEntity(ent);
@@ -43,7 +43,24 @@ void dd::Systems::LifebuoySystem::Initialize()
 
 void dd::Systems::LifebuoySystem::Update(double dt)
 {
+	for (auto it = m_LifeBuoys.begin(); it != m_LifeBuoys.end();) {
+		it->TimeToLive -= dt;
+		if (it->TimeToLive < 0.f) {
+			m_World->RemoveEntity(it->Entity);
+			m_LifeBuoys.erase(it++);
+		}
+		else {
+			auto transformComponent = m_World->GetComponent<Components::Transform>(it->Entity);
 
+			if (transformComponent->Position.x > m_RightEdge) {
+				transformComponent->Position = glm::vec3(m_LeftEdge + 0.1f, transformComponent->Position.y, transformComponent->Position.z);
+			}
+			else if (transformComponent->Position.x < m_LeftEdge) {
+				transformComponent->Position = glm::vec3(m_RightEdge - 0.1f, transformComponent->Position.y, transformComponent->Position.z);
+			}
+			++it;
+		}
+	}
 }
 
 void dd::Systems::LifebuoySystem::UpdateEntity(double dt, EntityID entity, EntityID parent)
@@ -79,10 +96,16 @@ bool dd::Systems::LifebuoySystem::OnContact(const dd::Events::Contact &event)
 bool dd::Systems::LifebuoySystem::OnLifebuoy(const dd::Events::Lifebuoy &event) 
 {
 	auto ent = m_World->CloneEntity(m_Template);
+	m_World->SetProperty(ent, "Name", "Lifebuoy");
 	m_World->RemoveComponent<Components::Template>(ent);
 	auto transform = m_World->GetComponent<Components::Transform>(ent);
 	auto physics = m_World->GetComponent<Components::Physics>(ent);
 	physics->CollisionType = CollisionType::Type::Dynamic;
-	transform->Position = glm::vec3(event.Transform->Position.x, transform->Position.y, -10.f);
+	transform->Position = glm::vec3(event.Transform->Position.x, transform->Position.y + 2.f, -10.f);
+	transform->Velocity = glm::vec3(20.f, 3.f, 0.f);
+	LifeBuoyInfo info;
+	info.Entity = ent;
+	m_LifeBuoys.push_back(info);
+	
 	return true;
 }

src/game/Game/PadSystem.cpp

@@ -38,9 +38,9 @@ void dd::Systems::PadSystem::Initialize()
         auto rectangleShape = m_World->AddComponent<Components::RectangleShape>(ent);
         rectangleShape->Dimensions = glm::vec2(1.f, 0.1f);
         auto physics = m_World->AddComponent<Components::Physics>(ent);
-        physics->CollisionType = CollisionType::Type::Dynamic;
+        physics->CollisionType = CollisionType::Type::Kinematic;
         physics->Category = CollisionLayer::Type::Pad;
-		physics->Mask = static_cast<CollisionLayer::Type>(CollisionLayer::Ball | CollisionLayer::PowerUp);
+		physics->Mask = static_cast<CollisionLayer::Type>(CollisionLayer::Ball | CollisionLayer::PowerUp | CollisionLayer::LifeBuoy);
         physics->Calculate = true;
         ctransform->Sticky = true;
         auto cModel = m_World->AddComponent<Components::Model>(ent);

src/game/Physics/ContactListener.cpp

@@ -12,7 +12,6 @@ void dd::Systems::PhysicsSystem::ContactListener::BeginContact(b2Contact* contac
     e.Entity2 = m_PhysicsSystem->m_BodiesToEntities[contact->GetFixtureB()->GetBody()];
     e.Normal = glm::normalize(glm::vec2(contact->GetManifold()->localNormal.x, contact->GetManifold()->localNormal.y));
     e.SignificantNormal = glm::normalize((glm::abs(e.Normal.x) > glm::abs(e.Normal.y)) ? glm::vec2(e.Normal.x, 0) : glm::vec2(0, e.Normal.y));
-
     m_PhysicsSystem->EventBroker->Publish(e);
 }
 
@@ -29,10 +28,17 @@ void dd::Systems::PhysicsSystem::ContactListener::PreSolve(b2Contact* contact, c
     auto physicsComponentA = m_PhysicsSystem->m_World->GetComponent<Components::Physics>(entityA);
     auto physicsComponentB = m_PhysicsSystem->m_World->GetComponent<Components::Physics>(entityB);
 
+
+	std::string propertyA = m_PhysicsSystem->m_World->GetProperty<std::string>(entityA, "Name");
+	std::string propertyB = m_PhysicsSystem->m_World->GetProperty<std::string>(entityB, "Name");
+
     if (physicsComponentA != nullptr && physicsComponentB != nullptr) {
         if (physicsComponentA->Calculate || physicsComponentB->Calculate) {
             // Turn of collisions
-            contact->SetEnabled(false);
+			if ((propertyA != "Lifebuoy" && propertyB != "Pad") || (propertyA != "Pad" && propertyB != "Lifebuoy")) {
+				contact->SetEnabled(false);
+			}
+			
         }
     }
 

src/game/Physics/PhysicsSystem.cpp

@@ -34,10 +34,9 @@ void dd::Systems::PhysicsSystem::InitializeWater()
     b2ParticleSystemDef m_ParticleSystemDef;
     m_ParticleSystemDef.radius = radius;
     m_ParticleSystemDef.gravityScale = gravityScale;
+	m_ParticleSystemDef.density = 4.f;
 
     m_WaterParticleSystem = m_PhysicsWorld->CreateParticleSystem(&m_ParticleSystemDef);
-
-
 }
 
 bool dd::Systems::PhysicsSystem::SetImpulse(const Events::SetImpulse &event)