Kraken grows redder with more hits, and uses more dangerous brick-sets. Kraken can change reaction time depending on damage by changing Max/MinSeconds to action in KrakenSystem.

include/Game/CKraken.h

@@ -17,13 +17,14 @@ struct Kraken : Component {
 
     int MaxHealth = 30;
 	int Health = MaxHealth;
-	int CurrentAction = 1;
+	int CurrentAction = 3;
+	float RetreatSpeed = 0.2;
 	
 	const int Idle = 1;
 	const int Grabbing = 2;
-	const int Taunting = 3;
+	const int BrickGenerating = 3;
-	const int Moving = 4;
+	const int BrickGenerating2 = 4;
-	const int BrickGenerating = 5;
+	const int Waiting = 5;
 	// Idle. Generating bricks. Taunting. No idea.
 };
 

include/Game/CLife.h

@@ -16,8 +16,12 @@ namespace Components
 struct Life : Component 
 {
     int Number = 0;
-	float SinusAltitude = 1;
+	float SinusAltitude = 0;
+	float Amplitude = 1;
+	float Frequency = 1;
+	float SinusSpeed = 1;
 	bool Left = false;
+	bool Dead = false;
 };
 
 }

include/Game/EBreakAllBricks.h

@@ -0,0 +1,25 @@
+//
+// Created by Adniklastrator on 2015-10-23.
+//
+
+#ifndef DAYDREAM_EBREAKALLBRICKS_H
+#define DAYDREAM_EBREAKALLBRICKS_H
+
+#include "Core/EventBroker.h"
+
+namespace dd
+{
+
+namespace Events
+{
+
+struct BreakAllBricks : Event
+{
+	
+};
+
+}
+
+}
+
+#endif //DAYDREAM_EBREAKALLBRICKS_H

include/Game/EBrickGenerating.h

@@ -19,6 +19,7 @@ struct BrickGenerating : Event
 	glm::vec3 Origin2;
 	int TargetLine;
 	int Set;
+	int SetCluster;
 };
 
 }

include/Game/KrakenSystem.h

@@ -28,6 +28,7 @@
 #include "Game/EKrakenHit.h"
 #include "Game/EKrakenDefeated.h"
 #include "Game/EBrickGenerating.h"
+#include "Game/EArrivedAtNewStage.h"
 #include "Game/CTravels.h"
 #include "Game/CKraken.h"
 #include "Game/CBall.h"
@@ -64,12 +65,15 @@ private:
 
 	bool m_Pause = false;
 	bool m_KrakenBattle = false;
+	bool m_KrakenHasArrived = false;
 	bool m_ReturnToIdle = false;
 	EntityID m_KrakenTemplate;
 	std::string m_Action = "Idle";
 	int m_NumberOfActions;
 	float m_KrakenTimer = 0;
-	float m_KrakenSecondsToAction = 10;
+	float m_KrakenMaxSecondsToAction = 10;
+	float m_KrakenMinSecondsToAction = 10;
+	float m_KrakenCurrentSecondsToAction = 15;
 	const int Idle = 1;
 
 	std::array<int, 42> m_Bricks;
@@ -83,6 +87,7 @@ private:
 	dd::EventRelay<KrakenSystem, dd::Events::KrakenHit> m_EKrakenHit;
 	dd::EventRelay<KrakenSystem, dd::Events::KrakenDefeated> m_EKrakenDefeated;
 	dd::EventRelay<KrakenSystem, dd::Events::BrickGenerating> m_EBrickGenerating;
+	dd::EventRelay<KrakenSystem, dd::Events::ArrivedAtNewStage> m_EArrivedAtNewStage;
     bool OnPause(const dd::Events::Pause &event);
 	bool OnResume(const dd::Events::Resume &event);
 	bool OnContact(const dd::Events::Contact &event);
@@ -91,6 +96,7 @@ private:
 	bool OnKrakenHit(const dd::Events::KrakenHit &event);
 	bool OnKrakenDefeated(const dd::Events::KrakenDefeated &event);
 	bool OnBrickGenerating(const dd::Events::BrickGenerating &event);
+	bool OnArrivedAtNewStage(const dd::Events::ArrivedAtNewStage &event);
 	void GetBrickSet();
 };
 

include/Game/LevelSystem.h

@@ -180,6 +180,8 @@ private:
 	bool m_BrickGenerating = false;
 	dd::Events::BrickGenerating m_BrickGeneratingEvent;
 
+	bool m_BreakAllBricks = false;
+
     dd::EventRelay<LevelSystem, dd::Events::Contact> m_EContact;
     dd::EventRelay<LevelSystem, dd::Events::ScoreEvent> m_EScoreEvent;
     dd::EventRelay<LevelSystem, dd::Events::MultiBall> m_EMultiBall;
@@ -207,7 +209,7 @@ private:
     bool OnHitPad(const dd::Events::HitPad &event);
 	bool OnBrickGenerating(const dd::Events::BrickGenerating &event);
 	bool BrickGenerating(const dd::Events::BrickGenerating &event);
-	void GetBrickSet(int Set);
+	void GetBrickSet(int Set, int SetCluster);
 	bool OnKrakenDefeated(const dd::Events::KrakenDefeated &event);
 
     void GetNextLevel();

include/Game/LifeSystem.h

@@ -25,6 +25,8 @@
 #include "Game/EKrakenAttackEnd.h"
 
 #include "Rendering/CAnimation.h"
+#include "Physics/CParticleEmitter.h"
+#include "Physics/ECreateParticleSequence.h"
 
 
 namespace dd

include/Game/ScreenShakeSystem.h

@@ -12,6 +12,7 @@
 #include "Core/CTemplate.h"
 #include "Core/EventBroker.h"
 #include "Core/World.h"
+#include "Rendering/CCamera.h"
 #include "Game/EPause.h"
 #include "Game/EResume.h"
 #include "Game/EScreenShake.h"

src/game/Game/KrakenSystem.cpp

@@ -17,6 +17,7 @@ void dd::Systems::KrakenSystem::Initialize()
 	EVENT_SUBSCRIBE_MEMBER(m_EKrakenHit, &KrakenSystem::OnKrakenHit);
 	EVENT_SUBSCRIBE_MEMBER(m_EKrakenDefeated, &KrakenSystem::OnKrakenDefeated);
 	EVENT_SUBSCRIBE_MEMBER(m_EBrickGenerating, &KrakenSystem::OnBrickGenerating);
+	EVENT_SUBSCRIBE_MEMBER(m_EArrivedAtNewStage, &KrakenSystem::OnArrivedAtNewStage);
 
 	EntityID ent = m_World->CreateEntity();
 	auto transform = m_World->AddComponent<Components::Transform>(ent);
@@ -67,6 +68,16 @@ void dd::Systems::KrakenSystem::Update(double dt)
 
 void dd::Systems::KrakenSystem::UpdateEntity(double dt, EntityID entity, EntityID parent)
 {
+	auto kraken = m_World->GetComponent<Components::Kraken>(entity);
+	if (kraken != nullptr) {
+		if (kraken->Health < 0) {
+			auto transform = m_World->GetComponent<Components::Transform>(entity);
+			transform->Position.y += kraken->RetreatSpeed * dt;
+			kraken->RetreatSpeed += 0.05;
+			return;
+		}
+	}
+
     if (IsPaused() || !m_KrakenBattle) {
         return;
     }
@@ -74,7 +85,7 @@ void dd::Systems::KrakenSystem::UpdateEntity(double dt, EntityID entity, EntityI
 	auto templateCheck = m_World->GetComponent<Components::Template>(entity);
 	if (templateCheck != nullptr){ return; }
 
-	auto kraken = m_World->GetComponent<Components::Kraken>(entity);
+	
 	if (kraken != nullptr) {
 		auto transform = m_World->GetComponent<Components::Transform>(entity);
 		if (transform->Position.y < -10) {
@@ -86,7 +97,7 @@ void dd::Systems::KrakenSystem::UpdateEntity(double dt, EntityID entity, EntityI
 		{
 		case 1: // Idle
 			m_KrakenTimer += dt;
-			if (m_KrakenTimer > m_KrakenSecondsToAction) {
+			if (m_KrakenTimer > m_KrakenCurrentSecondsToAction) {
 				m_KrakenTimer = 0;
 				if (m_NumberOfActions == 0) {
 					kraken->CurrentAction = 3;
@@ -114,7 +125,14 @@ void dd::Systems::KrakenSystem::UpdateEntity(double dt, EntityID entity, EntityI
 				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);
+				if (kraken->Health > 20) {
+					e.SetCluster = 0;
+				} else if (kraken->Health > 10) {
+					e.SetCluster = 1;
+				} else {
+					e.SetCluster = 2;
+				}
+				std::uniform_real_distribution<float> dist(1, 6.999f);
 				float random = dist(m_RandomGenerator);
 				e.Set = random;
 				EventBroker->Publish(e);
@@ -126,7 +144,14 @@ void dd::Systems::KrakenSystem::UpdateEntity(double dt, EntityID entity, EntityI
 				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);
+				if (kraken->Health > 20) {
+					e.SetCluster = 0;
+				} else if (kraken->Health > 10) {
+					e.SetCluster = 1;
+				} else {
+					e.SetCluster = 2;
+				}
+				std::uniform_real_distribution<float> dist(1, 6.999f);
 				float random = dist(m_RandomGenerator);
 				e.Set = random;
 				EventBroker->Publish(e);
@@ -196,6 +221,7 @@ bool dd::Systems::KrakenSystem::OnContact(const dd::Events::Contact &event)
 	if (projectile != nullptr) {
 		Events::ScoreEvent es;
 		es.Score = 23;
+		EventBroker->Publish(es);
 		Events::KrakenHit e;
 		e.Kraken = krakenEntity;
 		e.Hitter = otherEntitiy;
@@ -215,6 +241,7 @@ bool dd::Systems::KrakenSystem::OnContact(const dd::Events::Contact &event)
 		EventBroker->Publish(ec);
 		Events::ScoreEvent es;
 		es.Score = ball->Combo * 23;
+		EventBroker->Publish(es);
 		Events::KrakenHit e;
 		e.Kraken = krakenEntity;
 		e.Hitter = otherEntitiy;
@@ -248,7 +275,62 @@ bool dd::Systems::KrakenSystem::OnKrakenAttack(const dd::Events::KrakenAttack &e
 bool dd::Systems::KrakenSystem::OnKrakenHit(const dd::Events::KrakenHit &event)
 {
 	auto kraken = m_World->GetComponent<Components::Kraken>(event.Kraken);
+	auto transform = m_World->GetComponent<Components::Transform>(event.Hitter);
 	kraken->Health--;
+	//kraken->Health -= 15;
+	//kraken->Health = -1; //To defeat the kraken instantly.
+
+	auto model = m_World->GetComponent<Components::Model>(event.Kraken);
+	float modifier = ((float)kraken->MaxHealth - (float)kraken->Health) / (float)kraken->MaxHealth; // 1 is almost no life left, 0 is max life left.
+	std::cout << modifier << std::endl;
+	model->Color = glm::vec4(1, 1 - modifier, 1 - modifier, 1);
+
+	int timeDifferenceBetweenMaxAndMin = m_KrakenMaxSecondsToAction - m_KrakenMinSecondsToAction;
+	m_KrakenCurrentSecondsToAction = m_KrakenMaxSecondsToAction - (modifier * timeDifferenceBetweenMaxAndMin);
+	// If modifier is 1, MaxSeconds is 15, MinSeconds is 5, then... 15 - (1 * 10), meaning 5.
+
+	auto ball = m_World->GetComponent<Components::Transform>(event.Hitter);
+	if (ball != nullptr) {
+		//Particle trail
+		Events::CreateParticleSequence trail;
+		trail.parent = event.Hitter;
+		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 = 2;
+		trail.EmitterLifeTime = 1.f;
+		trail.ParticleLifeTime = 1.f;
+		trail.ParticlesPerTick = 1;
+		trail.SpawnRate = 0.5f;
+		trail.Speed = 10.f;
+		trail.EmittingAngle = glm::half_pi<float>();
+		trail.SpriteFile = "Textures/Particles/FadeBall.png";
+		trail.Color = glm::vec4(1, 0, 0, 1);
+		//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 = 2;
+	poof.Position = transform->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 = glm::vec4(1, 0, 0, 1);
+	poof.AlphaValues.clear();
+	poof.AlphaValues.push_back(1.f);
+	poof.AlphaValues.push_back(0.f);
+	poof.Speed = 20;
+	EventBroker->Publish(poof);
+
 	//std::cout << kraken->Health << std::endl;
 	//kraken->Health = -1;
 	if (kraken->Health < 0) {
@@ -266,6 +348,8 @@ bool dd::Systems::KrakenSystem::OnKrakenDefeated(const dd::Events::KrakenDefeate
 
 	auto kraken = m_World->GetComponent<Components::Kraken>(event.Kraken);
 	auto physicsComponent = m_World->GetComponent<Components::Physics>(event.Kraken);
+
+	m_World->RemoveComponent<Components::Travels>(event.Kraken);
 	/*physicsComponent->CollisionType = CollisionType::Type::Dynamic;
 	physicsComponent->GravityScale = 1.f;*/
 	physicsComponent->Mask = static_cast<CollisionLayer::Type>(CollisionLayer::Water | CollisionLayer::Wall);
@@ -292,8 +376,8 @@ bool dd::Systems::KrakenSystem::OnKrakenDefeated(const dd::Events::KrakenDefeate
 	EventBroker->Publish(i);*/
 
 	auto cModel = m_World->GetComponent<Components::Model>(event.Kraken);
-	cModel->Color = brickModel->Color;
+	cModel->Color = glm::vec4(1, 1, 1, 1);
-	cModel->Color *= 0.5f;
+	cModel->Color *= 0.3f;
 
 	/*m_World->RemoveComponent<Components::Template>(event.Kraken);
 	m_World->SetEntityParent(event.Kraken, 0);
@@ -346,3 +430,11 @@ bool dd::Systems::KrakenSystem::OnBrickGenerating(const dd::Events::BrickGenerat
 {
 	return true;
 }
+
+bool dd::Systems::KrakenSystem::OnArrivedAtNewStage(const dd::Events::ArrivedAtNewStage &event)
+{
+	if (m_KrakenBattle) {
+		m_KrakenHasArrived = true;
+	}
+	return true;
+}

src/game/Game/LevelSystem.cpp

@@ -281,6 +281,12 @@ void dd::Systems::LevelSystem::UpdateEntity(double dt, EntityID entity, EntityID
 
     auto brick = m_World->GetComponent<Components::Brick>(entity);
     if (brick != nullptr) {
+		if (m_BreakAllBricks) {
+			if (!brick->Removed) {
+				brick->Removed = true;
+				BrickHit(entity, entity, 1);
+			}
+		}
 
 		auto transform = m_World->GetComponent<Components::Transform>(entity);
 		if (brick->BeingGenerated) {
@@ -329,6 +335,16 @@ void dd::Systems::LevelSystem::UpdateEntity(double dt, EntityID entity, EntityID
 
     auto ball = m_World->GetComponent<Components::Ball>(entity);
 
+	if (ball != nullptr) {
+		if (m_BrickGenerating) {
+			auto transform = m_World->GetComponent<Components::Transform>(entity);
+			if (transform->Position.y < 0 && transform->Velocity.y < 0) {
+				m_BrickGenerating = false;
+				BrickGenerating(m_BrickGeneratingEvent);
+			}
+		}
+	}
+
     if (NumberOfBricks() <= 0 && m_LooseBricks <= 0 && !Restarting() && !m_Cleared) {
         if (MultiBalls() <= 0 && PowerUps() <= 0) {
             Events::StageCleared ec;
@@ -482,7 +498,7 @@ bool dd::Systems::LevelSystem::OnBrickGenerating(const dd::Events::BrickGenerati
 
 bool dd::Systems::LevelSystem::BrickGenerating(const dd::Events::BrickGenerating &event)
 {
-	GetBrickSet(event.Set);
+	GetBrickSet(event.Set, event.SetCluster);
 
 	int rows = 6;
 	int lines = 7;
@@ -520,7 +536,7 @@ bool dd::Systems::LevelSystem::BrickGenerating(const dd::Events::BrickGenerating
 	return true;
 }
 
-void dd::Systems::LevelSystem::GetBrickSet(int set) // These are sets the Kraken gets!
+void dd::Systems::LevelSystem::GetBrickSet(int set, int setCluster) // These are sets the Kraken gets!
 {
 	std::array<int, 42> level;
 	std::array<glm::vec4, 42> color;
@@ -552,8 +568,101 @@ void dd::Systems::LevelSystem::GetBrickSet(int set) // These are sets the Kraken
 	glm::vec4 m = glm::vec4(1, 0, 1, 1);
 	glm::vec4 d = glm::vec4(0, 0, 0, 1);
 
+	if (setCluster == 0) {
 		if (set == 1) {
-		level =
+			level = // The Charge
+			{1, 0, 0, 0, 0, 0, 1,
+			 0, 1, 0, 0, 0, 1, 0,
+			 0, 0, 1, 0, 1, 0, 0,
+			 0, 0, 0, 1, 0, 0, 0,
+			 0, 0, 0, 0, 0, 0, 0,
+			 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 };
+		} else if (set == 2) {
+			level = // The Audience
+			{0, 0, 0, 0, 0, 0, 0,
+			 1, 0, 0, 0, 0, 0, 1,
+			 1, 0, 0, 0, 0, 0, 1,
+			 1, 0, 0, 0, 0, 0, 1,
+			 1, 0, 0, 0, 0, 0, 1,
+			 0, 0, 0, 0, 0, 0, 0 };
+			color =
+			{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 = // The Alien Defense
+			{0, 0, 0, 0, 0, 0, 0,
+			 0, 0, 0, 0, 0, 0, 0,
+			 0, 0, 0, 0, 0, 0, 0,
+			 0, 1, 0, 0, 0, 1, 0,
+			 1, 1, 1, 0, 1, 1, 1,
+			 0, 0, 0, 0, 0, 0, 0 };
+			color =
+			{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 = // The Scales (right)
+			{1, 1, 1, 0, 0, 0, 0,
+			 1, 1, 1, 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,
+			 0, 0, 0, 0, 1, 1, 1 };
+			color =
+			{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 = // The Scales (left)
+			{0, 0, 0, 0, 1, 1, 1,
+			 0, 0, 0, 0, 1, 1, 1,
+			 0, 0, 0, 0, 0, 0, 0,
+			 0, 0, 0, 0, 0, 0, 0,
+			 1, 1, 1, 0, 0, 0, 0,
+			 1, 1, 1, 0, 0, 0, 0 };
+			color =
+			{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 = // The Sword
+			{0, 0, 0, 1, 0, 0, 0,
+			 0, 0, 1, 1, 1, 0, 0,
+			 0, 0, 0, 1, 0, 0, 0,
+			 0, 0, 0, 1, 0, 0, 0,
+			 0, 0, 0, 1, 0, 0, 0,
+			 0, 0, 0, 1, 0, 0, 0 };
+			color =
+			{c, c, c, c, c, c, c,
+			 c, c, c, c, c, c, c,
+			 c, c, c, c, c, c, c,
+			 c, c, c, c, c, c, c,
+			 c, c, c, c, c, c, c,
+			 c, c, c, c, c, c, c };
+		}
+	} else if (setCluster == 1) {
+		if (set == 1) {
+			level = // The Wall
 			{1, 0, 0, 0, 0, 0, 1,
 			 1, 0, 0, 0, 0, 0, 1,
 			 1, 0, 0, 0, 0, 0, 1,
@@ -567,9 +676,8 @@ void dd::Systems::LevelSystem::GetBrickSet(int set) // These are sets the Kraken
 			 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) {
-	else if (set == 2) {
+			level = // The Checkerboard
-		level =
 			{0, 0, 0, 0, 0, 0, 0,
 			 0, 0, 0, 0, 0, 0, 0,
 			 3, 0, 1, 0, 1, 0, 1,
@@ -583,9 +691,8 @@ void dd::Systems::LevelSystem::GetBrickSet(int set) // These are sets the Kraken
 			 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) {
-	else if (set == 3) {
+			level = // The Fighter Jet
-		level =
 			{0, 0, 0, 0, 0, 0, 0,
 			 0, 0, 0, 0, 0, 0, 0,
 			 1, 0, 1, 0, 1, 0, 1,
@@ -599,9 +706,8 @@ void dd::Systems::LevelSystem::GetBrickSet(int set) // These are sets the Kraken
 			 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) {
-	else if (set == 4) {
+			level = // The Formation
-		level =
 			{0, 0, 0, 0, 0, 0, 0,
 			 1, 1, 1, 1, 1, 3, 1,
 			 0, 0, 0, 0, 0, 0, 0,
@@ -615,9 +721,8 @@ void dd::Systems::LevelSystem::GetBrickSet(int set) // These are sets the Kraken
 			 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) {
-	else if (set == 5) {
+			level = // The Pillars
-		level =
 			{0, 0, 0, 0, 0, 0, 0,
 			 0, 1, 1, 0, 1, 1, 0,
 			 0, 1, 2, 0, 1, 1, 0,
@@ -631,22 +736,114 @@ void dd::Systems::LevelSystem::GetBrickSet(int set) // These are sets the Kraken
 			 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) {
-	else if (set == 6) {
+			level = // The Treasure Chest
-		level =
+			{0, 0, 0, 1, 0, 0, 0,
-		{0, 0, 0, 0, 0, 0, 0,
+			 0, 0, 1, 1, 1, 0, 0,
-		 0, 0, 0, 0, 0, 0, 0,
+			 0, 1, 1, 5, 1, 1, 0,
-		 0, 0, 0, 0, 0, 0, 0,
+			 0, 0, 1, 1, 1, 0, 0,
-		 1, 1, 1, 1, 1, 1, 1,
+			 0, 0, 0, 1, 0, 0, 0,
-		 1, 1, 1, 1, 1, 1, 1,
 			 0, 0, 0, 0, 0, 0, 0 };
 			color =
+			{c, c, c, c, c, c, c,
+			 c, c, c, c, c, c, c,
+			 c, c, c, c, c, c, c,
+			 c, c, c, c, c, c, c,
+			 c, c, c, c, c, c, c,
+			 c, c, c, c, c, c, c };
+		}
+	} else if (setCluster == 2) {
+		if (set == 1) {
+			level = // The Butterfly
+			{1, 0, 0, 1, 0, 0, 1,
+			 1, 1, 0, 1, 0, 1, 1,
+			 1, 1, 1, 1, 1, 1, 1,
+			 1, 1, 0, 1, 0, 1, 1, 
+			 1, 0, 0, 2, 0, 0, 1,
+			 1, 0, 0, 1, 0, 0, 3 };
+			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 };
+		} else if (set == 2) {
+			level = // The Cross
+			{1, 1, 0, 0, 0, 1, 1,
+			 0, 4, 1, 0, 1, 1, 0,
+			 0, 0, 1, 1, 1, 0, 0,
+			 0, 0, 1, 3, 1, 0, 0,
+			 0, 1, 1, 0, 1, 1, 0,
+			 1, 1, 0, 0, 0, 1, 1 };
+			color =
+			{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 = // The Inverted Cross
+			{0, 0, 1, 6, 1, 0, 0,
+			 1, 0, 0, 1, 0, 0, 1,
+			 1, 1, 0, 0, 0, 1, 3,
+			 1, 1, 0, 0, 0, 1, 1,
+			 1, 0, 0, 1, 0, 0, 1,
+			 0, 0, 1, 1, 1, 0, 0 };
+			color =
+			{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 = // The Great Wall
+			{1, 1, 1, 1, 1, 1, 1,
+			 1, 1, 1, 1, 1, 1, 1,
+			 0, 0, 0, 0, 0, 0, 0,
+			 1, 1, 1, 1, 1, 5, 1,
+			 0, 0, 0, 0, 0, 0, 0,
+			 1, 3, 1, 1, 1, 1, 1 };
+			color =
+			{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 = // The Champion
+			{0, 0, 1, 1, 1, 0, 0,
+			 0, 0, 1, 1, 2, 0, 0,
+			 0, 0, 1, 1, 1, 0, 0,
+			 1, 1, 1, 0, 1, 1, 1,
+			 5, 1, 1, 0, 1, 1, 1,
+			 1, 1, 1, 0, 1, 1, 1 };
+			color =
+			{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 = // The Dog. What, you can't see it? XD
+			{0, 1, 1, 1, 1, 1, 0,
+			 1, 1, 2, 1, 2, 1, 1,
+			 1, 1, 1, 1, 1, 1, 1,
+			 1, 0, 1, 1, 1, 0, 1,
+			 1, 0, 1, 1, 1, 0, 1,
+			 0, 0, 0, 3, 0, 0, 0 };
+			color =
+			{c, c, c, c, c, c, c,
+			 c, c, c, c, c, c, c,
+			 c, c, c, c, c, c, c,
+			 c, c, c, c, c, c, c,
+			 c, c, c, c, c, c, c,
+			 c, c, c, c, c, c, c };
+		}
 	}
 
 	std::copy(std::begin(level), std::end(level), std::begin(m_BrickSet));
@@ -932,9 +1129,14 @@ bool dd::Systems::LevelSystem::OnPowerUpTaken(const dd::Events::PowerUpTaken &ev
 bool dd::Systems::LevelSystem::OnKrakenDefeated(const dd::Events::KrakenDefeated &event)
 {
 	m_BrickGenerating = false;
+	m_BreakAllBricks = true;
 	SetNumberOfBricks(NumberOfBricks() - 1);
 	m_LooseBricks--;
 
+	Events::ScoreEvent e;
+	e.Score = 1000;
+	EventBroker->Publish(e);
+
 	std::cout << m_LooseBricks << std::endl;
 
 	return true;
@@ -943,6 +1145,7 @@ bool dd::Systems::LevelSystem::OnKrakenDefeated(const dd::Events::KrakenDefeated
 bool dd::Systems::LevelSystem::OnStageCleared(const dd::Events::StageCleared &event)
 {
     if (!m_Cleared) {
+		m_BreakAllBricks = false;
         m_Cleared = true;
         SetRestarting(true);
         Events::ResetBall e;
@@ -1041,10 +1244,10 @@ void dd::Systems::LevelSystem::GetNextLevel()
             level =
                     {0, 0, 0, 0, 0, 0, 0,
                      0, 0, 0, 0, 0, 0, 0,
-                     0, 0, 0, 100, 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,
+                     0, 0, 0, 100, 0, 0, 0};
 			color = 
 					{w, w, w, w, w, w, w,
 					 w, w, w, w, w, w, w,
@@ -1217,10 +1420,6 @@ 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/LifeSystem.cpp

@@ -52,29 +52,90 @@ void dd::Systems::LifeSystem::UpdateEntity(double dt, EntityID entity, EntityID
 	
 	if (life != nullptr) {
 		auto transform = m_World->GetComponent<Components::Transform>(entity);
+		if (transform->Position.y < -8) {
+			m_World->RemoveEntity(entity);
+			return;
+		}
+
+		transform->Position.x += transform->Velocity.x * dt;
+		transform->Position.y += transform->Velocity.y * dt;
+		
+		glm::vec2 dir = glm::normalize(glm::vec2(transform->Velocity.x, transform->Velocity.y));
+		glm::vec2 up = glm::vec2(0.f, 1.f);
+		float angle = glm::acos(glm::dot<float>(dir, up)) * glm::sign(dir.x);
+		transform->Orientation = glm::rotate(glm::quat(), angle, glm::vec3(0.f, 0.f, -1.f));
+
+		if (!life->Dead) {
 			if (life->Left) {
-			if (transform->Position.x > 3) {
+				if (transform->Position.x < -3.8) {
 					life->Left = false;
 					transform->Velocity.x = m_LifeSpeed;
 				}
-		} else {
+			}
-			
+			else {
-			if (transform->Position.x < -3) {
+				if (transform->Position.x > 3.8) {
 					life->Left = true;
 					transform->Velocity.x = -m_LifeSpeed;
 				}
 			}
-		transform->Position.x += transform->Velocity.x * dt;
+
-		/*glm::vec2 dir = glm::normalize(glm::vec2(transform->Velocity.x, transform->Velocity.y));
+			float sin = life->SinusAltitude;
-		glm::vec2 up = glm::vec2(0.f, 1.f);
+			life->SinusAltitude += life->SinusSpeed * dt;
-		float angle = glm::acos(glm::dot<float>(dir, up)) * glm::sign(dir.x);
+			float y = glm::sin((sin)* glm::half_pi<float>() * life->Frequency) * life->Amplitude;
-		transform->Orientation = glm::rotate(glm::quat(), angle, glm::vec3(0.f, 0.f, -1.f));*/
+			transform->Velocity.y = y;
+
 			if (Lives() != PastLives()) {
 				if (life->Number + 1 == PastLives()) {
-				m_World->RemoveEntity(entity);
+					life->Dead = true;
+					auto model = m_World->GetComponent<Components::Model>(entity);
+					model->Color *= 0.3;
+
+					//Particle trail
+					Events::CreateParticleSequence trail;
+					trail.parent = entity;
+					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 = model->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 = transform->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 = model->Color;
+					poof.AlphaValues.clear();
+					poof.AlphaValues.push_back(1.f);
+					poof.AlphaValues.push_back(0.f);
+					poof.Speed = 10;
+					EventBroker->Publish(poof);
+
+					//m_World->RemoveEntity(entity);
 					SetPastLives(Lives());
 				}
 			}
+		} else {
+			transform->Velocity.y -= 0.5 * dt;
+		}
 	}
 }
 
@@ -82,20 +143,25 @@ void dd::Systems::LifeSystem::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->Position = glm::vec3(-1.5f + number * 0.15f, -2.f, -5.f);
-	//transform->Position = glm::vec3(-1.5f + number * 1.5f, -3.f, -10.f);
+	transform->Position = glm::vec3(-3.8f + number * 3.7f, -5.2f, -10.f);
-	transform->Scale = glm::vec3(0.1f, 0.1f, 0.1f);
+	//transform->Scale = glm::vec3(0.1f, 0.1f, 0.1f);
-	/*transform->Scale = glm::vec3(0.2f, 0.2f, 0.2f);
+	transform->Scale = glm::vec3(0.2f, 0.2f, 0.2f);
-	transform->Velocity.x = m_LifeSpeed;*/
+	transform->Velocity.x = m_LifeSpeed;
 
-	std::shared_ptr<Components::Life> lifeNr = m_World->AddComponent<Components::Life>(life);
+	std::shared_ptr<Components::Life> cLife = m_World->AddComponent<Components::Life>(life);
-	lifeNr->Number = number;
+	cLife->Number = number;
+	cLife->SinusAltitude = glm::half_pi<float>() * number;
+	cLife->Amplitude = 0.2;
+	cLife->Frequency = 1;
+	cLife->SinusSpeed = 1;
 
 	auto model = m_World->AddComponent<Components::Model>(life);
 	model->ModelFile = "Models/Sid/Sid.dae";
 
 	auto anim = m_World->AddComponent<Components::Animation>(life);
-	anim->Speed = 0.f;
+	anim->Speed = 0.5f;
+
 	m_World->CommitEntity(life);
 }
 

src/game/Game/ScreenShakeSystem.cpp

@@ -36,7 +36,7 @@ void dd::Systems::ScreenShakeSystem::UpdateEntity(double dt, EntityID entity, En
         return;
     }
 
-	/*auto camera = m_World->GetComponent<Components::Camera>(entity);
+	auto camera = m_World->GetComponent<Components::Camera>(entity);
 	
 	if (camera != nullptr) {
 		auto transform = m_World->GetComponent<Components::Transform>(entity);
@@ -73,7 +73,7 @@ void dd::Systems::ScreenShakeSystem::UpdateEntity(double dt, EntityID entity, En
 		} else {
 			m_CameraPosition = transform->Position;
 		}
-	}*/
+	}
 }
 
 bool dd::Systems::ScreenShakeSystem::OnPause(const dd::Events::Pause &event)