RaiseWater implemented. Set Debug RaiseWater to true to activate it. And fixed second stage crashing.

include/Core/Engine.h

@@ -51,6 +51,7 @@
 #include "Game/CBrickPart.h"
 #include "Game/CWall.h"
 #include "Game/CKraken.h"
+#include "Game/CNewWaterVolume.h"
 #include "Game/CBackground.h"
 #include "Game/CTravels.h"
 #include "Game/CStickyAim.h"
@@ -149,6 +150,7 @@ public:
 		m_World->ComponentFactory.Register<Components::BrickPart>();
 		m_World->ComponentFactory.Register<Components::Pad>();
 		m_World->ComponentFactory.Register<Components::Wall>();
+		m_World->ComponentFactory.Register<Components::NewWaterVolume>();
 		m_World->ComponentFactory.Register<Components::Background>();
 		m_World->ComponentFactory.Register<Components::Life>();
 		m_World->ComponentFactory.Register<Components::Lifebuoy>();

include/Game/CBall.h

@@ -23,7 +23,7 @@ struct Ball : Component
 	bool InkBlaster = false;
 	bool Sticky = false;
 	glm::vec3 StickyPlacement = glm::vec3(0, 0, 0);
-    glm::vec3 SavedSpeed = glm::vec3(0, 0, 0);
+    glm::vec3 SavedSpeed = glm::vec3(0, 1, 0);
 };
 
 }

include/Game/CBrickPart.h

@@ -15,7 +15,8 @@ namespace Components
 
 struct BrickPart : Component
 {
-    
+	bool Submerged = false;
+	int NumberOfPartsInBrick;
 };
 
 }

include/Game/CNewWaterVolume.h

@@ -0,0 +1,25 @@
+//
+// Created by Adniklastrator on 2015-10-22.
+//
+
+#ifndef CNEWWATERVOLUME_H
+#define CNEWWATERVOLUME_H
+
+#include "Core/Component.h"
+
+namespace dd
+{
+
+namespace Components
+{
+
+struct NewWaterVolume : public Component
+{
+    
+};
+
+}
+
+}
+
+#endif //DAYDREAM_NEWWATERVOLUME_H

include/Game/LevelSystem.h

@@ -212,7 +212,7 @@ private:
 
     void GetNextLevel();
 	void SetBrokenModel(EntityID entity);
-	void CreateBrokenModelPart(EntityID Parent, std::string ModelPath, glm::vec3 RelativePosition, glm::vec2 Hitbox);
+	void CreateBrokenModelPart(EntityID Parent, std::string ModelPath, glm::vec3 RelativePosition, glm::vec2 Hitbox, int NumberOfParts);
 };
 
 }

include/Game/PadSystem.h

@@ -105,6 +105,9 @@ private:
 	double m_KrakenStrength = 0;
 	double m_PlayerStrength = 0;
     float m_Edge = 2.8f;
+	float m_PadOriginalHeight = -4.8;
+	float m_PadHeight = m_PadOriginalHeight;
+	float m_PadRiseSpeed = 0.2;
 	EntityID m_KrakenArm;
     Components::Transform* m_Transform = nullptr;
     Components::Pad* m_Pad = nullptr;

include/Game/TravellingSystem.h

@@ -18,6 +18,7 @@
 #include "Game/EStageCleared.h"
 #include "Game/CTravels.h"
 #include "Game/CBackground.h"
+#include "Game/CNewWaterVolume.h"
 
 
 namespace dd

include/Game/WaterSystem.h

@@ -11,9 +11,13 @@
 #include "Core/CTemplate.h"
 #include "Core/EventBroker.h"
 #include "Core/World.h"
+#include "Core/ConfigFile.h"
 #include "Transform/EMove.h"
+#include "Physics/CPhysics.h"
 #include "Physics/CWaterVolume.h"
 #include "Physics/CRectangleShape.h"
+#include "Game/CBrickPart.h"
+#include "Game/CNewWaterVolume.h"
 #include "Game/EPause.h"
 #include "Game/EResume.h"
 #include "Game/ERelevantObjectCreated.h"
@@ -47,6 +51,13 @@ public:
 private:
 	bool m_Pause = false;
 	EntityID m_BottomWall = 0;
+	float m_SubmergedOriginalHeight = -4.5;
+	float m_SubmergedHeight = m_SubmergedOriginalHeight;
+
+	bool m_RaiseWater = true;
+	bool m_RemoveWater = false;
+
+	std::array<int, 10> m_BrickPartCounters;
 
     dd::EventRelay<WaterSystem, dd::Events::Pause> m_EPause;
 	dd::EventRelay<WaterSystem, dd::Events::Resume> m_EResume;

src/game/Game/BallSystem.cpp

@@ -83,39 +83,19 @@ void dd::Systems::BallSystem::UpdateEntity(double dt, EntityID entity, EntityID
 	}
 
     auto ballComponent = m_World->GetComponent<Components::Ball>(entity);
-	
-    /*if (IsPaused()) {
-        if (ballComponent != nullptr) {
-            auto transform = m_World->GetComponent<Components::Transform>(entity);
-
-            if (!ballComponent->Paused) {
-                ballComponent->Paused = true;
-                ballComponent->SavedSpeed = transform->Velocity;
-                transform->Velocity = glm::vec3(0, 0, 0);
-            }
-        }
-        return;
-    } else {
-        if (ballComponent != nullptr) {
-            auto transform = m_World->GetComponent<Components::Transform>(entity);
-
-            if (ballComponent->Paused) {
-                transform->Velocity = ballComponent->SavedSpeed;
-                ballComponent->Paused = false;
-            }
-        }
-    }*/
 
     auto templateCheck = m_World->GetComponent<Components::Template>(entity);
     if (templateCheck != nullptr){ return; }
 
     if (ballComponent != nullptr) {
 		if (ReplaceBall()) {
+			m_First = true;
 			SetReplaceBall(false);
 			m_Waiting = true;
 			std::uniform_real_distribution<float> dist(-0.5f, 0.5f);
 			float random = dist(m_RandomGenerator);
 			ballComponent->SavedSpeed = glm::vec3(random, 1, 0.f);
+			//ballComponent->SavedSpeed = glm::vec3(0.f, 1, 0.f);
 			ballComponent->Waiting = true;
 			auto transform = m_World->GetComponent<Components::Transform>(entity);
 		}
@@ -128,6 +108,7 @@ void dd::Systems::BallSystem::UpdateEntity(double dt, EntityID entity, EntityID
 				/*std::uniform_real_distribution<float> dist(-0.5f, 0.5f);
 				float random = dist(m_RandomGenerator);*/
                 transform->Velocity = glm::normalize(ballComponent->SavedSpeed) * ballComponent->Speed;
+				//transform->Velocity = glm::normalize(glm::vec3(0, 1, 0)) * ballComponent->Speed;
             } else if (!ballComponent->Sticky) {
                 auto transform = m_World->GetComponent<Components::Transform>(entity);
                 transform->Velocity = glm::vec3(0.f, 0.f, 0.f);

src/game/Game/KrakenSystem.cpp

@@ -82,16 +82,16 @@ void dd::Systems::KrakenSystem::UpdateEntity(double dt, EntityID entity, EntityI
 		case 1: // Idle
 			m_KrakenTimer += dt;
 			if (m_KrakenTimer > m_KrakenSecondsToAction) {
+				m_KrakenTimer = 0;
 				if (m_NumberOfActions == 0) {
 					kraken->CurrentAction = 3;
-					break;
+				} else {
+					std::uniform_real_distribution<float> dist(1, 4.999f);
+					float random = dist(m_RandomGenerator);
+					//std::cout << random << std::endl;
+					kraken->CurrentAction = random;
+					//std::cout << kraken->CurrentAction << std::endl;
 				}
-				m_KrakenTimer = 0;
-				std::uniform_real_distribution<float> dist(1, 4.999f);
-				float random = dist(m_RandomGenerator);
-				//std::cout << random << std::endl;
-				kraken->CurrentAction = random;
-				//std::cout << kraken->CurrentAction << std::endl;
 			}
 			break;
 		case 2: // Grabbing

src/game/Game/LevelSystem.cpp

@@ -25,7 +25,7 @@ void dd::Systems::LevelSystem::Initialize()
 	EVENT_SUBSCRIBE_MEMBER(m_EBrickGenerating, &LevelSystem::OnBrickGenerating);
 	EVENT_SUBSCRIBE_MEMBER(m_EKrakenDefeated, &LevelSystem::OnKrakenDefeated);
 
-	m_GodMode = ResourceManager::Load<ConfigFile>("Config.ini")->GetValue("Cheat.GodMode", false);
+	m_GodMode = ResourceManager::Load<ConfigFile>("Config.ini")->GetValue<bool>("Cheat.GodMode", false);
 
 	//PointLightTest
 	{
@@ -240,6 +240,7 @@ void dd::Systems::LevelSystem::Initialize()
 	auto collisionSound = m_World->AddComponent<Components::CollisionSound>(m_BrickTemplate);
 	collisionSound->FilePath = "Sounds/Brick/shortbrickbreak.wav";
 	m_World->CommitEntity(m_BrickTemplate);
+
     return;
 }
 
@@ -278,15 +279,6 @@ void dd::Systems::LevelSystem::UpdateEntity(double dt, EntityID entity, EntityID
 		}
 	}
 
-	auto brickPart = m_World->GetComponent<Components::BrickPart>(entity);
-	if (brickPart != nullptr) {
-		auto transform = m_World->GetComponent<Components::Transform>(entity);
-		if (transform->Position.y < -10) {
-			m_World->RemoveEntity(entity);
-			return;
-		}
-	}
-
     auto brick = m_World->GetComponent<Components::Brick>(entity);
     if (brick != nullptr) {
         auto transform = m_World->GetComponent<Components::Transform>(entity);
@@ -1217,40 +1209,45 @@ void dd::Systems::LevelSystem::SetBrokenModel(EntityID entity)
 	std::uniform_int_distribution<int> dist(0, 2);
 	int index = dist(m_RandomGenerator);
 
+	int parts = 0;
+
 	switch (index)
 	{
 	case 0:
-		CreateBrokenModelPart(entity, "Models/Brick/BrickBreak/1/WhiteBrickBreak1.obj", glm::vec3(-0.29912f, 0.0082f, 0.f), glm::vec2(0.281f, 0.351f));
+		CreateBrokenModelPart(entity, "Models/Brick/BrickBreak/1/WhiteBrickBreak1.obj", glm::vec3(-0.29912f, 0.0082f, 0.f), glm::vec2(0.281f, 0.351f), 3);
-		CreateBrokenModelPart(entity, "Models/Brick/BrickBreak/1/WhiteBrickBreak2.obj", glm::vec3(0.07597f, -0.02899f, 0.f), glm::vec2(0.559f, 0.351f));
+		CreateBrokenModelPart(entity, "Models/Brick/BrickBreak/1/WhiteBrickBreak2.obj", glm::vec3(0.07597f, -0.02899f, 0.f), glm::vec2(0.559f, 0.351f), 3);
-		CreateBrokenModelPart(entity, "Models/Brick/BrickBreak/1/WhiteBrickBreak3.obj", glm::vec3(0.3227f, 0.05632, 0.f), glm::vec2(0.25f, 0.25f));
+		CreateBrokenModelPart(entity, "Models/Brick/BrickBreak/1/WhiteBrickBreak3.obj", glm::vec3(0.3227f, 0.05632, 0.f), glm::vec2(0.25f, 0.25f), 3);
 		break;
 
 	case 1:
-		CreateBrokenModelPart(entity, "Models/Brick/BrickBreak/2/WhiteBrickBreak1.obj", glm::vec3(-0.3236f, 0.0159f, 0.f), glm::vec2(0.237f, 0.327f));
+		CreateBrokenModelPart(entity, "Models/Brick/BrickBreak/2/WhiteBrickBreak1.obj", glm::vec3(-0.3236f, 0.0159f, 0.f), glm::vec2(0.237f, 0.327f), 4);
-		CreateBrokenModelPart(entity, "Models/Brick/BrickBreak/2/WhiteBrickBreak2.obj", glm::vec3(0.07645f, 0.03131f, 0.f), glm::vec2(0.594f, 0.211f));
+		CreateBrokenModelPart(entity, "Models/Brick/BrickBreak/2/WhiteBrickBreak2.obj", glm::vec3(0.07645f, 0.03131f, 0.f), glm::vec2(0.594f, 0.211f), 4);
-		CreateBrokenModelPart(entity, "Models/Brick/BrickBreak/2/WhiteBrickBreak3.obj", glm::vec3(0.09468f, -0.11792f, 0.f), glm::vec2(0.692f, 0.112f));
+		CreateBrokenModelPart(entity, "Models/Brick/BrickBreak/2/WhiteBrickBreak3.obj", glm::vec3(0.09468f, -0.11792f, 0.f), glm::vec2(0.692f, 0.112f), 4);
-		CreateBrokenModelPart(entity, "Models/Brick/BrickBreak/2/WhiteBrickBreak4.obj", glm::vec3(0.33957f, 0.13079f, 0.f), glm::vec2(0.208f, 0.085f));
+		CreateBrokenModelPart(entity, "Models/Brick/BrickBreak/2/WhiteBrickBreak4.obj", glm::vec3(0.33957f, 0.13079f, 0.f), glm::vec2(0.208f, 0.085f), 4);
 		break;
 
 	case 2:
-		CreateBrokenModelPart(entity, "Models/Brick/BrickBreak/3/WhiteBrickBreak1.obj", glm::vec3(-0.34882f, 0.0564f, 0.f), glm::vec2(0.175f, 0.228f));
+		CreateBrokenModelPart(entity, "Models/Brick/BrickBreak/3/WhiteBrickBreak1.obj", glm::vec3(-0.34882f, 0.0564f, 0.f), glm::vec2(0.175f, 0.228f), 4);
-		CreateBrokenModelPart(entity, "Models/Brick/BrickBreak/3/WhiteBrickBreak2.obj", glm::vec3(0.0678f, 0.07679f, 0.f), glm::vec2(0.699f, 0.183f));
+		CreateBrokenModelPart(entity, "Models/Brick/BrickBreak/3/WhiteBrickBreak2.obj", glm::vec3(0.0678f, 0.07679f, 0.f), glm::vec2(0.699f, 0.183f), 4);
-		CreateBrokenModelPart(entity, "Models/Brick/BrickBreak/3/WhiteBrickBreak3.obj", glm::vec3(-0.11862f, -0.10342, 0.f), glm::vec2(0.563f, 0.164f));
+		CreateBrokenModelPart(entity, "Models/Brick/BrickBreak/3/WhiteBrickBreak3.obj", glm::vec3(-0.11862f, -0.10342, 0.f), glm::vec2(0.563f, 0.164f), 4);
-		CreateBrokenModelPart(entity, "Models/Brick/BrickBreak/3/WhiteBrickBreak4.obj", glm::vec3(0.31479f, -0.06351f, 0.f), glm::vec2(0.261f, 0.21f));
+		CreateBrokenModelPart(entity, "Models/Brick/BrickBreak/3/WhiteBrickBreak4.obj", glm::vec3(0.31479f, -0.06351f, 0.f), glm::vec2(0.261f, 0.21f), 4);
 		break;
 
 	default:
 		LOG_INFO("Something went wrong with the random generator in SetBrokenModel");
 		break;
 	}
+
+	return;
 }
 
-void dd::Systems::LevelSystem::CreateBrokenModelPart(EntityID Parent, std::string ModelPath, glm::vec3 RelativePosition, glm::vec2 Hitbox)
+void dd::Systems::LevelSystem::CreateBrokenModelPart(EntityID Parent, std::string ModelPath, glm::vec3 RelativePosition, glm::vec2 Hitbox, int NumberOfParts)
 {
 	auto ent = m_World->CreateEntity(Parent);
 	auto cTemplate = m_World->AddComponent<Components::Template>(ent);
 	auto cTransform = m_World->AddComponent<Components::Transform>(ent);
 	auto cBrickPart = m_World->AddComponent<Components::BrickPart>(ent);
+	cBrickPart->NumberOfPartsInBrick = NumberOfParts;
 
 	cTransform->Position = RelativePosition;
 
@@ -1263,6 +1260,7 @@ void dd::Systems::LevelSystem::CreateBrokenModelPart(EntityID Parent, std::strin
 	auto cPhys = m_World->AddComponent<Components::Physics>(ent);
 	cPhys->CollisionType = CollisionType::Type::Dynamic;
 	cPhys->GravityScale = 1.f;
+	cPhys->Density = 30;
 	cPhys->Category = CollisionLayer::Type::Brick;
 	cPhys->Mask = static_cast<CollisionLayer::Type>(CollisionLayer::Type::Wall);
 }

src/game/Game/LifeSystem.cpp

@@ -79,8 +79,9 @@ bool dd::Systems::LifeSystem::OnLifeLost(const dd::Events::LifeLost &event)
 {
 	if (!m_GodMode){
 		SetLives(Lives() - 1);
+		return true;
 	}
-	return true;
+	return false;
 }
 
 bool dd::Systems::LifeSystem::OnPause(const dd::Events::Pause &event)

src/game/Game/PadSystem.cpp

@@ -44,7 +44,7 @@ void dd::Systems::PadSystem::Initialize()
         auto ent = m_World->CreateEntity();
         m_World->SetProperty(ent, "Name", "Pad");
         auto ctransform = m_World->AddComponent<Components::Transform>(ent);
-        ctransform->Position = glm::vec3(0.f, -4.8f, -10.f);
+        ctransform->Position = glm::vec3(0.f, m_PadHeight, -10.f);
         auto rectangleShape = m_World->AddComponent<Components::RectangleShape>(ent);
         rectangleShape->Dimensions = glm::vec2(1.f, 0.1f);
         auto physics = m_World->AddComponent<Components::Physics>(ent);
@@ -159,6 +159,13 @@ void dd::Systems::PadSystem::Update(double dt)
 	auto pad = Pad();
 	auto acceleration = Acceleration();
 
+	if (glm::abs(transform->Position.y - m_PadHeight) > m_PadRiseSpeed) {
+		if (transform->Position.y < m_PadHeight) {
+			transform->Position.y += m_PadRiseSpeed * (float)dt;
+		} else if (transform->Position.y > m_PadHeight) {
+			transform->Position.y -= m_PadRiseSpeed * 5 * (float)dt;
+		}
+	}
     if (transform->Velocity.x < -pad->MaxSpeed) {
         transform->Velocity.x = -pad->MaxSpeed;
     }
@@ -420,6 +427,7 @@ bool dd::Systems::PadSystem::OnStageCleared(const dd::Events::StageCleared &even
 {
     //auto entity = CreateBall();
 	m_StickyAim->Aiming = false;
+	m_PadHeight = m_PadOriginalHeight;
     return true;
 }
 
@@ -451,14 +459,8 @@ bool dd::Systems::PadSystem::OnRaiseWaterWall(const dd::Events::RaiseWaterWall &
 
 bool dd::Systems::PadSystem::RaisePad(float amount, float speed)
 {
-	auto transform = Transform();
+	m_PadHeight += amount;
-	glm::vec3 raise = glm::vec3(0, amount, 0);
+	m_PadRiseSpeed = speed;
-	Events::Move e;
-	e.Entity = m_Entity;
-	e.GoalPosition = transform->Position + raise;
-	e.Speed = speed;
-	e.Queue = true;
-	EventBroker->Publish(e);
 	return true;
 }
 

src/game/Game/WaterSystem.cpp

@@ -14,6 +14,8 @@ void dd::Systems::WaterSystem::Initialize()
 	EVENT_SUBSCRIBE_MEMBER(m_ERaiseWater, &WaterSystem::OnRaiseWater);
 	EVENT_SUBSCRIBE_MEMBER(m_ERaiseWaterWall, &WaterSystem::OnRaiseWaterWall);
 
+	m_RaiseWater = ResourceManager::Load<ConfigFile>("Config.ini")->GetValue<bool>("Debug.RaiseWater", false);
+
 	//Water test
 	{
 		auto t_waterBody = m_World->CreateEntity();
@@ -24,6 +26,10 @@ void dd::Systems::WaterSystem::Initialize()
 		auto body = m_World->AddComponent<Components::RectangleShape>(t_waterBody);
 		m_World->CommitEntity(t_waterBody);
 	}
+
+	m_BrickPartCounters =
+	{0, 0, 0, 0, 0,
+	 0, 0, 0, 0, 0 };
 }
 
 void dd::Systems::WaterSystem::Update(double dt)
@@ -43,6 +49,31 @@ void dd::Systems::WaterSystem::UpdateEntity(double dt, EntityID entity, EntityID
 	auto templateCheck = m_World->GetComponent<Components::Template>(entity);
 	if (templateCheck != nullptr){ return; }
 
+	auto brickPart = m_World->GetComponent<Components::BrickPart>(entity);
+	if (brickPart != nullptr) {
+		auto transform = m_World->GetComponent<Components::Transform>(entity);
+		if (m_RaiseWater) {
+			if (!brickPart->Submerged) {
+				if (transform->Position.y < m_SubmergedHeight) {
+					brickPart->Submerged = true;
+					m_BrickPartCounters[brickPart->NumberOfPartsInBrick]++;
+					std::cout << "Parts: " << m_BrickPartCounters[brickPart->NumberOfPartsInBrick] << " of " << brickPart->NumberOfPartsInBrick << std::endl;
+					if (m_BrickPartCounters[brickPart->NumberOfPartsInBrick] >= brickPart->NumberOfPartsInBrick) {
+						m_BrickPartCounters[brickPart->NumberOfPartsInBrick] = 0;
+						Events::RaiseWater e;
+						e.Amount = 0.2;
+						e.Speed = 0.2;
+						EventBroker->Publish(e);
+					}
+				}
+			}
+		}
+		if (transform->Position.y < -10) {
+			m_World->RemoveEntity(entity);
+			return;
+		}
+	}
+
 	if (m_BottomWall == 0) {
 		for (auto it = m_World->GetEntities()->begin(); it != m_World->GetEntities()->end(); it++) {
 			if (m_World->GetProperty<std::string>(it->first, "Name") == "BottomWall") {
@@ -51,6 +82,21 @@ void dd::Systems::WaterSystem::UpdateEntity(double dt, EntityID entity, EntityID
 			}
 		}
 	}
+
+	auto newWater = m_World->GetComponent<Components::NewWaterVolume>(entity);
+	if (newWater != nullptr) {
+		if (m_RemoveWater) {
+			//m_World->RemoveComponent<Components::WaterVolume>(entity);
+			//m_World->RemoveComponent<Components::RectangleShape>(entity);
+			//m_World->RemoveComponent<Components::WaterVolume>(entity);
+			//m_World->RemoveEntity(entity);
+			//m_World->RemoveComponent<Components::>();
+		}
+		/*auto transform = m_World->AddComponent<Components::Transform>(entity);
+		if (transform->Position.y < -10) {
+			m_World->RemoveEntity(entity);
+		}*/
+	}
 }
 
 bool dd::Systems::WaterSystem::OnPause(const dd::Events::Pause &event)
@@ -80,13 +126,14 @@ bool dd::Systems::WaterSystem::OnRelevantObjectCreated(const dd::Events::Relevan
 
 bool dd::Systems::WaterSystem::OnStageCleared(const dd::Events::StageCleared &event)
 {
-	
+	m_SubmergedHeight = m_SubmergedOriginalHeight;
+	m_RemoveWater = true;
 	return true;
 }
 
 bool dd::Systems::WaterSystem::OnArrivedAtNewStage(const dd::Events::ArrivedAtNewStage &event)
 {
-	
+	m_RemoveWater = false;
 	return true;
 }
 
@@ -95,13 +142,16 @@ bool dd::Systems::WaterSystem::OnRaiseWater(const dd::Events::RaiseWater &event)
 	{
 		auto t_waterBody = m_World->CreateEntity();
 		auto transform = m_World->AddComponent<Components::Transform>(t_waterBody);
-		transform->Position = glm::vec3(0.f, -3.5f, -10.f);
+		transform->Position = glm::vec3(0.f, m_SubmergedHeight, -10.f);
-		transform->Scale = glm::vec3(7.0f, event.Amount * 1.6f, 1.f);
+		transform->Scale = glm::vec3(7.0f, event.Amount * 1.4f, 1.f);
 		auto water = m_World->AddComponent<Components::WaterVolume>(t_waterBody);
+		auto newWater = m_World->AddComponent<Components::NewWaterVolume>(t_waterBody); //Meaning it isn't the original water we had.
 		auto body = m_World->AddComponent<Components::RectangleShape>(t_waterBody);
 		m_World->CommitEntity(t_waterBody);
 	}
 
+	m_SubmergedHeight += event.Amount;
+
 	return true;
 }