Fixed problems I ran into while playtesting.

Conflicts:
	include/Game/BallSystem.h
	include/Game/ProjectileSystem.h
	src/game/Game/BallSystem.cpp
	src/game/Game/ProjectileSystem.cpp
	src/game/Rendering/AnimationSystem.cpp

assets/DefaultConfig.ini

@@ -1,6 +1,7 @@
 [Debug]
-SkipStory=false
 LogLevel=1
+SkipPreload=false
+SkipMenu=false
 
 [Audio]
 SFXVolume=0.5
@@ -9,4 +10,10 @@ BGMVolume=0.5
 [Video]
 Fullscreen=false
 Width=675
-Height=1080[Water]Radius=0.3[Cheat]GodMode=false
+Height=1080
+
+[Water]
+Radius=0.3
+
+[Cheat]
+GodMode=false

include/Core/Engine.h

@@ -34,9 +34,11 @@
 #include "CTemplate.h"
 #include "Core/ConfigFile.h"
 #include "Core/EventBroker.h"
+#include "Input/InputSystem.h"
 #include "Rendering/CModel.h"
 #include "Rendering/CSprite.h"
 #include "Rendering/CPointLight.h"
+#include "Rendering/CCamera.h"
 #include "Transform/TransformSystem.h"
 #include "Sound/SoundSystem.h"
 #include "Sound/CCollisionSound.h"
@@ -67,6 +69,7 @@
 
 #include "Game/BrickComponents.h"
 
+#include "Game/ScreenShakeSystem.h"
 #include "Game/EScreenShake.h"
 
 #include "Physics/PhysicsSystem.h"
@@ -147,6 +150,7 @@ public:
 
 		m_World->ComponentFactory.Register<Components::Sprite>();
 
+		m_World->ComponentFactory.Register<Components::Camera>();
 		m_World->ComponentFactory.Register<Components::RectangleShape>();
 		m_World->ComponentFactory.Register<Components::Physics>();
 		m_World->ComponentFactory.Register<Components::Ball>();
@@ -173,6 +177,9 @@ public:
 		m_World->ComponentFactory.Register<Components::InkBlasterBrick>();
 		m_World->ComponentFactory.Register<Components::KrakenAttackBrick>();
 
+		//m_World->SystemFactory.Register<Systems::InputSystem>(
+		//	[this]() { return new Systems::InputSystem(m_World.get(), m_EventBroker); });
+		//m_World->AddSystem<Systems::InputSystem>();
 		m_World->SystemFactory.Register<Systems::LevelSystem>(
 			[this]() { return new Systems::LevelSystem(m_World.get(), m_EventBroker); });
 		m_World->AddSystem<Systems::LevelSystem>();
@@ -209,6 +216,9 @@ public:
 		m_World->SystemFactory.Register<Systems::LifeSystem>(
 			[this]() { return new Systems::LifeSystem(m_World.get(), m_EventBroker); });
 		m_World->AddSystem<Systems::LifeSystem>();
+		m_World->SystemFactory.Register<Systems::ScreenShakeSystem>(
+			[this]() { return new Systems::ScreenShakeSystem(m_World.get(), m_EventBroker); });
+		m_World->AddSystem<Systems::ScreenShakeSystem>();
 
 		m_World->ComponentFactory.Register<Components::Model>();
 		m_World->ComponentFactory.Register<Components::Template>();
@@ -251,9 +261,10 @@ public:
 		m_LastTime = currentTime;
 
 		// Update input
+		m_EventBroker->Swap();
 		m_InputManager->Update(dt);
-		// Swap event queues to get fresh input data in the read queue
+		//m_EventBroker->Process<Systems::InputSystem>();
-		//m_EventBroker->Swap();
+		m_EventBroker->Swap();
 
 		//ResourceManager::Update();
 		if (m_GameIsRunning) {
@@ -271,8 +282,6 @@ public:
 			TEMPAddToRenderQueue();
 		}
 
-		std::unique_ptr<dd::Camera> defaultCamera = nullptr;
-
 		// Render scene
 		//TODO send renderqueue to draw.
 		m_Renderer->Draw(m_RendererQueue);
@@ -280,6 +289,7 @@ public:
 		m_EventBroker->Process<Engine>();
 		// Swap event queues
 		m_EventBroker->Swap();
+		m_EventBroker->Clear();
 
 		glfwPollEvents();
 	}
@@ -293,6 +303,20 @@ public:
 		if (!m_TransformSystem)
 			m_TransformSystem = m_World->GetSystem<Systems::TransformSystem>();
 		
+		// HACK: How do we handle multiple cameras? Maybe view and projection matrices in render queue...
+		auto cameras = m_World->GetComponentsOfType<Components::Camera>();
+		if (cameras != nullptr) {
+			for (auto& component : *cameras) {
+				auto camera = static_cast<Components::Camera*>(component.get());
+				auto transform = m_World->GetComponent<Components::Transform>(camera->Entity);
+				m_Renderer->Camera()->SetPosition(transform->Position);
+				m_Renderer->Camera()->SetOrientation(transform->Orientation);
+				m_Renderer->Camera()->SetFOV(camera->FOV);
+				m_Renderer->Camera()->SetNearClip(camera->NearClip);
+				m_Renderer->Camera()->SetFarClip(camera->FarClip);
+			}
+		}
+
 		for (auto &pair : *m_World->GetEntities())
 		{
 			EntityID entity = pair.first;

include/Core/EventBroker.h

@@ -121,6 +121,7 @@ public:
 	int Process();
 	int Process(std::string contextTypeName);
 	void Swap();
+	void Clear();
 	void Unsubscribe(BaseEventRelay &relay);
 
 private:

include/Game/BallSystem.h

@@ -50,6 +50,7 @@
 #include "Physics/ECreateParticleSequence.h"
 #include "Sound/CCollisionSound.h"
 #include "Sound/EPlaySound.h"
+#include "Rendering/EAnimationComplete.h"
 
 namespace dd
 {
@@ -104,7 +105,7 @@ private:
 	std::mt19937 m_RandomGenerator;
 
     float m_XMovementMultiplier = 2.f;
-    float m_EdgeX = 3.4f; //Actually 3.2, but anyways.
+    float m_EdgeX = 3.2f; 
     float m_EdgeY = 5.2f;
     int m_MultiBalls = 0;
     bool m_ReplaceBall = false;
@@ -145,6 +146,7 @@ private:
     dd::EventRelay<BallSystem, dd::Events::ActionButton> m_EActionButton;
 	dd::EventRelay<BallSystem, dd::Events::StageCleared> m_EStageCleared;
 	dd::EventRelay<BallSystem, dd::Events::ArrivedAtNewStage> m_EArrivedAtNewStage;
+	dd::EventRelay<BallSystem, dd::Events::AnimationComplete> m_EAnimationComplete;
 
     bool Contact(const Events::Contact &event);
     bool OnMultiBallLost(const dd::Events::MultiBallLost &event);
@@ -160,6 +162,7 @@ private:
     bool OnActionButton(const dd::Events::ActionButton &event);
 	bool OnStageCleared(const dd::Events::StageCleared &event);
 	bool OnArrivedToNewStage(const dd::Events::ArrivedAtNewStage &event);
+	bool OnAnimationComplete(const dd::Events::AnimationComplete &event);
 };
 
 }

include/Game/CBall.h

@@ -22,6 +22,7 @@ struct Ball : Component
     bool Waiting = true;
 	bool InkBlaster = false;
 	bool Sticky = false;
+	bool Loaded = false;
 	glm::vec3 StickyPlacement = glm::vec3(0, 0, 0);
     glm::vec3 SavedSpeed = glm::vec3(0, 1, 0);
 

include/Game/CKraken.h

@@ -15,15 +15,16 @@ namespace Components
 
 struct Kraken : Component {
 
-    int MaxHealth = 30;
+    int MaxHealth = 18;
 	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,8 @@ struct BrickGenerating : Event
 	glm::vec3 Origin2;
 	int TargetLine;
 	int Set;
+	int SetCluster;
+	int Speed = 6;
 };
 
 }

include/Game/EKrakenHit.h

@@ -6,6 +6,7 @@
 #define DAYDREAM_EKRAKENHIT_H
 
 #include "Core/EventBroker.h"
+#include "Core/CTransform.h"
 
 namespace dd
 {
@@ -17,6 +18,7 @@ struct KrakenHit : Event
 {
 	EntityID Kraken;
 	EntityID Hitter;
+	glm::vec3 PlaceHit;
 	int MaxHealth;
 	int CurrentHealth;
 	int NewHealth;

include/Game/EScreenShake.h

@@ -15,9 +15,9 @@ namespace Events
 
 struct ScreenShake : Event
 {
-    float Time;
+    float Time = 1.f;
-	int Intensity;
+	float Intensity = 1.f;
-	float TimeTakenToCoolDown;
+	float TimeTakenToCoolDown = 1.f;
 };
 
 }

include/Game/GUI/HUD.h

@@ -41,8 +41,10 @@ public:
 		m_FPSCounter = new GUI::FPSCounter(this, "FPSCounter");
 
 		m_KrakenAttackSlider = new Slider(this, "KrakenSlider");
-		m_KrakenAttackSlider->SetTexture("Textures/GUI/Menu/SliderBackground.png");
+		m_KrakenAttackSlider->SetTexture("Textures/GUI/KrakenSlider/KrakenArmSliderBackground.png");
-		m_KrakenAttackSlider->SetTextureReleased("Textures/GUI/Menu/SliderHandle.png");
+		m_KrakenAttackSlider->SetTextureReleased("Textures/GUI/KrakenSlider/SpaceSpam.png");
+		m_KrakenAttackSlider->SetTexturePressed("Textures/GUI/KrakenSlider/SpaceHit.png");
+
 		m_KrakenAttackSlider->SetLeft(Width / 2 - m_KrakenAttackSlider->Width / 2);
 		m_KrakenAttackSlider->Y = 800;
 		m_KrakenAttackSlider->Hide();

include/Game/KrakenSystem.h

@@ -28,10 +28,12 @@
 #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"
 #include "Game/CProjectile.h"
+#include "Game/EScreenShake.h"
 #include "Sound/CCollisionSound.h"
 #include "Rendering/CAnimation.h"
 #include "Rendering/CSprite.h"
@@ -64,14 +66,21 @@ private:
 
 	bool m_Pause = false;
 	bool m_KrakenBattle = false;
+	bool m_KrakenHasArrived = false;
 	bool m_ReturnToIdle = false;
+	bool m_RandomKraken = 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;
 
+	int m_Set = 0;
+	int m_SetCluster = 0;
+
 	std::array<int, 42> m_Bricks;
 	std::array<int, 42> m_Colors;
 
@@ -83,6 +92,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,7 +101,9 @@ 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();
+	void CreateBloodEffect(glm::vec3);
 };
 
 }

include/Game/LevelSystem.h

@@ -19,6 +19,7 @@
 #include "Rendering/CSprite.h"
 #include "Rendering/CModel.h"
 #include "Rendering/CPointLight.h"
+#include "Rendering/CCamera.h"
 
 #include "Transform/EMove.h"
 
@@ -59,6 +60,7 @@
 #include "Game/EKrakenAppear.h"
 #include "Game/EKrakenDefeated.h"
 #include "Game/EBrickGenerating.h"
+#include "Game/EBreakAllBricks.h"
 
 #include "Physics/CPhysics.h"
 #include "Physics/CCircleShape.h"
@@ -101,7 +103,7 @@ public:
     void CreateBasicLevel(int, int, glm::vec2, float);
     void CreateLevel(int);
     EntityID CreateBrick(int, int, glm::vec2, float, int, int, int, glm::vec4);
-	void BrickHit(EntityID, EntityID, int);
+	void BrickHit(EntityID, EntityID, int, bool);
 
     void OnEntityRemoved(EntityID entity);
 
@@ -180,6 +182,9 @@ private:
 	bool m_BrickGenerating = false;
 	dd::Events::BrickGenerating m_BrickGeneratingEvent;
 
+	bool m_KrakenBattle = false;
+	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;
@@ -192,6 +197,7 @@ private:
 	dd::EventRelay<LevelSystem, dd::Events::Resume> m_EResume;
     dd::EventRelay<LevelSystem, dd::Events::HitPad> m_EHitPad;
 	dd::EventRelay<LevelSystem, dd::Events::BrickGenerating> m_EBrickGenerating;
+	dd::EventRelay<LevelSystem, dd::Events::BreakAllBricks> m_EBreakAllBricks;
 	dd::EventRelay<LevelSystem, dd::Events::KrakenDefeated> m_EKrakenDefeated;
 
     bool OnContact(const dd::Events::Contact &event);
@@ -207,7 +213,8 @@ 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);
+	bool OnBreakAllBricks(const dd::Events::BreakAllBricks &event);
+	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/LifebuoySystem.h

@@ -47,6 +47,10 @@ public:
 private:
 	bool m_Pause = false;
 	EntityID m_Template;
+	Events::Lifebuoy m_SavedEvent;
+	bool m_Lifebuoy = false;
+	float m_Timer;
+	float m_WaitingTime = 0.4;
 
 	dd::EventRelay<LifebuoySystem, dd::Events::Contact> m_EContact;
 	dd::EventRelay<LifebuoySystem, dd::Events::Pause> m_EPause;
@@ -58,6 +62,7 @@ private:
 	bool OnPause(const dd::Events::Pause &event);
 	bool OnResume(const dd::Events::Resume &event);
 	bool OnLifebuoy(const dd::Events::Lifebuoy &event);
+	bool Lifebuoy(const dd::Events::Lifebuoy &event);
 	bool OnLifebuoyHit(const dd::Events::LifebuoyHit &event);
 
 	struct LifebuoyInfo

include/Game/PadSystem.h

@@ -54,6 +54,7 @@
 #include "Rendering/CAnimation.h"
 
 #include "Game/EBrickGenerating.h"
+#include "Game/EBreakAllBricks.h"
 
 
 namespace dd
@@ -90,8 +91,8 @@ private:
     float m_Edge = 2.8f;
 	float m_PadOriginalHeight = -4.8;
 	float m_PadHeight = m_PadOriginalHeight;
-	EntityID m_KrakenArm = NULL;
+	EntityID m_KrakenArm = 0;
-	EntityID m_KrakenArmHitbox = NULL;
+	EntityID m_KrakenArmHitbox = 0;
 	float m_PadRiseSpeed = 0.2;
     Components::Transform* m_PadTransform = nullptr;
     Components::Pad* m_PadComponent = nullptr;

include/Game/ProjectileSystem.h

@@ -30,6 +30,7 @@
 #include "Game/CProjectile.h"
 #include "Game/CBall.h"
 #include "Rendering/CSprite.h"
+#include "Rendering/CAnimation.h"
 
 namespace dd
 {
@@ -60,7 +61,7 @@ private:
 	int m_Shots = 0;
 	float m_InkBlasterSpeed = 5;
 	EntityID m_InkBlastTemplate;
-	EntityID m_AttachedSquid;
+	EntityID m_AttachedSquid = 0;
 
 	dd::EventRelay<ProjectileSystem, dd::Events::Contact> m_EContact;
 	dd::EventRelay<ProjectileSystem, dd::Events::Pause> m_EPause;

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"

include/Physics/CParticleEmitter.h

@@ -26,6 +26,8 @@ struct ParticleEmitter : public Component
 	//values to interpolate between.
 	std::vector<glm::vec3> ScaleValues;
 	std::vector<float> AlphaValues;
+	std::vector<glm::vec3> VelocityValues;
+
 
     //System variables
     float GravityScale = 1.0f;

include/Physics/ECreateParticleSequence.h

@@ -29,6 +29,7 @@ struct CreateParticleSequence : public Event
 	bool DefaultScale = false;
 	std::vector<glm::vec3> ScaleValues;
 	std::vector<float> AlphaValues;
+	std::vector<glm::vec3> VelocityValues;
 
     //Particle
     std::string SpriteFile = "";

include/Rendering/BaseRenderer.h

@@ -37,8 +37,8 @@ public:
 	void SetFullscreen(bool fullscreen) { m_Fullscreen = fullscreen; }
 	bool VSYNC() const { return m_VSYNC; }
 	void SetVSYNC(bool vsync) { m_VSYNC = vsync; }
-	const dd::Camera* Camera() const { return m_Camera; }
+	dd::Camera* Camera() const { return m_Camera; }
-	void SetCamera(const dd::Camera* camera)
+	void SetCamera(dd::Camera* camera)
 	{
 		if (camera == nullptr) {
 			m_Camera = m_DefaultCamera.get();
@@ -55,7 +55,7 @@ protected:
 	bool m_Fullscreen = false;
 	bool m_VSYNC = false;
 	std::unique_ptr<dd::Camera> m_DefaultCamera = nullptr;
-	const dd::Camera* m_Camera = nullptr;
+	dd::Camera* m_Camera = nullptr;
 	GLFWwindow* m_Window = nullptr;
 };
 

include/Rendering/CCamera.h

@@ -30,14 +30,9 @@ namespace Components
 
 struct Camera : Component
 {
-	Camera() 
+	float FOV = glm::radians(45.f);
-	: FOV(glm::radians(45.f))
+	float NearClip = 0.01f;
-	, NearClip(0.1f)
+	float FarClip = 100.f;
-	, FarClip(100.f) { }
-
-	float FOV;
-	float NearClip;
-	float FarClip;
 };
 
 }

include/Rendering/EAnimationComplete.h

@@ -9,7 +9,7 @@ namespace dd
 namespace Events
 {
 
-struct AnimationComplete
+struct AnimationComplete : Event
 {
 	EntityID Entity;
 	std::string Animation;

include/Rendering/OpenGL/Rendering/Renderer.h

@@ -43,7 +43,6 @@ class Renderer : public BaseRenderer
 public:
 	void Initialize() override;
 	void Draw(RenderQueueCollection& rq) override;
-	void PlaceCamera(glm::vec3 position);
 
 private:
 	int m_GLVersion[2];
@@ -97,12 +96,6 @@ private:
 	void DrawWater(RenderQueue &objects);
 	void DrawGUI(RenderQueue& rq);
 	void DebugKeys();
-
-	dd::EventRelay<Renderer, dd::Events::ScreenShake> m_EScreenShake;
-	bool OnScreenShake(dd::Events::ScreenShake &event);
-	bool m_ScreenShake = false;
-	float m_ShakeIntensity = 0;
-	float m_ShakeTimer = 0;
 };
 
 }

src/game/Core/EventBroker.cpp

@@ -91,8 +91,11 @@ int dd::EventBroker::Process(std::string contextTypeName)
 void dd::EventBroker::Swap()
 {
 	std::swap(m_EventQueueRead, m_EventQueueWrite);
-	m_EventQueueWrite->clear();
+}
 
+void dd::EventBroker::Clear()
+{
+	m_EventQueueWrite->clear();
 }
 
 void dd::EventBroker::subscribeImmediate(dd::BaseEventRelay& relay)

src/game/Game/BallSystem.cpp

@@ -28,6 +28,7 @@ void dd::Systems::BallSystem::Initialize()
     EVENT_SUBSCRIBE_MEMBER(m_EActionButton, &BallSystem::OnActionButton);
 	EVENT_SUBSCRIBE_MEMBER(m_EStageCleared, &BallSystem::OnStageCleared);
 	EVENT_SUBSCRIBE_MEMBER(m_EArrivedAtNewStage, &BallSystem::OnArrivedToNewStage);
+	EVENT_SUBSCRIBE_MEMBER(m_EAnimationComplete, &BallSystem::OnAnimationComplete);
 
 
     //OctoBall
@@ -39,7 +40,7 @@ void dd::Systems::BallSystem::Initialize()
         transform->Velocity = glm::vec3(0.f, 0.f, 0.f);
 		transform->Orientation = glm::quat();
         auto model = m_World->AddComponent<Components::Model>(ent);
-        model->ModelFile = "Models/Sid/Sid.dae";
+        model->ModelFile = "Models/Sid/Sid_Flying.dae";
 		auto animation = m_World->AddComponent<Components::Animation>(ent);
 		animation->Speed = 1.0;
         std::shared_ptr<Components::CircleShape> circleShape = m_World->AddComponent<Components::CircleShape>(ent);
@@ -118,13 +119,32 @@ 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);*/
                 transformBall->Velocity = glm::normalize(ballComponent->SavedSpeed) * ballComponent->Speed;
+
+				auto cAnim = m_World->GetComponent<Components::Animation>(entity);
+				cAnim->Loop = false;
+				cAnim->Speed = 2.f;
+				cAnim->Time = 0.f; 
 				//transform->Velocity = glm::normalize(glm::vec3(0, 1, 0)) * ballComponent->Speed;
-            } else if (!ballComponent->Sticky) {
+			} else {
                 transformBall->Velocity = glm::vec3(0.f, 0.f, 0.f);
-                //transform->Position = glm::vec3(0.0f, -3.f, -10.f);
+
-				if (m_First) {
+				auto cModel = m_World->GetComponent<Components::Model>(entity);
-					transformBall->Orientation = glm::quat();
+				cModel->ModelFile = "Models/Sid/Sid_Jump.dae";
-					m_First = false;
+
+				auto cAnim = m_World->GetComponent<Components::Animation>(entity);
+				cAnim->Speed = 0.f;
+				cAnim->Time = 0.f;
+				cAnim->Loop = false;
+
+				if (!ballComponent->Sticky) {
+					auto transform = m_World->GetComponent<Components::Transform>(entity);
+					transform->Velocity = glm::vec3(0.f, 0.f, 0.f);
+					//transform->Position = glm::vec3(0.0f, -3.f, -10.f);
+
+					if (m_First) {
+						transform->Orientation = glm::quat();
+						m_First = false;
+					}
 				}
                 return;
             }
@@ -138,6 +158,12 @@ void dd::Systems::BallSystem::UpdateEntity(double dt, EntityID entity, EntityID
 				if (m_StickyCounter > 0) {
 					m_Sticky = true;
 				}
+
+				auto cAnim = m_World->GetComponent<Components::Animation>(entity);
+				cAnim->Speed = 2.f;
+				cAnim->Time = 0.f;
+				cAnim->Loop = false;
+
 				ballComponent->Sticky = false;
 			}
 		}
@@ -190,7 +216,8 @@ void dd::Systems::BallSystem::UpdateEntity(double dt, EntityID entity, EntityID
 			auto transform = m_World->GetComponent<Components::Transform>(entity);
 			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);
+			
+			float angle = atan2(dir.x, dir.y);
 			transform->Orientation = glm::rotate(glm::quat(), angle, glm::vec3(0.f, 0.f, -1.f));
 		}
     }
@@ -330,7 +357,7 @@ bool dd::Systems::BallSystem::Contact(const Events::Contact &event)
 					m_Waiting = true;
 					m_InkBlockedWaiting = true;
 					ballComponent->Sticky = true;
-					ballComponent->StickyPlacement = glm::vec3(0, 0.5f, 0);
+					ballComponent->StickyPlacement = glm::vec3(0, 0.25f, 0);
 					ballComponent->SavedSpeed = glm::normalize(glm::vec3(x, y, 0.f)) * ballComponent->Speed;
 					ballTransform->Velocity = glm::vec3(0.f, 0.f, 0.f);
 				}
@@ -340,11 +367,19 @@ bool dd::Systems::BallSystem::Contact(const Events::Contact &event)
 				m_Waiting = true;
 				ballComponent->Sticky = true;
 				//ballComponent->StickyPlacement = ballTransform->Position - padTransform->Position;
-				ballComponent->StickyPlacement = glm::vec3(0, 0.5f, 0);
+				ballComponent->StickyPlacement = glm::vec3(0, 0.25f, 0);
 				ballComponent->SavedSpeed = glm::normalize(glm::vec3(x, y, 0.f)) * ballComponent->Speed;
 				ballTransform->Velocity *= -1;
 				Events::StickyAttachedToPad e;
 				EventBroker->Publish(e);
+
+
+				auto cModel = m_World->GetComponent<Components::Model>(ballEntity);
+				cModel->ModelFile = "Models/Sid/Sid_Jump.dae";
+				auto cAnim = m_World->GetComponent<Components::Animation>(ballEntity);
+				cAnim->Loop = false;
+				cAnim->Speed = 0.f;
+				cAnim->Time = 0.f;
 				return true;
 			}
 		}
@@ -395,10 +430,7 @@ void dd::Systems::BallSystem::ResolveContacts()
 		auto ballComponent = m_World->GetComponent<Components::Ball>(entity);
 		reflectedVelocity = glm::normalize(reflectedVelocity) * ballComponent->Speed;
         transform->Velocity = glm::vec3(reflectedVelocity, 0.f);
-
     }
-
-
     m_Contacts.clear();
 }
 
@@ -439,17 +471,17 @@ bool dd::Systems::BallSystem::OnMultiBall(const dd::Events::MultiBall &event)
     ball2->Waiting = false;
     auto padTransform = event.padTransform;
     float x1 = padTransform->Position.x/* - 2*/, x2 = padTransform->Position.x/* + 2*/;
-    if (x1 < -m_EdgeX) {
+    if (x1 < -m_EdgeX + 0.4) {
-        x1 = m_EdgeX - 0.2;
+        x1 = m_EdgeX - 0.7;
     }
-    if (x2 > m_EdgeX) {
+    if (x2 > m_EdgeX - 0.4) {
-        x2 = -m_EdgeX + 0.2;
+        x2 = -m_EdgeX + 0.7;
     }
     transform1->Position = glm::vec3(x1, -5.5, -10);
     transform2->Position = glm::vec3(x2, -5.5, -10);
 
-    transform1->Velocity = glm::normalize(glm::vec3(5, 5 ,0.f)) * ball1->Speed;
+    transform1->Velocity = glm::normalize(glm::vec3(2.5, 5 ,0.f)) * ball1->Speed;
-    transform2->Velocity = glm::normalize(glm::vec3(-5, 5 ,0.f)) * ball2->Speed;
+    transform2->Velocity = glm::normalize(glm::vec3(-2.5, 5 ,0.f)) * ball2->Speed;
 
     SetMultiBalls(MultiBalls() + 2);
     //std::cout << MultiBalls() << std::endl;
@@ -474,6 +506,14 @@ bool dd::Systems::BallSystem::OnInkBlasterOver(const dd::Events::InkBlasterOver
 	auto ballComponent = m_World->GetComponent<Components::Ball>(event.Ball);
 	auto transform = m_World->GetComponent<Components::Transform>(event.Ball);
 
+
+	auto cModel = m_World->GetComponent<Components::Model>(event.Ball);
+	cModel->ModelFile = "Models/Sid/Sid_Jump.dae";
+
+	auto cAnim = m_World->GetComponent<Components::Animation>(event.Ball);
+	cAnim->Speed = 2.f;
+	cAnim->Loop = false;
+
 	m_InkBlaster = false;
 	m_InkAttached = false;
 	m_InkBlockedWaiting = false;
@@ -520,3 +560,20 @@ bool dd::Systems::BallSystem::OnArrivedToNewStage(const dd::Events::ArrivedAtNew
 	return true;
 }
 
+bool dd::Systems::BallSystem::OnAnimationComplete(const dd::Events::AnimationComplete &event)
+{
+	auto model = m_World->GetComponent<Components::Model>(event.Entity);
+	if (model) {
+		if (model->ModelFile == "Models/Sid/Sid_Jump.dae") {
+			model->ModelFile = "Models/Sid/Sid_Flying.dae";
+
+			auto anim = m_World->GetComponent<Components::Animation>(event.Entity);
+			anim->Speed = 1.f;
+			anim->Loop = true;
+			anim->Time = 0.f;
+		}
+	}
+
+	return true;
+}
+

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) {
@@ -82,12 +93,14 @@ void dd::Systems::KrakenSystem::UpdateEntity(double dt, EntityID entity, EntityI
 			return;
 		}
 		Events::KrakenAttack krakenAttack;
-		switch (kraken->CurrentAction)
+		switch (kraken->CurrentAction) {
-		{
 		case 1: // Idle
-			m_KrakenTimer += dt;
+			if (m_RandomKraken) {
-			if (m_KrakenTimer > m_KrakenSecondsToAction) {
+				m_KrakenTimer += dt;
+			}
+			if (m_KrakenTimer > m_KrakenCurrentSecondsToAction) {
 				m_KrakenTimer = 0;
+				kraken->CurrentAction = 3;
 				if (m_NumberOfActions == 0) {
 					kraken->CurrentAction = 3;
 				} else {
@@ -101,11 +114,12 @@ void dd::Systems::KrakenSystem::UpdateEntity(double dt, EntityID entity, EntityI
 			break;
 		case 2: // Grabbing
 			m_NumberOfActions++;
-			kraken->CurrentAction = 5;
+			kraken->CurrentAction = 3;
-			krakenAttack.ChargeUpdate = 0;
+			/*krakenAttack.ChargeUpdate = 0;
 			krakenAttack.KrakenStrength = 0.1;
 			krakenAttack.PlayerStrength = 0.05;
-			EventBroker->Publish(krakenAttack);
+			EventBroker->Publish(krakenAttack);*/
+			
 			break;
 		case 3: // Brick Generating
 			{
@@ -114,21 +128,60 @@ 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);
+				e.Speed = 10;
-				float random = dist(m_RandomGenerator);
+				if (m_RandomKraken) {
-				e.Set = random;
+					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;
+				} else {
+					e.Set = m_Set;
+					e.SetCluster = m_SetCluster;
+					m_Set++;
+					if (m_Set > 6) {
+						m_SetCluster++;
+						m_Set = 1;
+					}
+				}
+
 				EventBroker->Publish(e);
 				break;
 			}
 		case 4: // Brick Generating second case
 			{
+				m_NumberOfActions++;
 				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);
+				e.Speed = 10;
-				float random = dist(m_RandomGenerator);
+				if (m_RandomKraken) {
-				e.Set = random;
+					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;
+				} else {
+					e.Set = m_Set;
+					e.SetCluster = m_SetCluster;
+					m_Set++;
+					if (m_Set > 6) {
+					m_SetCluster++;
+					m_Set = 1;
+					}
+				}
+
 				EventBroker->Publish(e);
 				break;
 			}
@@ -194,15 +247,20 @@ bool dd::Systems::KrakenSystem::OnContact(const dd::Events::Contact &event)
 	
 	auto projectile = m_World->GetComponent<Components::Projectile>(otherEntitiy);
 	if (projectile != nullptr) {
-		Events::ScoreEvent es;
+		if (m_RandomKraken) {
-		es.Score = 23;
+			Events::ScoreEvent es;
-		Events::KrakenHit e;
+			es.Score = 23;
-		e.Kraken = krakenEntity;
+			EventBroker->Publish(es);
-		e.Hitter = otherEntitiy;
+			Events::KrakenHit e;
-		e.MaxHealth = kraken->MaxHealth;
+			e.Kraken = krakenEntity;
-		e.CurrentHealth = kraken->Health;
+			e.Hitter = otherEntitiy;
-		e.NewHealth = kraken->Health - 1;
+			auto transform = m_World->GetComponent<Components::Transform>(otherEntitiy);
-		EventBroker->Publish(e);
+			e.PlaceHit = transform->Position;
+			e.MaxHealth = kraken->MaxHealth;
+			e.CurrentHealth = kraken->Health;
+			e.NewHealth = kraken->Health - 1;
+			EventBroker->Publish(e);
+		}
 		m_World->RemoveEntity(otherEntitiy);
 		return true;
 	}
@@ -215,9 +273,12 @@ 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;
+		auto transform = m_World->GetComponent<Components::Transform>(otherEntitiy);
+		e.PlaceHit = transform->Position;
 		e.MaxHealth = kraken->MaxHealth;
 		e.CurrentHealth = kraken->Health;
 		e.NewHealth = kraken->Health - 1;
@@ -234,6 +295,13 @@ bool dd::Systems::KrakenSystem::OnKrakenAppear(const dd::Events::KrakenAppear &e
 	transform->Position = event.Position;
 	transform->Position.y += 3.f;
 	m_KrakenBattle = true;
+
+	Events::ScreenShake e;
+	e.Intensity = 10;
+	e.Time = 2;
+	e.TimeTakenToCoolDown = 6;
+	EventBroker->Publish(e);
+
 	return true;
 }
 
@@ -242,6 +310,13 @@ bool dd::Systems::KrakenSystem::OnKrakenAttack(const dd::Events::KrakenAttack &e
 	if (event.ChargeUpdate >= 1) {
 		m_ReturnToIdle = true;
 	}
+
+	Events::ScreenShake e;
+	e.Intensity = 2;
+	e.Time = 0.5f;
+	e.TimeTakenToCoolDown = 3.f;
+	EventBroker->Publish(e);
+
 	return true;
 }
 
@@ -249,6 +324,21 @@ bool dd::Systems::KrakenSystem::OnKrakenHit(const dd::Events::KrakenHit &event)
 {
 	auto kraken = m_World->GetComponent<Components::Kraken>(event.Kraken);
 	kraken->Health--;
+	kraken->CurrentAction = 3;
+	//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.
+
+	CreateBloodEffect(event.PlaceHit);
+
 	//std::cout << kraken->Health << std::endl;
 	//kraken->Health = -1;
 	if (kraken->Health < 0) {
@@ -257,15 +347,26 @@ bool dd::Systems::KrakenSystem::OnKrakenHit(const dd::Events::KrakenHit &event)
 		e.Hitter = event.Hitter;
 		EventBroker->Publish(e);
 	}
+
+	Events::ScreenShake e;
+	e.Intensity = 2;
+	e.Time = 0.2f;
+	e.TimeTakenToCoolDown = 1.5f;
+	EventBroker->Publish(e);
+
 	return false;
 }
 
 bool dd::Systems::KrakenSystem::OnKrakenDefeated(const dd::Events::KrakenDefeated &event)
 {
 	m_KrakenBattle = false;
+	m_Set = 0;
+	m_SetCluster = 0;
 
 	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 +393,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 +447,77 @@ 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;
+}
+
+void dd::Systems::KrakenSystem::CreateBloodEffect(glm::vec3 pos)
+{
+	//ParticlePoof
+	Events::CreateParticleSequence dust;
+	dust.EmitterLifeTime = 4;
+	dust.EmittingAngle = glm::half_pi<float>();
+	dust.Spread = 0.5f;
+	dust.NumberOfTicks = 1;
+	dust.ParticleLifeTime = 1.f;
+	dust.ParticlesPerTick = 1;
+	dust.Position = pos;
+	dust.ScaleValues.clear();
+	dust.ScaleValues.push_back(glm::vec3(0.5f));
+	dust.ScaleValues.push_back(glm::vec3(2.f, 2.f, 0.2f));
+	dust.SpriteFile = "Textures/Particles/Cloud_Particle.png";
+	dust.Color = glm::vec4(1, 0, 0, 1);
+	dust.AlphaValues.clear();
+	dust.AlphaValues.push_back(1.f);
+	dust.AlphaValues.push_back(0.f);
+	dust.Speed = 20;
+	EventBroker->Publish(dust);
+	std::uniform_real_distribution<float> dist(glm::pi<float>(), glm::two_pi<float>());
+	for (int i = 0; i < 3; i++) {
+		float angle = dist(m_RandomGenerator);
+
+		Events::CreateParticleSequence squirt;
+		squirt.EmitterLifeTime = 0.3f;
+		squirt.EmittingAngle = angle;
+		squirt.Spread = 0;
+		squirt.SpawnRate = 0.01f;
+		squirt.ParticleLifeTime = 0.5f;
+		squirt.ParticlesPerTick = 1;
+		squirt.Position = pos;
+		squirt.ScaleValues.clear();
+		squirt.ScaleValues.push_back(glm::vec3(0.09f));
+		squirt.SpriteFile = "Textures/Particles/FadeBall.png";
+		squirt.Color = glm::vec4(1, 0, 0, 1);
+		squirt.AlphaValues.clear();
+		squirt.AlphaValues.push_back(1.f);
+		squirt.AlphaValues.push_back(0.f);
+		squirt.Speed = 1000;
+		EventBroker->Publish(squirt);
+	}
+	Events::CreateParticleSequence drop;
+	drop.EmitterLifeTime = 7.f;
+	drop.SpawnRate = 0.1f;
+	//drop.EmittingAngle = glm::two_pi<float>() + glm::pi<float>();
+	drop.EmittingAngle = -glm::half_pi<float>();
+	drop.Spread = 0;
+	//drop.Spread = glm::two_pi<float>();
+	drop.ParticleLifeTime = 1.f;
+	drop.ParticlesPerTick = 2;
+	drop.Position = pos;
+	drop.ScaleValues.clear();
+	drop.ScaleValues.push_back(glm::vec3(.15f));
+	drop.ScaleValues.push_back(glm::vec3(0.1f));
+	drop.SpriteFile = "Textures/Particles/FadeBall.png";
+	drop.Color = glm::vec4(1, 0, 0, 1);
+	drop.AlphaValues.clear();
+	drop.AlphaValues.push_back(1.f);
+	drop.AlphaValues.push_back(0.f);
+	drop.GravityScale = 0;
+	drop.Speed = 300;
+	EventBroker->Publish(drop);
+}

src/game/Game/LevelSystem.cpp

@@ -23,10 +23,20 @@ void dd::Systems::LevelSystem::Initialize()
 	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_EBreakAllBricks, &LevelSystem::OnBreakAllBricks);
 	EVENT_SUBSCRIBE_MEMBER(m_EKrakenDefeated, &LevelSystem::OnKrakenDefeated);
 
 	m_GodMode = ResourceManager::Load<ConfigFile>("Config.ini")->GetValue<bool>("Cheat.GodMode", false);
 
+	// Camera
+	{
+		auto ent = m_World->CreateEntity();
+		auto transform = m_World->AddComponent<Components::Transform>(ent);
+		auto camera = m_World->AddComponent<Components::Camera>(ent);
+		camera->FOV = glm::radians(58.31f);
+		m_World->CommitEntity(ent);
+	}
+
 	//PointLightTest
 	{
 		auto t_Light = m_World->CreateEntity();
@@ -68,8 +78,20 @@ void dd::Systems::LevelSystem::Initialize()
 		auto t_halfPipe2 = m_World->CloneEntity(t_halfPipe);
 		auto transform2 = m_World->GetComponent<Components::Transform>(t_halfPipe);
 		transform2->Position = glm::vec3(0.f, 34.6f, -15.f); //Halfpipe Value
+
+		// Added to prevent white borders around screen shake
+		{
+			auto halfPipeBackground = m_World->CreateEntity();
+			auto transform = m_World->AddComponent<Components::Transform>(halfPipeBackground);
+			transform->Position = glm::vec3(0.f, 0.f, -15.f);
+			transform->Scale = glm::vec3(6.f, 6.f, 10.f) * 2.f;
+			auto model = m_World->AddComponent<Components::Model>(halfPipeBackground);
+			model->ModelFile = "Models/Halfpipe.obj";
+			m_World->CommitEntity(halfPipeBackground);
+		}
 	}
 
+
 	//Background
 
 	/*{
@@ -132,8 +154,8 @@ void dd::Systems::LevelSystem::Initialize()
 		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);
+		//std::shared_ptr<Components::Sprite> sprite = m_World->AddComponent<Components::Sprite>(BottomWall);
-		sprite->SpriteFile = "Textures/Core/ErrorTexture.png";
+		//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);
@@ -279,8 +301,20 @@ void dd::Systems::LevelSystem::UpdateEntity(double dt, EntityID entity, EntityID
 		}
 	}
 
+	if (m_BreakAllBricks) {
+		if (m_LooseBricks == 1 && m_KrakenBattle) {
+			m_BreakAllBricks = false;
+		}
+	}
+
     auto brick = m_World->GetComponent<Components::Brick>(entity);
     if (brick != nullptr) {
+		if (m_BreakAllBricks) {
+			if (!brick->Removed) {
+				brick->Removed = true;
+				BrickHit(entity, entity, 0, false);
+			}
+		}
 
 		auto transform = m_World->GetComponent<Components::Transform>(entity);
 		if (brick->BeingGenerated) {
@@ -329,6 +363,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 && !m_BreakAllBricks) {
+			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;
@@ -461,6 +505,7 @@ EntityID dd::Systems::LevelSystem::CreateBrick(int row, int line, glm::vec2 spac
 		model->ModelFile = "Models/Brick/KrakenBrick.obj";
 
 	} else if (typeInt == Kraken) {
+		m_KrakenBattle = true;
 		Events::KrakenAppear e;
 		e.Position = transform->Position;
 		e.Health = 10;
@@ -475,6 +520,7 @@ EntityID dd::Systems::LevelSystem::CreateBrick(int row, int line, glm::vec2 spac
 
 bool dd::Systems::LevelSystem::OnBrickGenerating(const dd::Events::BrickGenerating &event)
 {
+	m_BreakAllBricks = true;
 	m_BrickGenerating = true;
 	m_BrickGeneratingEvent = event;
 	return true;
@@ -482,7 +528,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;
@@ -507,7 +553,7 @@ bool dd::Systems::LevelSystem::BrickGenerating(const dd::Events::BrickGenerating
 					}
 					brick->GenerationGoal = e.GoalPosition;
 					e.Entity = ent;
-					e.Speed = 6;
+					e.Speed = event.Speed;
 					e.Queue = false;
 					EventBroker->Publish(e);
 					m_LooseBricks++;
@@ -520,7 +566,13 @@ bool dd::Systems::LevelSystem::BrickGenerating(const dd::Events::BrickGenerating
 	return true;
 }
 
-void dd::Systems::LevelSystem::GetBrickSet(int set) // These are sets the Kraken gets!
+bool dd::Systems::LevelSystem::OnBreakAllBricks(const dd::Events::BreakAllBricks &event)
+{
+	m_BreakAllBricks = true;
+	return true;
+}
+
+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,101 +604,282 @@ 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 (set == 1) {
+	if (setCluster == 0) {
-		level =
+		if (set == 1) {
-		{1, 0, 0, 0, 0, 0, 1,
+			level = // The Charge
-		 1, 0, 0, 0, 0, 0, 1,
+			{1, 0, 0, 0, 0, 0, 1,
-		 1, 0, 0, 0, 0, 0, 1,
+			 0, 1, 0, 0, 0, 1, 0,
-		 1, 1, 1, 1, 1, 1, 2,
+			 0, 0, 1, 0, 1, 0, 0,
-		 1, 1, 1, 1, 1, 1, 1,
+			 0, 0, 0, 1, 0, 0, 0,
-		 0, 0, 0, 0, 0, 0, 0};
+			 0, 0, 0, 0, 0, 0, 0,
-		color =
+			 0, 0, 0, 0, 0, 0, 0 };
-		{r, r, r, r, r, r, r,
+			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, 
+			 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) {
+		} else if (set == 2) {
-		level =
+			level = // The Audience
-		{0, 0, 0, 0, 0, 0, 0,
+			{0, 0, 0, 0, 0, 0, 0,
-		 0, 0, 0, 0, 0, 0, 0,
+			 4, 0, 0, 0, 0, 0, 1,
-		 3, 0, 1, 0, 1, 0, 1,
+			 1, 0, 0, 0, 0, 0, 1,
-		 0, 1, 0, 1, 0, 1, 0,
+			 1, 0, 0, 0, 0, 0, 1,
-		 1, 0, 1, 0, 1, 0, 1,
+			 1, 0, 0, 0, 0, 0, 6,
-		 0, 0, 0, 0, 0, 0, 0};
+			 0, 0, 0, 0, 0, 0, 0 };
-		color =
+			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,
-		 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) {
-	else if (set == 3) {
+			level = // The Alien Defense
-		level =
+			{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, 0,
-		 1, 0, 1, 0, 1, 0, 1,
+			 0, 3, 0, 0, 0, 1, 0,
-		 0, 1, 1, 1, 1, 1, 0,
+			 1, 1, 6, 0, 1, 1, 1,
-		 0, 0, 4, 1, 1, 0, 0,
+			 0, 0, 0, 0, 0, 0, 0 };
-		 0, 0, 0, 1, 0, 0, 0};
+			color =
-		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,
+			 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)
-	else if (set == 4) {
+			{1, 1, 1, 0, 0, 0, 0,
-		level =
+			 1, 1, 6, 0, 0, 0, 0,
-		{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,
-		 0, 0, 0, 0, 0, 0, 0,
+			 0, 0, 0, 0, 1, 1, 1,
-		 1, 1, 1, 1, 1, 1, 1,
+			 0, 0, 0, 0, 1, 4, 1 };
-		 0, 0, 0, 0, 0, 0, 0,
+			color =
-		 0, 0, 0, 0, 0, 0, 0};
+			{m, m, m, m, m, m, m,
-		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,
+			 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) {
-		 m, m, m, m, m, m, m};
+			level = // The Scales (left)
-	}
+			{0, 0, 0, 0, 1, 1, 1,
-	else if (set == 5) {
+			 0, 0, 0, 0, 1, 3, 1,
-		level =
+			 0, 0, 0, 0, 0, 0, 0,
-		{0, 0, 0, 0, 0, 0, 0,
+			 0, 0, 0, 0, 0, 0, 0,
-		 0, 1, 1, 0, 1, 1, 0,
+			 1, 1, 1, 0, 0, 0, 0,
-		 0, 1, 2, 0, 1, 1, 0,
+			 1, 6, 1, 0, 0, 0, 0 };
-		 0, 1, 1, 0, 1, 1, 0,
+			color =
-		 0, 1, 1, 0, 1, 1, 0,
+			{g, g, g, g, g, g, g,
-		 0, 0, 0, 0, 0, 0, 0};
+			 g, g, g, g, g, g, g,
-		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,
+			 g, g, g, g, g, g, g };
-		 g, g, g, g, g, g, g,
+		} else if (set == 6) {
-		 g, g, g, g, g, g, g, 
+			level = // The Sword
-		 g, g, g, g, g, g, g};
+			{0, 0, 0, 1, 0, 0, 0,
-	}
+			 0, 0, 6, 2, 6, 0, 0,
-	else if (set == 6) {
+			 0, 0, 0, 1, 0, 0, 0,
-		level =
+			 0, 0, 0, 1, 0, 0, 0,
-		{0, 0, 0, 0, 0, 0, 0,
+			 0, 0, 0, 1, 0, 0, 0,
-		 0, 0, 0, 0, 0, 0, 0,
+			 0, 0, 0, 1, 0, 0, 0 };
-		 0, 0, 0, 0, 0, 0, 0,
+			color =
-		 1, 1, 1, 1, 1, 1, 1,
+			{c, c, c, c, c, c, c,
-		 1, 1, 1, 1, 1, 1, 1,
+			 c, c, c, c, c, c, c,
-		 0, 0, 0, 0, 0, 0, 0};
+			 c, c, c, c, c, c, c,
-		color =
+			 c, c, c, c, c, c, c,
-		{r, r, r, r, r, r, r, 
+			 c, c, c, c, c, c, c,
-		 r, r, r, r, r, r, r,
+			 c, c, c, c, c, c, c };
-		 r, r, r, r, r, r, r,
+		}
-		 r, r, r, r, r, r, r,
+	} else if (setCluster == 1) {
-		 r, r, r, r, r, r, r, 
+		if (set == 1) {
-		 r, r, r, r, r, r, r};
+			level = // The Wall
+			{1, 0, 0, 0, 0, 0, 1,
+			 1, 0, 0, 0, 0, 0, 1,
+			 6, 0, 0, 0, 0, 0, 6,
+			 1, 1, 1, 1, 1, 1, 1,
+			 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 };
+		} else if (set == 2) {
+			level = // The Checkerboard
+			{0, 0, 0, 0, 0, 0, 0,
+			 0, 0, 0, 0, 0, 0, 0,
+			 3, 0, 1, 0, 6, 0, 1,
+			 0, 1, 0, 1, 0, 1, 0,
+			 1, 0, 1, 0, 1, 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 Fighter Jet
+			{0, 0, 0, 0, 0, 0, 0,
+			 0, 0, 0, 0, 0, 0, 0,
+			 6, 0, 1, 0, 1, 0, 6,
+			 0, 1, 1, 1, 1, 1, 0,
+			 0, 0, 5, 1, 1, 0, 0,
+			 0, 0, 0, 1, 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 Formation
+			{0, 0, 0, 0, 0, 0, 0,
+			 1, 1, 4, 1, 1, 3, 1,
+			 0, 0, 0, 0, 0, 0, 0,
+			 1, 1, 6, 1, 1, 1, 1,
+			 0, 0, 0, 0, 0, 0, 0,
+			 0, 0, 0, 0, 0, 0, 0 };
+			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 Pillars
+			{0, 0, 0, 0, 0, 0, 0,
+			 0, 1, 1, 0, 1, 1, 0,
+			 0, 6, 1, 0, 1, 6, 0,
+			 0, 1, 1, 0, 1, 1, 0,
+			 0, 1, 3, 0, 3, 1, 0,
+			 0, 0, 0, 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 Treasure Chest
+			{0, 0, 0, 1, 0, 0, 0,
+			 0, 0, 1, 1, 1, 0, 0,
+			 0, 1, 1, 2, 1, 1, 0,
+			 0, 0, 1, 6, 1, 0, 0,
+			 0, 0, 0, 1, 0, 0, 0,
+			 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
+			{4, 0, 0, 1, 0, 0, 1,
+			 1, 6, 0, 1, 0, 1, 1,
+			 1, 1, 1, 6, 1, 1, 1,
+			 1, 1, 0, 1, 0, 1, 1, 
+			 1, 0, 0, 1, 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, 6, 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, 1, 1, 0, 0,
+			 1, 0, 0, 6, 0, 0, 1,
+			 4, 1, 0, 0, 0, 1, 3,
+			 1, 1, 0, 0, 0, 1, 1,
+			 1, 0, 0, 6, 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, 6, 1, 1, 1, 1,
+			 0, 0, 0, 0, 0, 0, 0,
+			 1, 6, 1, 1, 1, 1, 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, 1, 0, 0,
+			 0, 0, 1, 1, 1, 0, 0,
+			 1, 1, 1, 0, 1, 1, 1,
+			 3, 6, 1, 0, 1, 6, 1,
+			 1, 1, 1, 0, 1, 1, 5 };
+			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, 6, 1, 1, 0,
+			 1, 1, 4, 5, 4, 1, 1,
+			 1, 1, 1, 1, 1, 1, 1,
+			 6, 0, 1, 1, 1, 0, 6,
+			 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));
@@ -715,7 +948,7 @@ bool dd::Systems::LevelSystem::OnContact(const dd::Events::Contact &event)
 		// For when a brick gets shot.
 		brick->Removed = true;
 		m_World->RemoveEntity(entityShot);
-		BrickHit(entityShot, entityBrick, 1);
+		BrickHit(entityShot, entityBrick, 1, true);
 		//ep.Radius = 0.05;
 
 		return true;
@@ -731,13 +964,13 @@ bool dd::Systems::LevelSystem::OnContact(const dd::Events::Contact &event)
 		ec.Ball = entityBall;
 		EventBroker->Publish(ec);
 
-		BrickHit(entityBall, entityBrick, ball->Combo);
+		BrickHit(entityBall, entityBrick, ball->Combo, true);
     }
 
     return true;
 }
 
-void dd::Systems::LevelSystem::BrickHit(EntityID entityHitter, EntityID entityBrick, int combo)
+void dd::Systems::LevelSystem::BrickHit(EntityID entityHitter, EntityID entityBrick, int combo, bool activatePowerUps)
 {
 	auto brick = m_World->GetComponent<Components::Brick>(entityBrick);
 	auto physicsComponent = m_World->GetComponent<Components::Physics>(entityBrick);
@@ -754,47 +987,54 @@ void dd::Systems::LevelSystem::BrickHit(EntityID entityHitter, EntityID entityBr
 	}
 
 	// Check if the brick is any kind of special.
-	auto multi = m_World->GetComponent<Components::MultiBallBrick>(entityBrick);
+	if (activatePowerUps) {
-	if (multi != nullptr) {
+		auto multi = m_World->GetComponent<Components::MultiBallBrick>(entityBrick);
-		Events::MultiBall e;
+		if (multi != nullptr) {
-		e.padTransform = transformComponentBrick;
+			Events::MultiBall e;
-		EventBroker->Publish(e);
+			e.padTransform = transformComponentBrick;
-	}
-	else {
-		auto buoy = m_World->GetComponent<Components::LifebuoyBrick>(entityBrick);
-		if (buoy != nullptr) {
-			Events::Lifebuoy e;
-			e.Transform = transformComponentBrick;
 			EventBroker->Publish(e);
 		}
 		else {
-			auto sticky = m_World->GetComponent<Components::StickyBrick>(entityBrick);
+			auto buoy = m_World->GetComponent<Components::LifebuoyBrick>(entityBrick);
-			if (sticky != nullptr) {
+			if (buoy != nullptr) {
-				Events::StickyPad e;
+				Events::Lifebuoy e;
 				e.Transform = transformComponentBrick;
-				e.Times = 3;
 				EventBroker->Publish(e);
 			}
 			else {
-				auto ink = m_World->GetComponent<Components::InkBlasterBrick>(entityBrick);
+				auto sticky = m_World->GetComponent<Components::StickyBrick>(entityBrick);
-				if (ink != nullptr) {
+				if (sticky != nullptr) {
-					Events::InkBlaster e;
+					Events::StickyPad e;
 					e.Transform = transformComponentBrick;
-					e.Shots = 5;
+					e.Times = 3;
-					e.Speed = 7;
 					EventBroker->Publish(e);
 				}
 				else {
-					auto kraken = m_World->GetComponent<Components::KrakenAttackBrick>(entityBrick);
+					auto ink = m_World->GetComponent<Components::InkBlasterBrick>(entityBrick);
-					if (kraken != nullptr) {
+					if (ink != nullptr) {
-						Events::KrakenAttack e;
+						Events::InkBlaster e;
-						e.ChargeUpdate = 0;
+						e.Transform = transformComponentBrick;
-						e.KrakenStrength = 0.1;
+						e.Shots = 5;
-						e.PlayerStrength = 0.05;
+						e.Speed = 7;
 						EventBroker->Publish(e);
 					}
 					else {
+						auto kraken = m_World->GetComponent<Components::KrakenAttackBrick>(entityBrick);
+						if (kraken != nullptr) {
+							Events::KrakenAttack e;
+							e.ChargeUpdate = 0;
+							if (m_KrakenBattle) {
+								e.KrakenStrength = 0.1;
+								e.PlayerStrength = 0.12;
+							} else {
+								e.KrakenStrength = 0.1;
+								e.PlayerStrength = 0.05;
+							}
+							EventBroker->Publish(e);
+						}
+						else {
 
+						}
 					}
 				}
 			}
@@ -931,11 +1171,17 @@ bool dd::Systems::LevelSystem::OnPowerUpTaken(const dd::Events::PowerUpTaken &ev
 
 bool dd::Systems::LevelSystem::OnKrakenDefeated(const dd::Events::KrakenDefeated &event)
 {
+	m_KrakenBattle = false;
 	m_BrickGenerating = false;
+	m_BreakAllBricks = true;
 	SetNumberOfBricks(NumberOfBricks() - 1);
 	m_LooseBricks--;
 
-	std::cout << m_LooseBricks << std::endl;
+	Events::ScoreEvent e;
+	e.Score = 1000;
+	EventBroker->Publish(e);
+
+	//std::cout << m_LooseBricks << std::endl;
 
 	return true;
 }
@@ -943,6 +1189,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;
@@ -1026,7 +1273,7 @@ void dd::Systems::LevelSystem::GetNextLevel()
             level =
                     {0, 0, 0, 0, 0, 0, 0,
                      0, 0, 0, 0, 0, 0, 0,
-                     0, 0, 0, 0, 0, 0, 0,
+                     2, 2, 2, 2, 2, 2, 2,
                      0, 0, 0, 0, 0, 0, 0,
                      0, 0, 0, 0, 0, 0, 0,
                      0, 0, 0, 0, 0, 0, 1};
@@ -1041,10 +1288,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 +1464,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,28 +52,89 @@ void dd::Systems::LifeSystem::UpdateEntity(double dt, EntityID entity, EntityID
 	
 	if (life != nullptr) {
 		auto transform = m_World->GetComponent<Components::Transform>(entity);
-		if (life->Left) {
+		if (transform->Position.y < -8) {
-			if (transform->Position.x > 3) {
+			m_World->RemoveEntity(entity);
-				life->Left = false;
+			return;
-				transform->Velocity.x = m_LifeSpeed;
-			}
-		} else {
-			
-			if (transform->Position.x < -3) {
-				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));
+		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));*/
+		transform->Orientation = glm::rotate(glm::quat(), angle, glm::vec3(0.f, 0.f, -1.f));
-		if (Lives() != PastLives()) {
+
-			if (life->Number + 1 == PastLives()) {
+		if (!life->Dead) {
-				m_World->RemoveEntity(entity);
+			if (life->Left) {
-				SetPastLives(Lives());
+				if (transform->Position.x < -3.8) {
+					life->Left = false;
+					transform->Velocity.x = m_LifeSpeed;
+				}
 			}
+			else {
+				if (transform->Position.x > 3.8) {
+					life->Left = true;
+					transform->Velocity.x = -m_LifeSpeed;
+				}
+			}
+
+			float sin = life->SinusAltitude;
+			life->SinusAltitude += life->SinusSpeed * dt;
+			float y = glm::sin((sin)* glm::half_pi<float>() * life->Frequency) * life->Amplitude;
+			transform->Velocity.y = y;
+
+			if (Lives() != PastLives()) {
+				if (life->Number + 1 == PastLives()) {
+					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/LifebuoySystem.cpp

@@ -44,11 +44,16 @@ void dd::Systems::LifebuoySystem::Initialize()
 
 void dd::Systems::LifebuoySystem::Update(double dt)
 {
-	for (auto it = m_Lifebuoys.begin(); it != m_Lifebuoys.end();) {
+	/*for (auto it = m_Lifebuoys.begin(); it != m_Lifebuoys.end();) { //Niklas note: Jag fortstatte få fel efter ni gick hem, och jag förstod inte det här så jag gjorde om som jag visste hur i UpdateEntity.
 		
 		auto transformComponent = m_World->GetComponent<Components::Transform>(it->Entity);
 		auto lifebuoyComponent = m_World->GetComponent<Components::Lifebuoy>(it->Entity);
 
+		if (!m_World->ValidEntity(it->Entity)){
+			m_Lifebuoys.erase(it++);
+		}
+
+
 		if (transformComponent->Position.y < m_DownEdge) {
 			m_World->RemoveEntity(it->Entity);
 			m_Lifebuoys.erase(it++);
@@ -75,6 +80,19 @@ void dd::Systems::LifebuoySystem::Update(double dt)
 
 			++it;
 		}
+	}*/
+
+	if (IsPaused()) {
+		return;
+	}
+	
+	if (m_Lifebuoy) {
+		m_Timer += dt;
+		if (m_Timer > m_WaitingTime) {
+			m_Timer = 0;
+			m_Lifebuoy = false;
+			Lifebuoy(m_SavedEvent);
+		}
 	}
 }
 
@@ -85,6 +103,38 @@ void dd::Systems::LifebuoySystem::UpdateEntity(double dt, EntityID entity, Entit
     }
     auto templateCheck = m_World->GetComponent<Components::Template>(entity);
     if (templateCheck != nullptr){ return; }
+
+	auto lifebuoyComponent = m_World->GetComponent<Components::Lifebuoy>(entity);
+
+	if (lifebuoyComponent != nullptr) {
+		auto transformComponent = m_World->GetComponent<Components::Transform>(entity);
+
+		if (transformComponent->Position.y < m_DownEdge) {
+			m_World->RemoveEntity(entity);
+			//m_Lifebuoys.erase(it++);
+		}
+		else {
+
+			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);
+			}
+
+			if (lifebuoyComponent->Hits <= 0) {
+				auto physicsComponent = m_World->GetComponent<Components::Physics>(entity);
+				physicsComponent->Mask = CollisionLayer::Type::LifeBuoy;
+				physicsComponent->GravityScale = 10.f;
+				auto modelComponent = m_World->GetComponent<Components::Model>(entity);
+				modelComponent->Color = glm::vec4(0.5f, 0.5f, 0.5f, 0.f);
+			}
+
+			if (transformComponent->Position.y < m_DownLimit && lifebuoyComponent->Hits > 0) {
+				transformComponent->Position.y = m_DownLimit;
+			}
+		}
+	}
 }
 
 bool dd::Systems::LifebuoySystem::OnPause(const dd::Events::Pause &event)
@@ -114,6 +164,13 @@ bool dd::Systems::LifebuoySystem::OnContact(const dd::Events::Contact &event)
 }
 
 bool dd::Systems::LifebuoySystem::OnLifebuoy(const dd::Events::Lifebuoy &event)
+{
+	m_Lifebuoy = true;
+	m_SavedEvent = event;
+	return true;
+}
+
+bool dd::Systems::LifebuoySystem::Lifebuoy(const dd::Events::Lifebuoy &event) 
 {
 	auto ent = m_World->CloneEntity(m_Template);
 	m_World->SetProperty(ent, "Name", "Lifebuoy");
@@ -121,7 +178,8 @@ bool dd::Systems::LifebuoySystem::OnLifebuoy(const dd::Events::Lifebuoy &event)
 	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(0.f, 0.f, -10.f);
+	//transform->Position = glm::vec3(0.f, 0.f, -10.f);
+	transform->Position = event.Transform->Position;
 	transform->Velocity = glm::vec3(20.f, 3.f, 0.f);
 	LifebuoyInfo info;
 	info.Entity = ent;
@@ -134,28 +192,30 @@ bool dd::Systems::LifebuoySystem::OnLifebuoyHit(const dd::Events::LifebuoyHit &e
 {
 	auto transformComponent = m_World->GetComponent<Components::Transform>(event.Lifebuoy);
 	auto lifebuoyComponent = m_World->GetComponent<Components::Lifebuoy>(event.Lifebuoy);
-	lifebuoyComponent->Hits -= 1;
+	if (lifebuoyComponent != nullptr) {
-	auto modelComponent = m_World->GetComponent<Components::Model>(event.Lifebuoy);
+		lifebuoyComponent->Hits -= 1;
-	modelComponent->ModelFile = "Models/Lifebuoy/Lifebuoy" + std::to_string(5 - lifebuoyComponent->Hits) + ".obj";
+		auto modelComponent = m_World->GetComponent<Components::Model>(event.Lifebuoy);
+		modelComponent->ModelFile = "Models/Lifebuoy/Lifebuoy" + std::to_string(5 - lifebuoyComponent->Hits) + ".obj";
 
-	Events::CreateParticleSequence e;
+		Events::CreateParticleSequence e;
-	e.EmitterLifeTime = 4;
+		e.EmitterLifeTime = 4;
-	e.EmittingAngle = glm::half_pi<float>();
+		e.EmittingAngle = glm::half_pi<float>();
-	e.Spread = 0.5f;
+		e.Spread = 0.5f;
-	e.NumberOfTicks = 1;
+		e.NumberOfTicks = 1;
-	e.ParticleLifeTime = 2.f;
+		e.ParticleLifeTime = 2.f;
-	e.ParticlesPerTick = 1;
+		e.ParticlesPerTick = 1;
-	e.Position = transformComponent->Position;
+		e.Position = transformComponent->Position;
-	e.ScaleValues.clear();
+		e.ScaleValues.clear();
-	e.ScaleValues.push_back(glm::vec3(0.5f));
+		e.ScaleValues.push_back(glm::vec3(0.5f));
-	e.ScaleValues.push_back(glm::vec3(2.f, 2.f, 0.2f));
+		e.ScaleValues.push_back(glm::vec3(2.f, 2.f, 0.2f));
-	e.SpriteFile = "Textures/Particles/Cloud_Particle.png";
+		e.SpriteFile = "Textures/Particles/Cloud_Particle.png";
-	e.Color = glm::vec4(1, 0, 0, 1);
+		e.Color = glm::vec4(1, 0, 0, 1);
-	e.AlphaValues.clear();
+		e.AlphaValues.clear();
-	e.AlphaValues.push_back(1.f);
+		e.AlphaValues.push_back(1.f);
-	e.AlphaValues.push_back(0.f);
+		e.AlphaValues.push_back(0.f);
-	e.Speed = 10.f;
+		e.Speed = 10.f;
-	EventBroker->Publish(e);
+		EventBroker->Publish(e);
+	}
 
 	return true;
 }

src/game/Game/PadSystem.cpp

@@ -56,9 +56,14 @@ void dd::Systems::PadSystem::Initialize()
         cModel->ModelFile = "Models/Ship/Ship.obj";
 
         auto pad = m_World->AddComponent<Components::Pad>(ent);
+		pad->SlowdownModifier = 10.f;
         m_World->CommitEntity(ent);
 
         m_Edge = 3.2 - (ctransform->Scale.x / 2);
+		
+		m_PadEntity = ent;
+		m_PadTransform = ctransform.get();
+		m_PadComponent = pad.get();
     }
 
 	//Stick
@@ -77,18 +82,31 @@ void dd::Systems::PadSystem::Initialize()
 		m_StickTransform = transform;
 		m_StickyAim = sticky;
 
-		/*{
+			/*{
-			auto entChild = m_World->CreateEntity(ent);
+		auto entChild = m_World->CreateEntity(ent);
-			std::shared_ptr<Components::Transform> transform = m_World->AddComponent<Components::Transform>(entChild);
+		std::shared_ptr<Components::Transform> transform = m_World->AddComponent<Components::Transform>(entChild);
-			transform->Position = glm::vec3(0.f, 12.5f, 0.f);
+		transform->Position = glm::vec3(0.f, 12.5f, 0.f);
 
-			transform->Scale = glm::vec3(0.1f, 25.f, 0.1f);
+		transform->Scale = glm::vec3(0.1f, 25.f, 0.1f);
-			std::shared_ptr<Components::Sprite> sprite = m_World->AddComponent<Components::Sprite>(entChild);
+		std::shared_ptr<Components::Sprite> sprite = m_World->AddComponent<Components::Sprite>(entChild);
-			sprite->SpriteFile = "Models/Brick/White.png";
+		sprite->SpriteFile = "Models/Brick/White.png";
-			sprite->Color = glm::vec4(0.f, 0.5f, 0.f, 0.5f);
+		sprite->Color = glm::vec4(0.f, 0.5f, 0.f, 0.5f);
 		}*/
 	}
 
+	// Kraken arm
+	{
+		m_KrakenArm = m_World->CreateEntity(m_PadEntity);
+		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 = 0.0f;
+		animation->Loop = false;
+		m_World->CommitEntity(m_KrakenArm);
+	}
+
 	m_ResetBall = true;
 }
 
@@ -106,20 +124,25 @@ void dd::Systems::PadSystem::UpdateEntity(double dt, EntityID entity, EntityID p
 		if (ball->Waiting || ball->Sticky) {
 			if (m_ResetBall && ball->Waiting) {
 				ball->StickyPlacement = glm::vec3(0.f, 0.f, 0.f);
-				ball->StickyPlacement.y += 0.45f;
+				ball->StickyPlacement.y += 0.25f;
 				m_ResetBall = false;
 			}
 			auto ballTransform = m_World->GetComponent<Components::Transform>(entity);
 			ballTransform->Position = m_PadTransform->Position;
 			ballTransform->Position += ball->StickyPlacement;
-			glm::vec2 dir = glm::normalize(glm::vec2(ball->SavedSpeed.x, ball->SavedSpeed.y));
+			if (ball->Loaded) {
-			glm::vec2 up = glm::vec2(0.f, 1.f);
+				ballTransform->Orientation = glm::quat();
-			float angle = glm::acos(glm::dot<float>(dir, up)) * glm::sign(dir.x);
+			} else {
-			ballTransform->Orientation = glm::rotate(glm::quat(), angle, glm::vec3(0.f, 0.f, -1.f));
+				glm::vec2 dir = glm::normalize(glm::vec2(ball->SavedSpeed.x, ball->SavedSpeed.y));
-			if (ball->Sticky) {
+				glm::vec2 up = glm::vec2(0.f, 1.f);
-				m_StickTransform->Orientation = glm::rotate(glm::quat(), angle, glm::vec3(0.f, 0.f, 1.f));
+				float angle = glm::acos(glm::dot<float>(dir, up)) * glm::sign(dir.x);
-				m_StickTransform->Position = ballTransform->Position;
+				ballTransform->Orientation = glm::rotate(glm::quat(), angle, glm::vec3(0.f, 0.f, -1.f));
+				if (ball->Sticky) {
+					m_StickTransform->Orientation = glm::rotate(glm::quat(), angle, glm::vec3(0.f, 0.f, 1.f));
+					m_StickTransform->Position = ballTransform->Position;
+				}
 			}
+			
 		}
 		if (!m_StickyAim->Aiming) {
 			m_StickTransform->Position = glm::vec3(30.f, 0.f, 0.f);
@@ -133,17 +156,6 @@ void dd::Systems::PadSystem::Update(double dt)
         return;
     }
 
-    if (m_PadEntity == 0) {
-        for (auto it = m_World->GetEntities()->begin(); it != m_World->GetEntities()->end(); it++) {
-            if (m_World->GetProperty<std::string>(it->first, "Name") == "Pad") {
-                m_PadEntity = it->first;
-                m_PadTransform = m_World->GetComponent<Components::Transform>(m_PadEntity);
-                m_PadComponent = m_World->GetComponent<Components::Pad>(m_PadEntity);
-                break;
-            }
-        }
-    }
-
 	if (m_KrakenAttack) {
 		m_KrakenCharge -= m_KrakenStrength * dt;
 		if (m_KrakenCharge < 0) {
@@ -281,6 +293,10 @@ bool dd::Systems::PadSystem::OnKeyDown(const dd::Events::KeyDown &event) {
 		e.Origin1 = glm::vec3(-5, 7, -10);
 		e.Origin2 = glm::vec3(5, 7, -10);
 		e.Set = 1;
+		e.SetCluster = 1;
+		EventBroker->Publish(e);
+	} else if (val == GLFW_KEY_C) {
+		Events::BreakAllBricks e;
 		EventBroker->Publish(e);
 	} else if (val == GLFW_KEY_L) {
 		Events::Lifebuoy e;
@@ -476,18 +492,10 @@ bool dd::Systems::PadSystem::OnKrakenAttack(const dd::Events::KrakenAttack &even
 
 		transform->Velocity = glm::vec3(0, 0, 0);
 		acceleration = glm::vec3(0, 0, 0);
-		LOG_INFO("Kraken arm duuude");
+		if (m_KrakenArmHitbox == 0) {
-		if (!m_KrakenArm){
+			auto animation = m_World->GetComponent<Components::Animation>(m_KrakenArm);
-			LOG_INFO("InKrakenArmDuuude");
+			animation->Time = 0.0;
-			m_KrakenArm = m_World->CreateEntity(m_PadEntity);
+			animation->Speed = 1.0;
-			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;
-			animation->Loop = false;
-			m_World->CommitEntity(m_KrakenArm);
 
 			m_KrakenArmHitbox = m_World->CreateEntity();
 			auto hb_transform = m_World->AddComponent<Components::Transform>(m_KrakenArmHitbox);
@@ -525,10 +533,14 @@ bool dd::Systems::PadSystem::OnKrakenAttackEnd(const dd::Events::KrakenAttackEnd
 	m_KrakenStrength = 0;
 	m_PlayerStrength = 0;
 
-		m_World->RemoveEntity(m_KrakenArm);
+		//m_World->RemoveEntity(m_KrakenArm);
-		m_World->RemoveEntity(m_KrakenArmHitbox);
+
-		m_KrakenArm = NULL;
+	auto animation = m_World->GetComponent<Components::Animation>(m_KrakenArm);
-		m_KrakenArmHitbox = NULL;
+	animation->Time = 0.0;
+	animation->Speed = -1.5;
+	m_World->RemoveEntity(m_KrakenArmHitbox);
+	//m_KrakenArm = NULL;
+	m_KrakenArmHitbox = 0;
 		
 	return true;
 }

src/game/Game/ProjectileSystem.cpp

@@ -108,9 +108,20 @@ bool dd::Systems::ProjectileSystem::OnInkBlaster(const dd::Events::InkBlaster &e
 
 bool dd::Systems::ProjectileSystem::OnHitPad(const dd::Events::HitPad &event)
 {
-	if (m_InkBlaster) {
+	if (m_InkBlaster && m_AttachedSquid == 0) {
+		auto ball = m_World->GetComponent<Components::Ball>(event.Ball);
+		ball->Loaded = true;
 		m_SquidLoaded = true;
 		m_AttachedSquid = event.Ball;
+
+
+		auto model = m_World->GetComponent<Components::Model>(m_AttachedSquid);
+		model->ModelFile = "Models/Sid/Sid_Shoot.dae";
+		
+		auto anim = m_World->GetComponent<Components::Animation>(m_AttachedSquid);
+		anim->Loop = false;
+		anim->Speed = 0.f;
+		anim->Time = 0.f;
 	}
 	return true;
 }
@@ -140,18 +151,33 @@ bool dd::Systems::ProjectileSystem::OnActionButton(const dd::Events::ActionButto
 			transform->Velocity = glm::vec3(0, projectile->Speed, 0);
 			m_Shots--;
 
+			auto anim = m_World->GetComponent<Components::Animation>(m_AttachedSquid);
+			anim->Loop = false;
+			anim->Speed = 2.f;
+			anim->Time = 0.f;
+
 			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->Loaded = false;
 				ball->Waiting = true;
 
 				{
 					Events::InkBlasterOver e;
 					e.Ball = m_AttachedSquid;
+					
 					EventBroker->Publish(e);
+
+					auto model = m_World->GetComponent<Components::Model>(m_AttachedSquid);
+					model->ModelFile = "Models/Sid/Sid_Flying.dae";
+
+					auto anim = m_World->GetComponent<Components::Animation>(m_AttachedSquid);
+					anim->Loop = true;
+					anim->Speed = 1.f;
+					m_AttachedSquid = 0;
 				}
 			{
 				Events::ActionButton e;

src/game/Game/ScreenShakeSystem.cpp

@@ -5,6 +5,7 @@
 #include "PrecompiledHeader.h"
 #include "Game/ScreenShakeSystem.h"
 
+
 void dd::Systems::ScreenShakeSystem::Initialize()
 {
 	std::random_device rd;
@@ -36,7 +37,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 +74,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)

src/game/Game/WaterSystem.cpp

@@ -57,7 +57,7 @@ void dd::Systems::WaterSystem::UpdateEntity(double dt, EntityID entity, EntityID
 				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;
+					//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;

src/game/Physics/PhysicsSystem.cpp

@@ -592,7 +592,7 @@ void dd::Systems::PhysicsSystem::UpdateParticleEmitters(double dt)
 	
 			
 			//Random z-value
-            std::uniform_real_distribution<float> dist(0, 1);
+            std::uniform_real_distribution<float> dist(0, 0.1);
             float zDistribution = dist(gen);
 			particleTransform->Position = glm::vec3(emitterTransform->Position.x, emitterTransform->Position.y, -9.5f + zDistribution);
 			particleTransform->Scale = particleTemplate->Scale;
@@ -730,6 +730,7 @@ bool dd::Systems::PhysicsSystem::CreateParticleSequence(const Events::CreatePart
 	particleEmitter->RadiusDistribution = event.RadiusDistribution;
 	particleEmitter->DefaultScale = event.DefaultScale;
 	particleEmitter->ScaleValues = event.ScaleValues;
+	particleEmitter->VelocityValues = event.VelocityValues;
 	{
 		//Creating Particle Template
 		auto particle = m_World->CreateEntity(emitter);

src/game/Rendering/AnimationSystem.cpp

@@ -35,17 +35,17 @@ void dd::Systems::AnimationSystem::Update(double dt)
 
 		if (animationComponent->Speed != 0.0) {
 			double nextTime = animationComponent->Time + animationComponent->Speed * dt;
-			if (glm::abs(nextTime) > animation->Duration) {
+			if (!animationComponent->Loop && glm::abs(nextTime) > animation->Duration) {
-				if (!animationComponent->Loop) {
+				animationComponent->Time = glm::sign(nextTime) * animation->Duration;
-					animationComponent->Time = glm::sign(nextTime) * animation->Duration;
+				animationComponent->Speed = 0.0;
-					animationComponent->Speed = 0.0;
+				LOG_DEBUG("Animation \"%s\" on Entity %i finished.", animationComponent->Name.c_str(), ent);
-					LOG_DEBUG("Animation \"%s\" on Entity %i finished.", animationComponent->Name.c_str(), ent);
+				Events::AnimationComplete e;
-					Events::AnimationComplete e;
+				e.Entity = ent;
-					e.Entity = ent;
+				e.Animation = animationComponent->Name;
-					e.Animation = animationComponent->Name;
+					EventBroker->Publish(e);
-				}
+			} else {
+				animationComponent->Time = nextTime;
 			}
-			animationComponent->Time = nextTime;
 		}
 	}
 }

src/game/Rendering/OpenGL/Renderer.cpp

@@ -63,7 +63,7 @@ void dd::Renderer::Initialize()
 	}
 
 	// Create default camera
-	m_DefaultCamera = std::unique_ptr<dd::Camera>(new dd::Camera((float)m_Resolution.Width / m_Resolution.Height, 45.f, 0.01f, 5000.f));
+	m_DefaultCamera = std::unique_ptr<dd::Camera>(new dd::Camera((float)m_Resolution.Width / m_Resolution.Height, glm::radians(45.f), 0.01f, 5000.f));
 	m_DefaultCamera->SetPosition(glm::vec3(0, 0, 0));
 	if (m_Camera == nullptr) {
 		m_Camera = m_DefaultCamera.get();
@@ -391,11 +391,6 @@ void dd::Renderer::DrawForward(RenderQueue &objects, RenderQueue &lights)
 	DrawWater(objects);
 }
 
-void dd::Renderer::PlaceCamera(glm::vec3 position)
-{
-	m_DefaultCamera->SetPosition(position);
-}
-
 void dd::Renderer::DrawScene(RenderQueue &objects, ShaderProgram &program)
 {
 	GLuint shaderProgramHandle = program;

src/game/Rendering/Skeleton.cpp

@@ -69,7 +69,7 @@ std::vector<glm::mat4> dd::Skeleton::GetFrameBones(const Animation& animation, d
 	int currentKeyframeIndex = GetKeyframe(animation, time);
 
 	const Animation::Keyframe& currentFrame = animation.Keyframes[currentKeyframeIndex];
-	const Animation::Keyframe& nextFrame = animation.Keyframes[currentKeyframeIndex + 1];
+	const Animation::Keyframe&	nextFrame = animation.Keyframes[(currentKeyframeIndex + 1) % animation.Keyframes.size()];
 	float alpha = (time - currentFrame.Time) / (nextFrame.Time - currentFrame.Time);
 
 	//auto animationFrame = Animations[""].Keyframes[frame];
@@ -149,7 +149,7 @@ int dd::Skeleton::GetKeyframe(const Animation& animation, double time)
 {
 	if (time < 0)
 		time = 0;
-	if (time > animation.Duration)
+	if (time >= animation.Duration)
 		return animation.Keyframes.size() - 1;
 
 	for (int keyframe = 0; keyframe < animation.Keyframes.size(); ++keyframe) {