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

include/Core/Engine.h

@@ -37,6 +37,7 @@
 #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 +68,7 @@
 
 #include "Game/BrickComponents.h"
 
+#include "Game/ScreenShakeSystem.h"
 #include "Game/EScreenShake.h"
 
 #include "Physics/PhysicsSystem.h"
@@ -147,6 +149,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>();
@@ -209,6 +212,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>();
@@ -271,8 +277,6 @@ public:
 			TEMPAddToRenderQueue();
 		}
 
-		std::unique_ptr<dd::Camera> defaultCamera = nullptr;
-
 		// Render scene
 		//TODO send renderqueue to draw.
 		m_Renderer->Draw(m_RendererQueue);
@@ -292,6 +296,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())
 		{

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
 {
@@ -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,7 +15,7 @@ namespace Components
 
 struct Kraken : Component {
 
-    int MaxHealth = 30;
+    int MaxHealth = 18;
 	int Health = MaxHealth;
 	int CurrentAction = 3;
 	float RetreatSpeed = 0.2;

include/Game/EBrickGenerating.h

@@ -20,6 +20,7 @@ struct BrickGenerating : Event
 	int TargetLine;
 	int Set;
 	int SetCluster;
+	int Speed = 6;
 };
 
 }

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/KrakenSystem.h

@@ -33,6 +33,7 @@
 #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"
@@ -67,6 +68,7 @@ private:
 	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;
@@ -76,6 +78,9 @@ private:
 	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;
 

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,7 @@ 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;
@@ -194,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);
@@ -209,6 +213,7 @@ private:
     bool OnHitPad(const dd::Events::HitPad &event);
 	bool OnBrickGenerating(const dd::Events::BrickGenerating &event);
 	bool BrickGenerating(const dd::Events::BrickGenerating &event);
+	bool OnBreakAllBricks(const dd::Events::BreakAllBricks &event);
 	void GetBrickSet(int Set, int SetCluster);
 	bool OnKrakenDefeated(const dd::Events::KrakenDefeated &event);
 

include/Game/PadSystem.h

@@ -54,6 +54,7 @@
 #include "Rendering/CAnimation.h"
 
 #include "Game/EBrickGenerating.h"
+#include "Game/EBreakAllBricks.h"
 
 
 namespace dd

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/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/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;
 			}
 		}
@@ -330,7 +356,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 +366,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 +429,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();
 }
 
@@ -474,6 +505,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 +559,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

@@ -93,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) {
+				m_KrakenTimer += dt;
+			}
 			if (m_KrakenTimer > m_KrakenCurrentSecondsToAction) {
 				m_KrakenTimer = 0;
+				kraken->CurrentAction = 3;
 				if (m_NumberOfActions == 0) {
 					kraken->CurrentAction = 3;
 				} else {
@@ -112,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
 			{
@@ -125,35 +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);
-				if (kraken->Health > 20) {
+				e.Speed = 10;
+				if (m_RandomKraken) {
+					if (kraken->Health > 20) {
 					e.SetCluster = 0;
-				} else if (kraken->Health > 10) {
+					} else if (kraken->Health > 10) {
 					e.SetCluster = 1;
-				} else {
+					} 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;
+					}
 				}
-				std::uniform_real_distribution<float> dist(1, 6.999f);
+
-				float random = dist(m_RandomGenerator);
-				e.Set = random;
 				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);
-				if (kraken->Health > 20) {
+				e.Speed = 10;
-					e.SetCluster = 0;
+				if (m_RandomKraken) {
-				} else if (kraken->Health > 10) {
+					if (kraken->Health > 20) {
-					e.SetCluster = 1;
+						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.SetCluster = 2;
+					e.Set = m_Set;
+					e.SetCluster = m_SetCluster;
+					m_Set++;
+					if (m_Set > 6) {
+					m_SetCluster++;
+					m_Set = 1;
+					}
 				}
-				std::uniform_real_distribution<float> dist(1, 6.999f);
+
-				float random = dist(m_RandomGenerator);
-				e.Set = random;
 				EventBroker->Publish(e);
 				break;
 			}
@@ -261,6 +289,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;
 }
 
@@ -269,6 +304,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;
 }
 
@@ -277,6 +319,7 @@ 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->CurrentAction = 3;
 	//kraken->Health -= 15;
 	//kraken->Health = -1; //To defeat the kraken instantly.
 
@@ -299,12 +342,21 @@ 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);

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,12 +301,18 @@ 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, 1);
+				BrickHit(entity, entity, 0, false);
 			}
 		}
 
@@ -336,7 +364,7 @@ void dd::Systems::LevelSystem::UpdateEntity(double dt, EntityID entity, EntityID
     auto ball = m_World->GetComponent<Components::Ball>(entity);
 
 	if (ball != nullptr) {
-		if (m_BrickGenerating) {
+		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;
@@ -477,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;
@@ -491,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;
@@ -523,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++;
@@ -536,6 +566,12 @@ bool dd::Systems::LevelSystem::BrickGenerating(const dd::Events::BrickGenerating
 	return true;
 }
 
+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;
@@ -587,10 +623,10 @@ void dd::Systems::LevelSystem::GetBrickSet(int set, int setCluster) // These are
 		} else if (set == 2) {
 			level = // The Audience
 			{0, 0, 0, 0, 0, 0, 0,
+			 4, 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,
+			 1, 0, 0, 0, 0, 0, 6,
-			 1, 0, 0, 0, 0, 0, 1,
 			 0, 0, 0, 0, 0, 0, 0 };
 			color =
 			{y, y, y, y, y, y, y,
@@ -604,8 +640,8 @@ void dd::Systems::LevelSystem::GetBrickSet(int set, int setCluster) // These are
 			{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,
+			 0, 3, 0, 0, 0, 1, 0,
-			 1, 1, 1, 0, 1, 1, 1,
+			 1, 1, 6, 0, 1, 1, 1,
 			 0, 0, 0, 0, 0, 0, 0 };
 			color =
 			{b, b, b, b, b, b, b,
@@ -617,11 +653,11 @@ void dd::Systems::LevelSystem::GetBrickSet(int set, int setCluster) // These are
 		} else if (set == 4) {
 			level = // The Scales (right)
 			{1, 1, 1, 0, 0, 0, 0,
-			 1, 1, 1, 0, 0, 0, 0,
+			 1, 1, 6, 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 };
+			 0, 0, 0, 0, 1, 4, 1 };
 			color =
 			{m, m, m, m, m, m, m,
 			 m, m, m, m, m, m, m,
@@ -632,11 +668,11 @@ void dd::Systems::LevelSystem::GetBrickSet(int set, int setCluster) // These are
 		} 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, 1, 3, 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 };
+			 1, 6, 1, 0, 0, 0, 0 };
 			color =
 			{g, g, g, g, g, g, g,
 			 g, g, g, g, g, g, g,
@@ -647,7 +683,7 @@ void dd::Systems::LevelSystem::GetBrickSet(int set, int setCluster) // These are
 		} else if (set == 6) {
 			level = // The Sword
 			{0, 0, 0, 1, 0, 0, 0,
-			 0, 0, 1, 1, 1, 0, 0,
+			 0, 0, 6, 2, 6, 0, 0,
 			 0, 0, 0, 1, 0, 0, 0,
 			 0, 0, 0, 1, 0, 0, 0,
 			 0, 0, 0, 1, 0, 0, 0,
@@ -665,8 +701,8 @@ void dd::Systems::LevelSystem::GetBrickSet(int set, int setCluster) // These are
 			level = // The Wall
 			{1, 0, 0, 0, 0, 0, 1,
 			 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, 2,
+			 1, 1, 1, 1, 1, 1, 1,
 			 1, 1, 1, 1, 1, 1, 1,
 			 0, 0, 0, 0, 0, 0, 0 };
 			color =
@@ -680,7 +716,7 @@ void dd::Systems::LevelSystem::GetBrickSet(int set, int setCluster) // These are
 			level = // The Checkerboard
 			{0, 0, 0, 0, 0, 0, 0,
 			 0, 0, 0, 0, 0, 0, 0,
-			 3, 0, 1, 0, 1, 0, 1,
+			 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 };
@@ -695,7 +731,7 @@ void dd::Systems::LevelSystem::GetBrickSet(int set, int setCluster) // These are
 			level = // The Fighter Jet
 			{0, 0, 0, 0, 0, 0, 0,
 			 0, 0, 0, 0, 0, 0, 0,
-			 1, 0, 1, 0, 1, 0, 1,
+			 6, 0, 1, 0, 1, 0, 6,
 			 0, 1, 1, 1, 1, 1, 0,
 			 0, 0, 4, 1, 1, 0, 0,
 			 0, 0, 0, 1, 0, 0, 0 };
@@ -709,9 +745,9 @@ void dd::Systems::LevelSystem::GetBrickSet(int set, int setCluster) // These are
 		} else if (set == 4) {
 			level = // The Formation
 			{0, 0, 0, 0, 0, 0, 0,
-			 1, 1, 1, 1, 1, 3, 1,
+			 1, 1, 4, 1, 1, 3, 1,
 			 0, 0, 0, 0, 0, 0, 0,
-			 1, 1, 1, 1, 1, 1, 1,
+			 1, 1, 6, 1, 1, 1, 1,
 			 0, 0, 0, 0, 0, 0, 0,
 			 0, 0, 0, 0, 0, 0, 0 };
 			color = 
@@ -725,9 +761,9 @@ void dd::Systems::LevelSystem::GetBrickSet(int set, int setCluster) // These are
 			level = // The Pillars
 			{0, 0, 0, 0, 0, 0, 0,
 			 0, 1, 1, 0, 1, 1, 0,
-			 0, 1, 2, 0, 1, 1, 0,
+			 0, 6, 1, 0, 1, 6, 0,
-			 0, 1, 1, 0, 1, 1, 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,
@@ -740,8 +776,8 @@ void dd::Systems::LevelSystem::GetBrickSet(int set, int setCluster) // These are
 			level = // The Treasure Chest
 			{0, 0, 0, 1, 0, 0, 0,
 			 0, 0, 1, 1, 1, 0, 0,
-			 0, 1, 1, 5, 1, 1, 0,
+			 0, 1, 1, 2, 1, 1, 0,
-			 0, 0, 1, 1, 1, 0, 0,
+			 0, 0, 1, 6, 1, 0, 0,
 			 0, 0, 0, 1, 0, 0, 0,
 			 0, 0, 0, 0, 0, 0, 0 };
 			color =
@@ -755,11 +791,11 @@ void dd::Systems::LevelSystem::GetBrickSet(int set, int setCluster) // These are
 	} else if (setCluster == 2) {
 		if (set == 1) {
 			level = // The Butterfly
-			{1, 0, 0, 1, 0, 0, 1,
+			{4, 0, 0, 1, 0, 0, 1,
-			 1, 1, 0, 1, 0, 1, 1,
+			 1, 6, 0, 1, 0, 6, 1,
-			 1, 1, 1, 1, 1, 1, 1,
+			 1, 1, 1, 6, 1, 1, 1,
 			 1, 1, 0, 1, 0, 1, 1, 
-			 1, 0, 0, 2, 0, 0, 1,
+			 1, 0, 0, 1, 0, 0, 1,
 			 1, 0, 0, 1, 0, 0, 3 };
 			color =
 			{r, r, r, r, r, r, r,
@@ -771,7 +807,7 @@ void dd::Systems::LevelSystem::GetBrickSet(int set, int setCluster) // These are
 		} else if (set == 2) {
 			level = // The Cross
 			{1, 1, 0, 0, 0, 1, 1,
-			 0, 4, 1, 0, 1, 1, 0,
+			 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,
@@ -785,11 +821,11 @@ void dd::Systems::LevelSystem::GetBrickSet(int set, int setCluster) // These are
 			 y, y, y, y, y, y, y };
 		} else if (set == 3) {
 			level = // The Inverted Cross
-			{0, 0, 1, 6, 1, 0, 0,
+			{0, 0, 1, 1, 1, 0, 0,
-			 1, 0, 0, 1, 0, 0, 1,
+			 1, 0, 0, 6, 0, 0, 1,
-			 1, 1, 0, 0, 0, 1, 3,
+			 4, 1, 0, 0, 0, 1, 3,
 			 1, 1, 0, 0, 0, 1, 1,
-			 1, 0, 0, 1, 0, 0, 1,
+			 1, 0, 0, 6, 0, 0, 1,
 			 0, 0, 1, 1, 1, 0, 0 };
 			color =
 			{b, b, b, b, b, b, b,
@@ -801,11 +837,11 @@ void dd::Systems::LevelSystem::GetBrickSet(int set, int setCluster) // These are
 		} else if (set == 4) {
 			level = // The Great Wall
 			{1, 1, 1, 1, 1, 1, 1,
-			 1, 1, 1, 1, 1, 1, 1,
+			 1, 1, 6, 1, 1, 1, 1,
 			 0, 0, 0, 0, 0, 0, 0,
-			 1, 1, 1, 1, 1, 5, 1,
+			 1, 6, 1, 1, 1, 1, 1,
 			 0, 0, 0, 0, 0, 0, 0,
-			 1, 3, 1, 1, 1, 1, 1 };
+			 1, 3, 1, 1, 1, 1, 5 };
 			color =
 			{m, m, m, m, m, m, m,
 			 m, m, m, m, m, m, m,
@@ -816,10 +852,10 @@ void dd::Systems::LevelSystem::GetBrickSet(int set, int setCluster) // These are
 		} 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,
 			 0, 0, 1, 1, 1, 0, 0,
 			 1, 1, 1, 0, 1, 1, 1,
-			 5, 1, 1, 0, 1, 1, 1,
+			 3, 6, 1, 0, 1, 6, 1,
 			 1, 1, 1, 0, 1, 1, 1 };
 			color =
 			{g, g, g, g, g, g, g,
@@ -830,10 +866,10 @@ void dd::Systems::LevelSystem::GetBrickSet(int set, int setCluster) // These are
 			 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,
+			{0, 1, 1, 6, 1, 1, 0,
-			 1, 1, 2, 1, 2, 1, 1,
+			 1, 1, 4, 5, 4, 1, 1,
 			 1, 1, 1, 1, 1, 1, 1,
-			 1, 0, 1, 1, 1, 0, 1,
+			 6, 0, 1, 1, 1, 0, 6,
 			 1, 0, 1, 1, 1, 0, 1,
 			 0, 0, 0, 3, 0, 0, 0 };
 			color =
@@ -912,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;
@@ -928,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);
@@ -951,47 +987,49 @@ 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;
+							e.KrakenStrength = 0.1;
+							e.PlayerStrength = 0.05;
+							EventBroker->Publish(e);
+						}
+						else {
 
+						}
 					}
 				}
 			}
@@ -1128,6 +1166,7 @@ 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);

src/game/Game/PadSystem.cpp

@@ -123,20 +123,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);
@@ -287,6 +292,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;

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;
 }
@@ -139,19 +150,34 @@ bool dd::Systems::ProjectileSystem::OnActionButton(const dd::Events::ActionButto
 			transform->Position = event.Position;
 			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;

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/Rendering/AnimationSystem.cpp

@@ -42,6 +42,7 @@ void dd::Systems::AnimationSystem::Update(double dt)
 				Events::AnimationComplete e;
 				e.Entity = ent;
 				e.Animation = animationComponent->Name;
+					EventBroker->Publish(e);
 			} else {
 				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;