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

src/game/Game/BallSystem.cpp

@@ -51,6 +51,8 @@ void dd::Systems::BallSystem::Initialize()
         physics->Category = CollisionLayer::Type::Ball;
 		physics->Mask = static_cast<CollisionLayer::Type>(CollisionLayer::Type::Pad | CollisionLayer::Type::Brick | CollisionLayer::Type::Wall | CollisionLayer::LifeBuoy);
         physics->Calculate = true;
+		auto collisionSound = m_World->AddComponent<Components::CollisionSound>(ent);
+		collisionSound->FilePath = "Sounds/Jelly/squid-bounce-n.wav";
 
         m_World->CommitEntity(ent);
 
@@ -319,17 +321,20 @@ bool dd::Systems::BallSystem::Contact(const Events::Contact &event)
 			particleEvent.EmittingAngle = glm::half_pi<float>();
 			particleEvent.Spread = 0.f;
 			particleEvent.NumberOfTicks = 1;
-			particleEvent.ParticleLifeTime = 2.f;
+			particleEvent.ParticleLifeTime = 1.3f;
 			particleEvent.ParticlesPerTick = 1;
-			particleEvent.Position = glm::vec3(ballTransform->Position.x, -3.f, -3.f);
-			if (ballTransform->Position.x >= 2.7f) {
-				particleEvent.Position = glm::vec3(2.7f, -3.f, -3.f);
-			} else if (ballTransform->Position.x <= -2.7f) {
-				particleEvent.Position = glm::vec3(-2.7f, -3.f, -3.f);
+			particleEvent.Position = glm::vec3(ballTransform->Position.x, -3.5f, -3.f);
+			if (ballTransform->Position.x >= 2.5f) {
+				particleEvent.Position = glm::vec3(2.5f, -3.5f, -3.f);
+			} else if (ballTransform->Position.x <= -2.5f) {
+				particleEvent.Position = glm::vec3(-2.5f, -3.5f, -3.f);
 			}
-			particleEvent.ScaleValues.push_back(glm::vec3(1.f));
+			particleEvent.ScaleValues.push_back(glm::vec3(1.5f));
+			particleEvent.ScaleValues.push_back(glm::vec3(2.f));
 			particleEvent.Color = glm::vec4(1.f);
-			particleEvent.Speed = 0;
+			particleEvent.Speed = 1.f;
+			particleEvent.AlphaValues.push_back(1.f);
+			particleEvent.AlphaValues.push_back(0.7f);
 
 			if (ballComponent->Combo <= 9) {
 				particleEvent.SpriteFile = "Textures/Combo/Combo00" + std::to_string(ballComponent->Combo) + ".png";

src/game/Game/KrakenSystem.cpp

@@ -11,8 +11,11 @@ void dd::Systems::KrakenSystem::Initialize()
 	m_RandomGenerator = std::mt19937(rd());
     EVENT_SUBSCRIBE_MEMBER(m_EPause, &KrakenSystem::OnPause);
 	EVENT_SUBSCRIBE_MEMBER(m_EResume, &KrakenSystem::OnResume);
+	EVENT_SUBSCRIBE_MEMBER(m_EContact, &KrakenSystem::OnContact);
 	EVENT_SUBSCRIBE_MEMBER(m_EKrakenAppear, &KrakenSystem::OnKrakenAppear);
 	EVENT_SUBSCRIBE_MEMBER(m_EKrakenAttack, &KrakenSystem::OnKrakenAttack);
+	EVENT_SUBSCRIBE_MEMBER(m_EKrakenHit, &KrakenSystem::OnKrakenHit);
+	EVENT_SUBSCRIBE_MEMBER(m_EKrakenDefeated, &KrakenSystem::OnKrakenDefeated);
 	EVENT_SUBSCRIBE_MEMBER(m_EBrickGenerating, &KrakenSystem::OnBrickGenerating);
 
 	EntityID ent = m_World->CreateEntity();
@@ -59,7 +62,7 @@ void dd::Systems::KrakenSystem::Update(double dt)
 
 void dd::Systems::KrakenSystem::UpdateEntity(double dt, EntityID entity, EntityID parent)
 {
-    if (IsPaused()) {
+    if (IsPaused() || !m_KrakenBattle) {
         return;
     }
 
@@ -68,18 +71,27 @@ void dd::Systems::KrakenSystem::UpdateEntity(double dt, EntityID entity, EntityI
 
 	auto kraken = m_World->GetComponent<Components::Kraken>(entity);
 	if (kraken != nullptr) {
+		auto transform = m_World->GetComponent<Components::Transform>(entity);
+		if (transform->Position.y < -10) {
+			m_World->RemoveEntity(entity);
+			return;
+		}
 		Events::KrakenAttack krakenAttack;
 		switch (kraken->CurrentAction)
 		{
 		case 1: // Idle
-			//m_KrakenTimer += dt;
+			m_KrakenTimer += dt;
 			if (m_KrakenTimer > m_KrakenSecondsToAction) {
+				if (m_NumberOfActions == 0) {
+					kraken->CurrentAction = 3;
+					break;
+				}
 				m_KrakenTimer = 0;
-				std::uniform_real_distribution<float> dist(1, 2.999f);
+				std::uniform_real_distribution<float> dist(1, 4.999f);
 				float random = dist(m_RandomGenerator);
-				std::cout << random << std::endl;
+				//std::cout << random << std::endl;
 				kraken->CurrentAction = random;
-				std::cout << kraken->CurrentAction << std::endl;
+				//std::cout << kraken->CurrentAction << std::endl;
 			}
 			break;
 		case 2: // Grabbing
@@ -90,9 +102,29 @@ void dd::Systems::KrakenSystem::UpdateEntity(double dt, EntityID entity, EntityI
 			EventBroker->Publish(krakenAttack);
 			break;
 		case 3: // Brick Generating
-			break;
-		case 4: // Moving
-			break;
+			{
+				kraken->CurrentAction = 1;
+				Events::BrickGenerating e;
+				e.Origin1 = glm::vec3(-5, 7, -10);
+				e.Origin2 = glm::vec3(5, 7, -10);
+				std::uniform_real_distribution<float> dist(1, 5.999f);
+				float random = dist(m_RandomGenerator);
+				e.Set = random;
+				EventBroker->Publish(e);
+				break;
+			}
+		case 4: // Brick Generating second case
+			{
+				kraken->CurrentAction = 1;
+				Events::BrickGenerating e;
+				e.Origin1 = glm::vec3(-5, 7, -10);
+				e.Origin2 = glm::vec3(5, 7, -10);
+				std::uniform_real_distribution<float> dist(1, 5.999f);
+				float random = dist(m_RandomGenerator);
+				e.Set = random;
+				EventBroker->Publish(e);
+				break;
+			}
 		case 5: // Taunting
 			if (m_ReturnToIdle) {
 				m_ReturnToIdle = false;
@@ -126,6 +158,45 @@ bool dd::Systems::KrakenSystem::OnResume(const dd::Events::Resume &event)
 	return true;
 }
 
+bool dd::Systems::KrakenSystem::OnContact(const dd::Events::Contact &event)
+{
+	Components::Kraken* kraken1 = m_World->GetComponent<Components::Kraken>(event.Entity1);
+	Components::Kraken* kraken2 = m_World->GetComponent<Components::Kraken>(event.Entity2);
+	Components::Kraken* kraken;
+
+	if (kraken1 != nullptr && kraken2 != nullptr) {
+		return false;
+	}
+
+	EntityID krakenEntity, otherEntitiy;
+
+	//Which is the ball?
+	if (kraken1 != nullptr) {
+		krakenEntity = event.Entity1;
+		otherEntitiy = event.Entity2;
+		kraken = kraken1;
+	}
+	else if (kraken2 != nullptr) {
+		krakenEntity = event.Entity2;
+		otherEntitiy = event.Entity1;
+		kraken = kraken2;
+	}
+	else {
+		return false;
+	}
+	
+	auto ball = m_World->GetComponent<Components::Ball>(otherEntitiy);
+	if (ball != nullptr) {
+		Events::KrakenHit e;
+		e.Kraken = krakenEntity;
+		e.Hitter = otherEntitiy;
+		e.MaxHealth = kraken->MaxHealth;
+		e.CurrentHealth = kraken->Health;
+		e.NewHealth = kraken->Health - 1;
+		EventBroker->Publish(e);
+	}
+}
+
 bool dd::Systems::KrakenSystem::OnKrakenAppear(const dd::Events::KrakenAppear &event)
 {
 	auto ent = m_World->CloneEntity(m_KrakenTemplate);
@@ -144,6 +215,103 @@ bool dd::Systems::KrakenSystem::OnKrakenAttack(const dd::Events::KrakenAttack &e
 	return true;
 }
 
+bool dd::Systems::KrakenSystem::OnKrakenHit(const dd::Events::KrakenHit &event)
+{
+	auto kraken = m_World->GetComponent<Components::Kraken>(event.Kraken);
+	kraken->Health--;
+	//std::cout << kraken->Health << std::endl;
+	//kraken->Health = -1;
+	if (kraken->Health < 0) {
+		Events::KrakenDefeated e;
+		e.Kraken = event.Kraken;
+		e.Hitter = event.Hitter;
+		EventBroker->Publish(e);
+	}
+	return false;
+}
+
+bool dd::Systems::KrakenSystem::OnKrakenDefeated(const dd::Events::KrakenDefeated &event)
+{
+	m_KrakenBattle = false;
+
+	auto kraken = m_World->GetComponent<Components::Kraken>(event.Kraken);
+	auto physicsComponent = m_World->GetComponent<Components::Physics>(event.Kraken);
+	/*physicsComponent->CollisionType = CollisionType::Type::Dynamic;
+	physicsComponent->GravityScale = 1.f;*/
+	physicsComponent->Mask = static_cast<CollisionLayer::Type>(CollisionLayer::Water | CollisionLayer::Wall);
+	/*physicsComponent->Calculate = false;*/
+
+	auto transformComponentBrick = m_World->GetComponent<Components::Transform>(event.Kraken);
+	auto transformComponentHitter = m_World->GetComponent<Components::Transform>(event.Hitter);
+
+
+	auto brickModel = m_World->GetComponent<Components::Model>(event.Kraken);
+
+	auto cTransform = m_World->GetComponent<Components::Transform>(event.Kraken);
+	/*cTransform->Position = cTransform->Position + transformComponentBrick->Position;
+	glm::vec2 ballToBrick = 4.f * glm::normalize(glm::vec2(cTransform->Position.x - transformComponentHitter->Position.x, cTransform->Position.y - transformComponentHitter->Position.y));
+	cTransform->Velocity = glm::vec3(ballToBrick.x, ballToBrick.y, 0.f);
+
+	std::uniform_real_distribution<float> dist(-1.5f, 1.5f);
+	int impulseStrength = dist(m_RandomGenerator);
+
+	Events::SetImpulse i;
+	i.Entity = event.Kraken;
+	i.Impulse = glm::vec2(impulseStrength, 0.f);
+	i.Point = glm::vec2(cTransform->Position.x, cTransform->Position.y + 0.5f);
+	EventBroker->Publish(i);*/
+
+	auto cModel = m_World->GetComponent<Components::Model>(event.Kraken);
+	cModel->Color = brickModel->Color;
+	cModel->Color *= 0.5f;
+
+	/*m_World->RemoveComponent<Components::Template>(event.Kraken);
+	m_World->SetEntityParent(event.Kraken, 0);
+	m_World->CommitEntity(event.Kraken);*/
+
+	//Particle trail
+	Events::CreateParticleSequence trail;
+	trail.parent = event.Kraken;
+	trail.AlphaValues.push_back(1.f);
+	trail.AlphaValues.push_back(0.f);
+	trail.ScaleValues.push_back(glm::vec3(0.08f));
+	trail.ScaleValues.push_back(glm::vec3(0.f));
+	trail.RadiusDistribution = 1;
+	trail.EmitterLifeTime = 2.f;
+	trail.ParticleLifeTime = 1.f;
+	trail.ParticlesPerTick = 1;
+	trail.SpawnRate = 0.1f;
+	trail.Speed = 10.f;
+	trail.EmittingAngle = glm::half_pi<float>();
+	trail.SpriteFile = "Textures/Particles/FadeBall.png";
+	trail.Color = brickModel->Color;
+	//p.Spread = ...
+	EventBroker->Publish(trail);
+
+	//ParticlePoof
+	Events::CreateParticleSequence poof;
+	poof.EmitterLifeTime = 4;
+	poof.EmittingAngle = glm::half_pi<float>();
+	poof.Spread = 0.5f;
+	poof.NumberOfTicks = 1;
+	poof.ParticleLifeTime = 1.5f;
+	poof.ParticlesPerTick = 1;
+	poof.Position = cTransform->Position;
+	poof.ScaleValues.clear();
+	poof.ScaleValues.push_back(glm::vec3(0.5f));
+	poof.ScaleValues.push_back(glm::vec3(2.f, 2.f, 0.2f));
+	poof.SpriteFile = "Textures/Particles/Cloud_Particle.png";
+	poof.Color = brickModel->Color;
+	poof.AlphaValues.clear();
+	poof.AlphaValues.push_back(1.f);
+	poof.AlphaValues.push_back(0.f);
+	poof.Speed = 10;
+	EventBroker->Publish(poof);
+
+
+	return true;
+}
+
 bool dd::Systems::KrakenSystem::OnBrickGenerating(const dd::Events::BrickGenerating &event)
 {
 	return true;

src/game/Game/LevelSystem.cpp

@@ -18,10 +18,12 @@ void dd::Systems::LevelSystem::Initialize()
 	EVENT_SUBSCRIBE_MEMBER(m_EMultiBallLost, &LevelSystem::OnMultiBallLost);
 	EVENT_SUBSCRIBE_MEMBER(m_EPowerUpTaken, &LevelSystem::OnPowerUpTaken);
 	EVENT_SUBSCRIBE_MEMBER(m_EStageCleared, &LevelSystem::OnStageCleared);
+	EVENT_SUBSCRIBE_MEMBER(m_EArrivedAtNewStage, &LevelSystem::OnArrivedAtNewStage);
 	EVENT_SUBSCRIBE_MEMBER(m_EPause, &LevelSystem::OnPause);
 	EVENT_SUBSCRIBE_MEMBER(m_EResume, &LevelSystem::OnResume);
 	EVENT_SUBSCRIBE_MEMBER(m_EHitPad, &LevelSystem::OnHitPad);
 	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);
 
@@ -60,7 +62,7 @@ void dd::Systems::LevelSystem::Initialize()
 		travels->CurrentlyTraveling = false;
 		auto model = m_World->AddComponent<Components::Model>(t_halfPipe);
 		model->ModelFile = "Models/Test/halfpipe/Halfpipe.obj";
-		model->Color = glm::vec4(0.8f, 0.8f, 0.8f, 0.3f);
+		model->Color = glm::vec4(0.8f, 0.8f, 0.8f, 1.f);
 		m_World->CommitEntity(t_halfPipe);
 
 		auto t_halfPipe2 = m_World->CloneEntity(t_halfPipe);
@@ -84,16 +86,7 @@ void dd::Systems::LevelSystem::Initialize()
 	}*/
 
 	//			auto particleEmitter= m_World->AddComponent<Components::Emitter>(Pe);
-	//Water test
-	{
-		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->Scale = glm::vec3(7.0f, 1.5f, 1.f);
-		auto water = m_World->AddComponent<Components::WaterVolume>(t_waterBody);
-		auto body = m_World->AddComponent<Components::RectangleShape>(t_waterBody);
-		m_World->CommitEntity(t_waterBody);
-	}
+	
 
 	//ParticleTest
 
@@ -114,7 +107,7 @@ void dd::Systems::LevelSystem::Initialize()
 	particleEmitter->Spread = glm::pi<float>()*2;
 	particleEmitter->EmittingAngle = glm::pi<float>();
 	particleEmitter->LifeTime = 50;
-
+	
 	{
 	auto Pt = m_World->CreateEntity(Pe);
 	auto PtTransform = m_World->AddComponent<Components::Transform>(Pt);
@@ -134,13 +127,13 @@ void dd::Systems::LevelSystem::Initialize()
 	//TODO: Why does the ball not collide with these bricks?
 	//BottomBox
 	{
-		auto BottomWall = m_World->CreateEntity();
+		EntityID BottomWall = m_World->CreateEntity();
 		auto transform = m_World->AddComponent<Components::Transform>(BottomWall);
 		auto wall = m_World->AddComponent<Components::Wall>(BottomWall);
 		transform->Position = glm::vec3(0.f, -6.f, -10.f);
 		transform->Scale = glm::vec3(20.f, 0.5f, 1.f);
-		//std::shared_ptr<Components::Sprite> sprite = m_World->AddComponent<Components::Sprite>(BottomWall);
-		//sprite->SpriteFile = "Textures/Core/ErrorTexture.png";
+		std::shared_ptr<Components::Sprite> sprite = m_World->AddComponent<Components::Sprite>(BottomWall);
+		sprite->SpriteFile = "Textures/Core/ErrorTexture.png";
 		std::shared_ptr<Components::RectangleShape> rectangleShape = m_World->AddComponent<Components::RectangleShape>(BottomWall);
 		rectangleShape->Dimensions = glm::vec2(20.f, 0.5f);
 		std::shared_ptr<Components::Physics> physics = m_World->AddComponent<Components::Physics>(BottomWall);
@@ -152,6 +145,8 @@ void dd::Systems::LevelSystem::Initialize()
 			physics->Mask = static_cast<CollisionLayer::Type>(CollisionLayer::LifeBuoy);
 		}
 		m_World->CommitEntity(BottomWall);
+
+		m_World->SetProperty(BottomWall, "Name", "BottomWall");
 	}
 
 	{
@@ -253,6 +248,9 @@ void dd::Systems::LevelSystem::Update(double dt)
     if (!m_Initialized) {
         GetNextLevel();
         CreateLevel(0);
+		for (int i = 0; i < m_KrakenBricks.size(); i++) {
+			m_KrakenBricks[i] = false;
+		}
         m_Initialized = true;
     }
 }
@@ -301,6 +299,7 @@ void dd::Systems::LevelSystem::UpdateEntity(double dt, EntityID entity, EntityID
 			} else if (brick->Type == InkBlasterBrick) {
 				Events::InkBlaster e;
 				e.Shots = 5;
+				e.Speed = 7;
 				EventBroker->Publish(e);
 			} else if(brick->Type == KrakenAttackBrick) {
 				Events::KrakenAttack e;
@@ -321,6 +320,7 @@ void dd::Systems::LevelSystem::UpdateEntity(double dt, EntityID entity, EntityID
             Events::StageCleared ec;
             ec.ClearedStage = m_CurrentLevel;
             ec.StageCluster = m_CurrentCluster;
+			ec.StagesInCluster = m_StagesInCluster;
             EventBroker->Publish(ec);
         } else {
             if (ball != nullptr && MultiBalls() > 0) {
@@ -443,7 +443,7 @@ EntityID dd::Systems::LevelSystem::CreateBrick(int row, int line, glm::vec2 spac
 	} else if (typeInt == KrakenAttackBrick) {
 		cBrick->Type = KrakenAttackBrick;
 		auto type = m_World->AddComponent<Components::KrakenAttackBrick>(brick);
-		model->Color = glm::vec4(0.f, 0.5f, 1.0f, .0f);
+		model->Color = glm::vec4(0.f, 0.5f, 1.0f, 1.0f);
 	} else if (typeInt == Kraken) {
 		Events::KrakenAppear e;
 		e.Position = transform->Position;
@@ -459,26 +459,41 @@ EntityID dd::Systems::LevelSystem::CreateBrick(int row, int line, glm::vec2 spac
 
 bool dd::Systems::LevelSystem::OnBrickGenerating(const dd::Events::BrickGenerating &event)
 {
-	GetBrickSet(event.Set);
-	LOG_DEBUG("This is happening.");
+	m_BrickGenerating = true;
+	m_BrickGeneratingEvent = event;
+	return true;
+}
 
-	int rows = 2;
+bool dd::Systems::LevelSystem::BrickGenerating(const dd::Events::BrickGenerating &event)
+{
+	GetBrickSet(event.Set);
+
+	int rows = 6;
 	int lines = 7;
 	int getter = 0;
 	for (int i = 0; i < rows; i++) {
 		for (int j = 0; j < lines; j++) {
-			auto ent = CreateBrick(i, j, SpaceBetweenBricks(), SpaceToEdge(), -4, 1, m_BrickSet[getter], m_ColorSet[getter]);
-			if (ent != NULL) {
-				auto transform = m_World->GetComponent<Components::Transform>(ent);
-				Events::Move e;
-				e.GoalPosition = transform->Position;
-				transform->Position = event.Origin;
-				e.Entity = ent;
-				e.Speed = 6;
-				e.Queue = false;
-				EventBroker->Publish(e);
-				m_LooseBricks++;
-				SetNumberOfBricks(NumberOfBricks() + 1);
+			if (!m_KrakenBricks[getter]) {
+				auto ent = CreateBrick(i, j, SpaceBetweenBricks(), SpaceToEdge(), -3.2, 1, m_BrickSet[getter], m_ColorSet[getter]);
+				if (ent != NULL) {
+					auto brick = m_World->GetComponent<Components::Brick>(ent);
+					brick->Number = getter;
+					m_KrakenBricks[getter] = true;
+					auto transform = m_World->GetComponent<Components::Transform>(ent);
+					Events::Move e;
+					e.GoalPosition = transform->Position;
+					if (j < 4) {
+						transform->Position = event.Origin1;
+					} else {
+						transform->Position = event.Origin2;
+					}
+					e.Entity = ent;
+					e.Speed = 6;
+					e.Queue = false;
+					EventBroker->Publish(e);
+					m_LooseBricks++;
+					SetNumberOfBricks(NumberOfBricks() + 1);
+				}
 			}
 			getter++;
 		}
@@ -486,10 +501,10 @@ bool dd::Systems::LevelSystem::OnBrickGenerating(const dd::Events::BrickGenerati
 	return true;
 }
 
-void dd::Systems::LevelSystem::GetBrickSet(int set)
+void dd::Systems::LevelSystem::GetBrickSet(int set) // These are sets the Kraken gets!
 {
-	std::array<int, 14> level;
-	std::array<glm::vec4, 14> color;
+	std::array<int, 42> level;
+	std::array<glm::vec4, 42> color;
 	// Level array indicates type of brick.
 	// 0 is empty space.
 	// 1 is standard brick.
@@ -509,62 +524,110 @@ void dd::Systems::LevelSystem::GetBrickSet(int set)
 	// m is magenta.
 	// d is dark.
 	// Feel free to make your own.
-	glm::vec4 w = glm::vec4(1, 1, 1, 0);
-	glm::vec4 r = glm::vec4(1, 0, 0, 0);
-	glm::vec4 g = glm::vec4(0, 1, 0, 0);
-	glm::vec4 b = glm::vec4(0, 0, 1, 0);
-	glm::vec4 y = glm::vec4(1, 1, 0, 0);
-	glm::vec4 c = glm::vec4(0, 1, 1, 0);
-	glm::vec4 m = glm::vec4(1, 0, 1, 0);
-	glm::vec4 d = glm::vec4(0, 0, 0, 0);
+	glm::vec4 w = glm::vec4(1, 1, 1, 1);
+	glm::vec4 r = glm::vec4(1, 0, 0, 1);
+	glm::vec4 g = glm::vec4(0, 1, 0, 1);
+	glm::vec4 b = glm::vec4(0, 0, 1, 1);
+	glm::vec4 y = glm::vec4(1, 1, 0, 1);
+	glm::vec4 c = glm::vec4(0, 1, 1, 1);
+	glm::vec4 m = glm::vec4(1, 0, 1, 1);
+	glm::vec4 d = glm::vec4(0, 0, 0, 1);
 
 	if (set == 1) {
 		level =
-		{1, 1, 1, 1, 1, 1, 1,
-		 1, 1, 1, 1, 1, 1, 1 };
+		{1, 0, 0, 0, 0, 0, 1,
+		 1, 0, 0, 0, 0, 0, 1,
+		 1, 0, 0, 0, 0, 0, 1,
+		 1, 1, 1, 1, 1, 1, 2,
+		 1, 1, 1, 1, 1, 1, 1,
+		 0, 0, 0, 0, 0, 0, 0};
 		color =
 		{r, r, r, r, r, r, r,
-		 r, r, r, r, r, r, r };
+		 r, r, r, r, r, r, r,
+		 r, r, r, r, r, r, r,
+		 r, r, r, r, r, r, r,
+		 r, r, r, r, r, r, r, 
+		 r, r, r, r, r, r, r};
 	}
 	else if (set == 2) {
 		level =
-		{2, 2, 2, 2, 2, 2, 2,
-		 2, 2, 2, 2, 2, 2, 2 };
+		{0, 0, 0, 0, 0, 0, 0,
+		 0, 0, 0, 0, 0, 0, 0,
+		 3, 0, 1, 0, 1, 0, 1,
+		 0, 1, 0, 1, 0, 1, 0,
+		 1, 0, 1, 0, 1, 0, 1,
+		 0, 0, 0, 0, 0, 0, 0};
 		color =
-		{w, w, w, w, w, w, w,
-		 w, w, w, w, w, w, w };
+		{y, y, y, y, y, y, y,
+		 y, y, y, y, y, y, y,
+		 y, y, y, y, y, y, y,
+		 y, y, y, y, y, y, y,
+		 y, y, y, y, y, y, y, 
+		 y, y, y, y, y, y, y};
 	}
 	else if (set == 3) {
 		level =
 		{0, 0, 0, 0, 0, 0, 0,
-		 0, 0, 0, 0, 0, 0, 0 };
+		 0, 0, 0, 0, 0, 0, 0,
+		 1, 0, 1, 0, 1, 0, 1,
+		 0, 1, 1, 1, 1, 1, 0,
+		 0, 0, 4, 1, 1, 0, 0,
+		 0, 0, 0, 1, 0, 0, 0};
 		color =
-		{w, w, w, w, w, w, w,
-		 w, w, w, w, w, w, w };
+		{b, b, b, b, b, b, b,
+		 b, b, b, b, b, b, b,
+		 b, b, b, b, b, b, b,
+		 b, b, b, b, b, b, b,
+		 b, b, b, b, b, b, b, 
+		 b, b, b, b, b, b, b};
 	}
 	else if (set == 4) {
 		level =
 		{0, 0, 0, 0, 0, 0, 0,
-		 0, 0, 0, 0, 0, 0, 0 };
+		 1, 1, 1, 1, 1, 3, 1,
+		 0, 0, 0, 0, 0, 0, 0,
+		 1, 1, 1, 1, 1, 1, 1,
+		 0, 0, 0, 0, 0, 0, 0,
+		 0, 0, 0, 0, 0, 0, 0};
 		color =
-		{w, w, w, w, w, w, w,
-		 w, w, w, w, w, w, w };
+		{m, m, m, m, m, m, m,
+		 m, m, m, m, m, m, m,
+		 m, m, m, m, m, m, m,
+		 m, m, m, m, m, m, m,
+		 m, m, m, m, m, m, m, 
+		 m, m, m, m, m, m, m};
 	}
 	else if (set == 5) {
 		level =
 		{0, 0, 0, 0, 0, 0, 0,
-		 0, 0, 0, 0, 0, 0, 0 };
+		 0, 1, 1, 0, 1, 1, 0,
+		 0, 1, 2, 0, 1, 1, 0,
+		 0, 1, 1, 0, 1, 1, 0,
+		 0, 1, 1, 0, 1, 1, 0,
+		 0, 0, 0, 0, 0, 0, 0};
 		color =
-		{w, w, w, w, w, w, w,
-		 w, w, w, w, w, w, w };
+		{g, g, g, g, g, g, g,
+		 g, g, g, g, g, g, g,
+		 g, g, g, g, g, g, g,
+		 g, g, g, g, g, g, g,
+		 g, g, g, g, g, g, g, 
+		 g, g, g, g, g, g, g};
 	}
 	else if (set == 6) {
 		level =
-		{0, 0, 0, 1, 0, 0, 0,
-		 0, 0, 0, 0, 0, 0, 0 };
+		{0, 0, 0, 0, 0, 0, 0,
+		 0, 0, 0, 0, 0, 0, 0,
+		 0, 0, 0, 0, 0, 0, 0,
+		 1, 1, 1, 1, 1, 1, 1,
+		 1, 1, 1, 1, 1, 1, 1,
+		 0, 0, 0, 0, 0, 0, 0};
 		color =
-		{w, w, w, w, w, w, w,
-		 w, w, w, w, w, w, w };
+		{r, r, r, r, r, r, r, 
+		 r, r, r, r, r, r, r,
+		 r, r, r, r, r, r, r,
+		 r, r, r, r, r, r, r,
+		 r, r, r, r, r, r, r, 
+		 r, r, r, r, r, r, r};
 	}
 
 	std::copy(std::begin(level), std::end(level), std::begin(m_BrickSet));
@@ -579,6 +642,11 @@ void dd::Systems::LevelSystem::OnEntityRemoved(EntityID entity)
 
 bool dd::Systems::LevelSystem::OnContact(const dd::Events::Contact &event)
 {
+	auto templateCheck = m_World->GetComponent<Components::Template>(event.Entity1);
+	if (templateCheck != nullptr){ return false; }
+	templateCheck = m_World->GetComponent<Components::Template>(event.Entity2);
+	if (templateCheck != nullptr){ return false; }
+
     EntityID entityBrick;
     EntityID entityBall;
 	EntityID entityShot = 0;
@@ -656,10 +724,12 @@ void dd::Systems::LevelSystem::BrickHit(EntityID entityHitter, EntityID entityBr
 
 	auto transformComponentBrick = m_World->GetComponent<Components::Transform>(entityBrick);
 	auto transformComponentHitter = m_World->GetComponent<Components::Transform>(entityHitter);
-		
-
 	auto brickModel = m_World->GetComponent<Components::Model>(entityBrick);
 
+	if (brick->Number < 50) {
+		m_KrakenBricks[brick->Number] = false;
+	}
+
 	// Check if the brick is any kind of special.
 	auto multi = m_World->GetComponent<Components::MultiBallBrick>(entityBrick);
 	if (multi != nullptr) {
@@ -688,6 +758,7 @@ void dd::Systems::LevelSystem::BrickHit(EntityID entityHitter, EntityID entityBr
 					Events::InkBlaster e;
 					e.Transform = transformComponentBrick;
 					e.Shots = 5;
+					e.Speed = 7;
 					EventBroker->Publish(e);
 				}
 				else {
@@ -710,8 +781,6 @@ void dd::Systems::LevelSystem::BrickHit(EntityID entityHitter, EntityID entityBr
 	auto brickChildren = m_World->GetEntityChildren(entityBrick);
 	for (auto b : brickChildren)
 	{
-
-
 		auto cTransform = m_World->GetComponent<Components::Transform>(b);
 		cTransform->Position = cTransform->Position + transformComponentBrick->Position;
 		glm::vec2 ballToBrick = 4.f * glm::normalize(glm::vec2(cTransform->Position.x - transformComponentHitter->Position.x, cTransform->Position.y - transformComponentHitter->Position.y));
@@ -837,6 +906,16 @@ bool dd::Systems::LevelSystem::OnPowerUpTaken(const dd::Events::PowerUpTaken &ev
     return true;
 }
 
+bool dd::Systems::LevelSystem::OnKrakenDefeated(const dd::Events::KrakenDefeated &event)
+{
+	SetNumberOfBricks(NumberOfBricks() - 1);
+	m_LooseBricks--;
+
+	std::cout << m_LooseBricks << std::endl;
+
+	return true;
+}
+
 bool dd::Systems::LevelSystem::OnStageCleared(const dd::Events::StageCleared &event)
 {
     if (!m_Cleared) {
@@ -848,12 +927,13 @@ bool dd::Systems::LevelSystem::OnStageCleared(const dd::Events::StageCleared &ev
         es.Score = 500;
         EventBroker->Publish(es);
         m_CurrentLevel++;
-        if (m_CurrentLevel < 6) {
+        if (m_CurrentLevel <= event.StagesInCluster) {
             GetNextLevel();
             CreateLevel(12); //NextLevelDistance
 		} else {
 			// Win
 			Events::ClusterClear e;
+			e.ClusterCleared = m_CurrentCluster;
 			EventBroker->Publish(e);
 
 			Events::Pause p;
@@ -864,6 +944,12 @@ bool dd::Systems::LevelSystem::OnStageCleared(const dd::Events::StageCleared &ev
     return true;
 }
 
+bool dd::Systems::LevelSystem::OnArrivedAtNewStage(const dd::Events::ArrivedAtNewStage &event)
+{
+	m_Cleared = false;
+	return true;
+}
+
 void dd::Systems::LevelSystem::GetNextLevel()
 {
     std::array<int, 42> level;
@@ -889,14 +975,14 @@ void dd::Systems::LevelSystem::GetNextLevel()
 	// m is magenta.
 	// d is dark.
 	// Feel free to make your own.
-	glm::vec4 w = glm::vec4(1, 1, 1, 0);
-	glm::vec4 r = glm::vec4(1, 0, 0, 0);
-	glm::vec4 g = glm::vec4(0, 1, 0, 0);
-	glm::vec4 b = glm::vec4(0, 0, 1, 0);
-	glm::vec4 y = glm::vec4(1, 1, 0, 0);
-	glm::vec4 c = glm::vec4(0, 1, 1, 0);
-	glm::vec4 m = glm::vec4(1, 0, 1, 0);
-	glm::vec4 d = glm::vec4(0, 0, 0, 0);
+	glm::vec4 w = glm::vec4(1, 1, 1, 1);
+	glm::vec4 r = glm::vec4(1, 0, 0, 1);
+	glm::vec4 g = glm::vec4(0, 1, 0, 1);
+	glm::vec4 b = glm::vec4(0, 0, 1, 1);
+	glm::vec4 y = glm::vec4(1, 1, 0, 1);
+	glm::vec4 c = glm::vec4(0, 1, 1, 1);
+	glm::vec4 m = glm::vec4(1, 0, 1, 1);
+	glm::vec4 d = glm::vec4(0, 0, 0, 1);
 
 	//glm::vec4 p4 = glm::vec4(asd.f / 255.f, asd.f / 255.f, sad.f / 255.f, 1.f);
 	glm::vec4 br = glm::vec4(143.f / 255.f, 98.f / 255.f, 0.f / 255.f, 1.f);
@@ -1108,6 +1194,10 @@ void dd::Systems::LevelSystem::GetNextLevel()
 bool dd::Systems::LevelSystem::OnHitPad(const dd::Events::HitPad &event)
 {
     m_Cleared = false;
+	if (m_BrickGenerating) {
+		m_BrickGenerating = false;
+		BrickGenerating(m_BrickGeneratingEvent);
+	}
     return true;
 }
 

src/game/Game/LifebuoySystem.cpp

@@ -143,7 +143,7 @@ bool dd::Systems::LifebuoySystem::OnLifebuoyHit(const dd::Events::LifebuoyHit &e
 	e.EmittingAngle = glm::half_pi<float>();
 	e.Spread = 0.5f;
 	e.NumberOfTicks = 1;
-	e.ParticleLifeTime = 1.f;
+	e.ParticleLifeTime = 2.f;
 	e.ParticlesPerTick = 1;
 	e.Position = transformComponent->Position;
 	e.ScaleValues.clear();

src/game/Game/PadSystem.cpp

@@ -30,6 +30,7 @@ void dd::Systems::PadSystem::Initialize()
 	EVENT_SUBSCRIBE_MEMBER(m_EResetBall, &PadSystem::OnResetBall);
 	EVENT_SUBSCRIBE_MEMBER(m_EResetAll, &PadSystem::OnResetAll);
 	EVENT_SUBSCRIBE_MEMBER(m_ERaiseWater, &PadSystem::OnRaiseWater);
+	EVENT_SUBSCRIBE_MEMBER(m_ERaiseWaterWall, &PadSystem::OnRaiseWaterWall);
     EVENT_SUBSCRIBE_MEMBER(m_EPause, &PadSystem::OnPause);
 	EVENT_SUBSCRIBE_MEMBER(m_EResume, &PadSystem::OnResume);
 	EVENT_SUBSCRIBE_MEMBER(m_EKrakenAttack, &PadSystem::OnKrakenAttack);
@@ -57,17 +58,6 @@ void dd::Systems::PadSystem::Initialize()
         m_World->CommitEntity(ent);
 
         SetEdge(3.2 - (ctransform->Scale.x / 2));
-
-
-		{
-			auto entArm = m_World->CreateEntity(ent);
-			auto ctransform = m_World->AddComponent<Components::Transform>(entArm);
-			ctransform->Position = glm::vec3(1.f, -3.0f, 0.f);
-			auto cModel = m_World->AddComponent<Components::Model>(entArm);
-			cModel->ModelFile = "Models/Kraken/Arm.dae";
-			auto animationComponent = m_World->AddComponent<Components::Animation>(entArm);
-			animationComponent->Speed = 1.0f;
-		}
     }
 
 
@@ -97,6 +87,17 @@ void dd::Systems::PadSystem::Initialize()
 
 		m_StickTransform = transform;
 		m_StickyAim = sticky;
+
+		/*{
+			auto entChild = m_World->CreateEntity(ent);
+			std::shared_ptr<Components::Transform> transform = m_World->AddComponent<Components::Transform>(entChild);
+			transform->Position = glm::vec3(0.f, 12.5f, 0.f);
+
+			transform->Scale = glm::vec3(0.1f, 25.f, 0.1f);
+			std::shared_ptr<Components::Sprite> sprite = m_World->AddComponent<Components::Sprite>(entChild);
+			sprite->SpriteFile = "Models/Brick/White.png";
+			sprite->Color = glm::vec4(0.f, 0.5f, 0.f, 0.5f);
+		}*/
 	}
 
 	m_ResetBall = true;
@@ -162,7 +163,6 @@ void dd::Systems::PadSystem::Update(double dt)
 		Events::KrakenAttack e;
 		e.ChargeUpdate = m_KrakenCharge;
 		EventBroker->Publish(e);
-		//std::cout << "Charge: " << m_KrakenCharge << std::endl;
 		return;
 	}
 
@@ -242,8 +242,14 @@ bool dd::Systems::PadSystem::OnKeyDown(const dd::Events::KeyDown &event) {
 	} else if (val == GLFW_KEY_W) {
 		Events::RaiseWater e;
 		e.Amount = 0.2;
+		e.Speed = 0.2;
 		EventBroker->Publish(e);
-	}  else if (val == GLFW_KEY_A) {
+	} else if (val == GLFW_KEY_Q) {
+		Events::RaiseWaterWall e;
+		e.Amount = 0.2;
+		e.Speed = 0.2;
+		EventBroker->Publish(e);
+	} else if (val == GLFW_KEY_A) {
 		Events::ResetAll e;
 		EventBroker->Publish(e);
 	} else if (val == GLFW_KEY_M) {
@@ -276,7 +282,8 @@ bool dd::Systems::PadSystem::OnKeyDown(const dd::Events::KeyDown &event) {
 		EventBroker->Publish(e);
 	} else if (val == GLFW_KEY_G) {
 		Events::BrickGenerating e;
-		e.Origin = glm::vec3(-5, 7, -10);
+		e.Origin1 = glm::vec3(-5, 7, -10);
+		e.Origin2 = glm::vec3(5, 7, -10);
 		e.Set = 1;
 		EventBroker->Publish(e);
 	} else if (val == GLFW_KEY_L) {
@@ -290,6 +297,7 @@ bool dd::Systems::PadSystem::OnKeyDown(const dd::Events::KeyDown &event) {
 	} else if (val == GLFW_KEY_I) {
 		Events::InkBlaster e;
 		e.Shots = 5;
+		e.Speed = 7;
 		EventBroker->Publish(e);
 	} else if (val == GLFW_KEY_K) {
 		Events::KrakenAttack e;
@@ -300,7 +308,7 @@ bool dd::Systems::PadSystem::OnKeyDown(const dd::Events::KeyDown &event) {
 	} else if (val == GLFW_KEY_Q) {
 		Events::Move e;
 		e.Entity = Entity();
-		e.GoalPosition = glm::vec3(0, 0, -10);
+		e.GoalPosition = glm::vec3(0, 0, -10); 
 		e.Speed = 5;
 		e.Queue = false;
 		EventBroker->Publish(e);
@@ -439,21 +447,29 @@ bool dd::Systems::PadSystem::OnResetAll(const dd::Events::ResetAll &event)
 }
 
 bool dd::Systems::PadSystem::OnRaiseWater(const dd::Events::RaiseWater &event)
+{
+	RaisePad(event.Amount, event.Speed);
+
+	return true;
+}
+
+bool dd::Systems::PadSystem::OnRaiseWaterWall(const dd::Events::RaiseWaterWall &event)
+{
+	RaisePad(event.Amount, event.Speed);
+
+	return true;
+}
+
+bool dd::Systems::PadSystem::RaisePad(float amount, float speed)
 {
 	auto transform = Transform();
-	glm::vec3 raise = glm::vec3(0, event.Amount, 0);
-	transform->Position += raise;
-
-	{
-		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->Scale = glm::vec3(7.0f, event.Amount * 1.6f, 1.f);
-		auto water = m_World->AddComponent<Components::WaterVolume>(t_waterBody);
-		auto body = m_World->AddComponent<Components::RectangleShape>(t_waterBody);
-		m_World->CommitEntity(t_waterBody);
-	}
-
+	glm::vec3 raise = glm::vec3(0, amount, 0);
+	Events::Move e;
+	e.Entity = m_Entity;
+	e.GoalPosition = transform->Position + raise;
+	e.Speed = speed;
+	e.Queue = true;
+	EventBroker->Publish(e);
 	return true;
 }
 
@@ -470,6 +486,17 @@ bool dd::Systems::PadSystem::OnKrakenAttack(const dd::Events::KrakenAttack &even
 		transform->Velocity = glm::vec3(0, 0, 0);
 		acceleration = glm::vec3(0, 0, 0);
 
+		if (!m_KrakenArm){
+			m_KrakenArm = m_World->CreateEntity(Entity());
+			auto transform = m_World->AddComponent<Components::Transform>(m_KrakenArm);
+			transform->Position = glm::vec3(1.f, -3.0f, 0.f);
+			auto model = m_World->AddComponent<Components::Model>(m_KrakenArm);
+			model->ModelFile = "Models/kraken/Arm.dae";
+			auto animation = m_World->AddComponent<Components::Animation>(m_KrakenArm);
+			animation->Speed = 1.0f;
+			m_World->CommitEntity(m_KrakenArm);
+		}
+
 		SetTransform(transform);
 		SetAcceleration(acceleration);
 	} else if (m_KrakenCharge >= 1) {
@@ -477,6 +504,10 @@ bool dd::Systems::PadSystem::OnKrakenAttack(const dd::Events::KrakenAttack &even
 		m_KrakenCharge = 0;
 		m_KrakenStrength = 0;
 		m_PlayerStrength = 0;
+
+		m_World->RemoveEntity(m_KrakenArm);
+		m_KrakenArm = NULL;
+		
 	}
 	return true;
 }

src/game/Game/ProjectileSystem.cpp

@@ -100,6 +100,7 @@ bool dd::Systems::ProjectileSystem::OnInkBlaster(const dd::Events::InkBlaster &e
 {
 	m_InkBlaster = true;
 	m_Shots = event.Shots;
+	m_InkBlasterSpeed = event.Speed;
 	return true;
 }
 
@@ -117,9 +118,11 @@ bool dd::Systems::ProjectileSystem::OnActionButton(const dd::Events::ActionButto
 	if (m_InkBlaster && m_SquidLoaded) {
 		auto ent = m_World->CloneEntity(m_InkBlastTemplate);
 		m_World->RemoveComponent<Components::Template>(ent);
+		auto projectile = m_World->GetComponent<Components::Projectile>(ent);
+		projectile->Speed = m_InkBlasterSpeed;
 		auto transform = m_World->GetComponent<Components::Transform>(ent);
 		transform->Position = event.Position;
-		transform->Velocity = glm::vec3(0, 7, 0);
+		transform->Velocity = glm::vec3(0, projectile->Speed, 0);
 		m_Shots--;
 		if (m_Shots <= 0) {
 			auto ball = m_World->GetComponent<Components::Ball>(m_AttachedSquid);

src/game/Game/ProjectileSystem.cpp.orig

@@ -0,0 +1,151 @@
+//
+// Created by Adniklastrator on 2015-10-08.
+//
+
+
+#include "PrecompiledHeader.h"
+#include "Game/ProjectileSystem.h"
+
+
+void dd::Systems::ProjectileSystem::Initialize()
+{
+	EVENT_SUBSCRIBE_MEMBER(m_EContact, &ProjectileSystem::OnContact);
+	EVENT_SUBSCRIBE_MEMBER(m_EPause, &ProjectileSystem::OnPause);
+	EVENT_SUBSCRIBE_MEMBER(m_EResume, &ProjectileSystem::OnResume);
+	EVENT_SUBSCRIBE_MEMBER(m_EInkBlaster, &ProjectileSystem::OnInkBlaster);
+	EVENT_SUBSCRIBE_MEMBER(m_EHitPad, &ProjectileSystem::OnHitPad);
+	EVENT_SUBSCRIBE_MEMBER(m_EActionButton, &ProjectileSystem::OnActionButton);
+
+	//Ink Blast
+	{
+		auto ent = m_World->CreateEntity();
+		m_World->SetProperty(ent, "Name", "Projectile");
+		std::shared_ptr<Components::Transform> ctransform = m_World->AddComponent<Components::Transform>(ent);
+		
+		auto circleShape = m_World->AddComponent<Components::CircleShape>(ent);
+		auto inkBlastTemplate = m_World->AddComponent<Components::Template>(ent);
+		circleShape->Radius = 0.1f;
+		auto physics = m_World->AddComponent<Components::Physics>(ent);
+		physics->CollisionType = CollisionType::Type::Dynamic;
+		physics->Category = CollisionLayer::Type::Projectile;
+		physics->Mask = static_cast<CollisionLayer::Type>(CollisionLayer::Type::Pad | CollisionLayer::Type::Brick | CollisionLayer::Type::Wall);
+		physics->Calculate = true;
+		ctransform->Position = glm::vec3(0.f, 0.f, -10.f);
+		ctransform->Scale = glm::vec3(0.6f, 0.6f, 0.6f);
+// 		auto cModel = m_World->AddComponent<Components::Model>(ent);
+// 		cModel->ModelFile = "Models/Test/Ball/Sid.obj";
+		auto cSprite = m_World->AddComponent<Components::Sprite>(ent);
+		cSprite->SpriteFile = "Textures/Particles/OilShot.png";
+		auto projectile = m_World->AddComponent<Components::Projectile>(ent);
+
+		m_World->CommitEntity(ent);
+
+		m_InkBlastTemplate = ent;
+	}
+
+    return;
+}
+
+void dd::Systems::ProjectileSystem::Update(double dt)
+{
+	if (m_Pause) {
+		return;
+	}
+}
+
+void dd::Systems::ProjectileSystem::UpdateEntity(double dt, EntityID entity, EntityID parent)
+{
+    if (IsPaused()) {
+        return;
+    }
+    auto templateCheck = m_World->GetComponent<Components::Template>(entity);
+    if (templateCheck != nullptr){ return; }
+
+	auto shot = m_World->GetComponent<Components::Projectile>(entity);
+	if (shot != nullptr) {
+		auto transform = m_World->GetComponent<Components::Transform>(entity);
+		if (transform->Position.y > 8) {
+			m_World->RemoveEntity(entity);
+		}
+	}
+}
+
+bool dd::Systems::ProjectileSystem::OnPause(const dd::Events::Pause &event)
+{
+    /*if (event.Type != "ProjectileSystem" && event.Type != "All") {
+        return false;
+    }*/
+    
+    m_Pause = true;
+
+    return true;
+}
+
+bool dd::Systems::ProjectileSystem::OnResume(const dd::Events::Resume &event)
+{
+	/*if (event.Type != "ProjectileSystem" && event.Type != "All") {
+	return false;
+	}*/
+	m_Pause = false;
+	return true;
+}
+
+bool dd::Systems::ProjectileSystem::OnContact(const dd::Events::Contact &event)
+{
+    
+    return true;
+}
+
+bool dd::Systems::ProjectileSystem::OnInkBlaster(const dd::Events::InkBlaster &event)
+{
+	m_InkBlaster = true;
+	m_Shots = event.Shots;
+	m_InkBlasterSpeed = event.Speed;
+	return true;
+}
+
+bool dd::Systems::ProjectileSystem::OnHitPad(const dd::Events::HitPad &event)
+{
+	if (m_InkBlaster) {
+		m_SquidLoaded = true;
+		m_AttachedSquid = event.Ball;
+	}
+	return true;
+}
+
+bool dd::Systems::ProjectileSystem::OnActionButton(const dd::Events::ActionButton &event)
+{
+	if (m_InkBlaster && m_SquidLoaded) {
+		auto ent = m_World->CloneEntity(m_InkBlastTemplate);
+		m_World->RemoveComponent<Components::Template>(ent);
+		auto projectile = m_World->GetComponent<Components::Projectile>(ent);
+		projectile->Speed = m_InkBlasterSpeed;
+		auto transform = m_World->GetComponent<Components::Transform>(ent);
+		transform->Position = event.Position;
+<<<<<<< HEAD
+		transform->Velocity = glm::vec3(0, projectile->Speed, 0);
+=======
+		transform->Velocity = glm::vec3(0, 7, 0);
+>>>>>>> origin/master
+		m_Shots--;
+		if (m_Shots <= 0) {
+			auto ball = m_World->GetComponent<Components::Ball>(m_AttachedSquid);
+			m_InkBlaster = false;
+			m_SquidLoaded = false;
+			ball->InkBlaster = false;
+			ball->Sticky = false;
+			ball->Waiting = true;
+			
+			{
+				Events::InkBlasterOver e;
+				e.Ball = m_AttachedSquid;
+				EventBroker->Publish(e);
+			}
+			{
+				Events::ActionButton e;
+				EventBroker->Publish(e);
+			}
+		}
+	}
+	return true;
+}

src/game/Game/TravellingSystem.cpp

@@ -97,7 +97,7 @@ bool dd::Systems::TravellingSystem::OnResume(const dd::Events::Resume &event)
 
 bool dd::Systems::TravellingSystem::OnStageCleared(const dd::Events::StageCleared &event)
 {
-	if (event.ClearedStage < 5) {
+	if (event.ClearedStage < event.StagesInCluster) {
 		m_Travelling = true;
 	}
 	return true;

src/game/Game/WaterSystem.cpp

@@ -0,0 +1,124 @@
+//
+// Created by Adniklastrator on 2015-10-20.
+//
+
+#include "PrecompiledHeader.h"
+#include "Game/WaterSystem.h"
+
+void dd::Systems::WaterSystem::Initialize()
+{
+	EVENT_SUBSCRIBE_MEMBER(m_EPause, &WaterSystem::OnPause);
+	EVENT_SUBSCRIBE_MEMBER(m_EResume, &WaterSystem::OnResume);
+	EVENT_SUBSCRIBE_MEMBER(m_ERelevantObjectCreated, &WaterSystem::OnRelevantObjectCreated);
+    EVENT_SUBSCRIBE_MEMBER(m_EStageCleared, &WaterSystem::OnStageCleared);
+	EVENT_SUBSCRIBE_MEMBER(m_ERaiseWater, &WaterSystem::OnRaiseWater);
+	EVENT_SUBSCRIBE_MEMBER(m_ERaiseWaterWall, &WaterSystem::OnRaiseWaterWall);
+
+	//Water test
+	{
+		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->Scale = glm::vec3(7.0f, 1.5f, 1.f);
+		auto water = m_World->AddComponent<Components::WaterVolume>(t_waterBody);
+		auto body = m_World->AddComponent<Components::RectangleShape>(t_waterBody);
+		m_World->CommitEntity(t_waterBody);
+	}
+}
+
+void dd::Systems::WaterSystem::Update(double dt)
+{
+	if (m_Pause) {
+		return;
+	}
+	
+}
+
+void dd::Systems::WaterSystem::UpdateEntity(double dt, EntityID entity, EntityID parent)
+{
+	if (m_Pause) {
+		return;
+	}
+
+	auto templateCheck = m_World->GetComponent<Components::Template>(entity);
+	if (templateCheck != nullptr){ 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") {
+				m_BottomWall = entity;
+				break;
+			}
+		}
+	}
+}
+
+bool dd::Systems::WaterSystem::OnPause(const dd::Events::Pause &event)
+{
+	/*if (event.Type != "WaterSystem" && event.Type != "All") {
+		return false;
+	}*/
+	m_Pause = true;
+    return true;
+}
+bool dd::Systems::WaterSystem::OnResume(const dd::Events::Resume &event)
+{
+	/*if (event.Type != "WaterSystem" && event.Type != "All") {
+	return false;
+	}*/
+	m_Pause = false;
+	return true;
+}
+
+bool dd::Systems::WaterSystem::OnRelevantObjectCreated(const dd::Events::RelevantObjectCreated &event)
+{
+	if (event.ObjectName == "BottomWall") {
+		m_BottomWall = event.ObjectID;
+	}
+	return true;
+}
+
+bool dd::Systems::WaterSystem::OnStageCleared(const dd::Events::StageCleared &event)
+{
+	
+	return true;
+}
+
+bool dd::Systems::WaterSystem::OnArrivedAtNewStage(const dd::Events::ArrivedAtNewStage &event)
+{
+	
+	return true;
+}
+
+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->Scale = glm::vec3(7.0f, event.Amount * 1.6f, 1.f);
+		auto water = m_World->AddComponent<Components::WaterVolume>(t_waterBody);
+		auto body = m_World->AddComponent<Components::RectangleShape>(t_waterBody);
+		m_World->CommitEntity(t_waterBody);
+	}
+
+	return true;
+}
+
+bool dd::Systems::WaterSystem::OnRaiseWaterWall(const dd::Events::RaiseWaterWall &event) 
+{
+	auto transform = m_World->GetComponent<Components::Transform>(m_BottomWall);
+	if (transform != nullptr) {
+		glm::vec3 raise = glm::vec3(0, event.Amount, 0);
+		Events::Move e;
+		e.Entity = m_BottomWall;
+		e.GoalPosition = transform->Position + raise;
+		e.Queue = true;
+		e.Speed = 0.2;
+		EventBroker->Publish(e);
+	} else {
+		LOG_ERROR("There is no BottomWall in WaterSystem");
+	}
+
+	return true;
+}