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

Conflicts:
	src/game/Game/LevelSystem.cpp

include/Core/Engine.h

@@ -31,14 +31,15 @@
 //TODO: Remove includes that are only here for the temporary draw solution.
 #include "World.h"
 #include "CTransform.h"
+#include "CTemplate.h"
 #include "Core/EventBroker.h"
 #include "Rendering/CModel.h"
 #include "Rendering/CSprite.h"
-#include "CTemplate.h"
 #include "Rendering/CPointLight.h"
 #include "Transform/TransformSystem.h"
 #include "Sound/SoundSystem.h"
 #include "Sound/CCollisionSound.h"
+
 #include "Game/LevelSystem.h"
 #include "Game/PadSystem.h"
 #include "Game/CBall.h"
@@ -46,12 +47,15 @@
 #include "Game/CLifebuoy.h"
 #include "Game/CProjectile.h"
 #include "Game/CBrick.h"
+#include "Game/CStickyAim.h"
 #include "Game/BallSystem.h"
 #include "Game/HitLagSystem.h"
 #include "Game/LifebuoySystem.h"
 #include "Game/ProjectileSystem.h"
 #include "Game/Bricks/CPowerUpBrick.h"
 
+#include "Game/BrickComponents.h"
+
 #include "Physics/PhysicsSystem.h"
 #include "Physics/CPhysics.h"
 #include "Physics/CRectangleShape.h"
@@ -116,10 +120,18 @@ public:
 		m_World->ComponentFactory.Register<Components::Life>();
 		m_World->ComponentFactory.Register<Components::Lifebuoy>();
 		m_World->ComponentFactory.Register<Components::Projectile>();
+		m_World->ComponentFactory.Register<Components::StickyAim>();
 
 		m_World->ComponentFactory.Register<Components::PowerUp>();
 		m_World->ComponentFactory.Register<Components::PowerUpBrick>();
 
+		m_World->ComponentFactory.Register<Components::StandardBrick>();
+		m_World->ComponentFactory.Register<Components::MultiBallBrick>();
+		m_World->ComponentFactory.Register<Components::LifebuoyBrick>();
+		m_World->ComponentFactory.Register<Components::StickyBrick>();
+		m_World->ComponentFactory.Register<Components::InkBlasterBrick>();
+		m_World->ComponentFactory.Register<Components::KrakenAttackBrick>();
+
 		m_World->SystemFactory.Register<Systems::LevelSystem>(
 				[this]() { return new Systems::LevelSystem(m_World.get(), m_EventBroker); });
 		m_World->AddSystem<Systems::LevelSystem>();

include/GUI/Button.h

@@ -93,7 +93,7 @@ protected:
 	virtual bool OnMousePress(const Events::MousePress& event)
 	{
 		if (Hidden()) {
-			LOG_DEBUG("Pressed hidden button");
+			//LOG_DEBUG("Pressed hidden button");
 			return false;
 		}
 
@@ -117,7 +117,7 @@ protected:
 	virtual bool OnMouseRelease(const Events::MouseRelease& event)
 	{
 		if (Hidden()) {
-			LOG_DEBUG("Released hidden button");
+			//LOG_DEBUG("Released hidden button");
 			return false;
 		}
 

include/GUI/NumberFrame.h

@@ -10,11 +10,11 @@ namespace dd
 namespace GUI
 {
 
-class NumberFrame : public Frame
+class NumberFrame : public TextureFrame
 {
 public:
 	NumberFrame(Frame* parent, std::string name)
-		: Frame(parent, name)
+		: TextureFrame(parent, name)
 	{
 		m_CharacterTextures['0'] = "Textures/GUI/Numbers/N0.png";
 		m_CharacterTextures['1'] = "Textures/GUI/Numbers/N1.png";

include/Game/BallSystem.h

@@ -11,25 +11,29 @@
 #include "Physics/CRectangleShape.h"
 #include "Physics/EContact.h"
 #include "Rendering/CModel.h"
+#include "Rendering/CSprite.h"
 #include "Rendering/CPointLight.h"
 #include "Game/CBall.h"
 #include "Game/CPowerUp.h"
 #include "Game/CLife.h"
 #include "Game/CBrick.h"
+#include "Game/CLifebuoy.h"
 #include "Game/ELifeLost.h"
 #include "Game/EComboEvent.h"
 #include "Game/EResetBall.h"
 #include "Game/EMultiBall.h"
 #include "Game/EMultiBallLost.h"
 #include "Game/EStickyPad.h"
+#include "Game/EStickyAttachedToPad.h"
 #include "Game/EInkBlaster.h"
 #include "Game/EInkBlasterOver.h"
+#include "Game/EStageCleared.h"
+#include "Game/EArrivedAtNewStage.h"
 #include "Game/EGameOver.h"
 #include "Game/EPause.h"
 #include "Game/EHitPad.h"
 #include "Game/EHitLag.h"
 #include "Game/EActionButton.h"
-#include "Game/CLifebuoy.h"
 #include "Game/ELifebuoyHit.h"
 
 namespace dd
@@ -99,8 +103,11 @@ private:
 	bool m_Sticky = false;
 	bool m_InkBlaster = false;
 	bool m_InkAttached = false;
-	bool m_BlockedWaiting = false;
-	int m_StickyCounter = 5;
+	bool m_InkBlockedWaiting = false;
+	bool m_Restarting = false;
+	int m_StickyCounter = 3;
+
+	bool m_StageBlockedWaiting = false;
 
     glm::vec3 m_SavedSpeed;
     bool m_InitializePause = false;
@@ -120,6 +127,8 @@ private:
     dd::EventRelay<BallSystem, dd::Events::Pause> m_EPause;
     dd::EventRelay<BallSystem, dd::Events::Contact> m_Contact;
     dd::EventRelay<BallSystem, dd::Events::ActionButton> m_EActionButton;
+	dd::EventRelay<BallSystem, dd::Events::StageCleared> m_EStageCleared;
+	dd::EventRelay<BallSystem, dd::Events::ArrivedAtNewStage> m_EArrivedAtNewStage;
 
     bool Contact(const Events::Contact &event);
     bool OnLifeLost(const dd::Events::LifeLost &event);
@@ -131,6 +140,8 @@ private:
 	bool OnInkBlasterOver(const dd::Events::InkBlasterOver &event);
     bool OnPause(const dd::Events::Pause &event);
     bool OnActionButton(const dd::Events::ActionButton &event);
+	bool OnStageCleared(const dd::Events::StageCleared &event);
+	bool OnArrivedToNewStage(const dd::Events::ArrivedAtNewStage &event);
 };
 
 }

include/Game/BrickComponents.h

@@ -0,0 +1,15 @@
+//
+// Created by Adniklastrator on 2015-10-12.
+//
+
+#ifndef DAYDREAM_CBRICKCOMPONENTS_H
+#define DAYDREAM_CBRICKCOMPONENTS_H
+
+#include "Game/CStandardBrick.h"
+#include "Game/CMultiBallBrick.h"
+#include "Game/CLifebuoyBrick.h"
+#include "Game/CStickyBrick.h"
+#include "Game/CInkBlasterBrick.h"
+#include "Game/CKrakenAttackBrick.h"
+
+#endif //DAYDREAM_CBRICKCOMPONENTS_H

include/Game/CBrick.h

@@ -16,8 +16,18 @@ namespace Components
 struct Brick : Component
 {
     int Score = 50;
+	//0 = empty, 1 = normal, 2 = multi-brick, 3 = lifebuoy, 4 = sticky, 5 = blaster, 6 = kraken
     int Type = 0;
     bool Removed = false;
+
+	//What number of types each is.
+	const int EmptyBrickSpace = 0;
+	const int StandardBrick = 1;
+	const int MultiBallBrick = 2;
+	const int LifebuoyBrick = 3;
+	const int StickyBrick = 4;
+	const int InkBlasterBrick = 5;
+	const int KrakenAttackBrick = 6;
 };
 
 }

include/Game/CInkBlasterBrick.h

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

include/Game/CKrakenAttackBrick.h

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

include/Game/CLifebuoyBrick.h

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

include/Game/CMultiBallBrick.h

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

include/Game/CStandardBrick.h

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

include/Game/CStickyAim.h

@@ -0,0 +1,25 @@
+//
+// Created by Adniklastrator on 2015-10-12.
+//
+
+#ifndef DAYDREAM_CSTICKYAIM_H
+#define DAYDREAM_CSTICKYAIM_H
+
+#include "Core/Component.h"
+
+namespace dd
+{
+
+namespace Components
+{
+
+struct StickyAim : Component
+{
+    bool Aiming = false;
+};
+
+}
+
+}
+
+#endif //DAYDREAM_CSTICKYAIM_H

include/Game/CStickyBrick.h

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

include/Game/EArrivedAtNewStage.h

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

include/Game/EInkBlaster.h

@@ -16,6 +16,7 @@ namespace Events
 struct InkBlaster : Event
 {
     Components::Transform* Transform;
+	int Shots;
 };
 
 }

include/Game/EStickyAttachedToPad.h

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

include/Game/EStickyPad.h

@@ -16,6 +16,7 @@ namespace Events
 struct StickyPad : Event
 {
     Components::Transform* Transform;
+	int Times;
 };
 
 }

include/Game/GUI/HUD.h

@@ -26,24 +26,24 @@ public:
 		Width = parent->Width;
 		Height = parent->Height;
 
-		m_LevelIndicator = new GUI::TextureFrame(this, "HUDLevelIndicator");
-		m_LevelIndicator->SetTexture("Textures/GUI/HUD/LevelIndicatorBG.png");
+		//m_LevelIndicator = new GUI::TextureFrame(this, "HUDLevelIndicator");
+		//m_LevelIndicator->SetTexture("Textures/GUI/HUD/LevelIndicatorBG.png");
 
-		m_AreaNumberFrame = new GUI::NumberFrame(m_LevelIndicator, "HUDScoreNumberFrameawdawdwa");
-		m_AreaNumberFrame->X = 132;
-		m_AreaNumberFrame->Y = 19;
-		m_AreaNumberFrame->SetNumber(6);
-		m_StageNumberFrame = new GUI::NumberFrame(m_LevelIndicator, "HUDScoreNumberFrameawdawdwa");
-		m_StageNumberFrame->X = 165;
-		m_StageNumberFrame->Y = 19;
-		m_StageNumberFrame->SetNumber(5);
+		//m_AreaNumberFrame = new GUI::NumberFrame(m_LevelIndicator, "HUDScoreNumberFrameawdawdwa");
+		//m_AreaNumberFrame->X = 132;
+		//m_AreaNumberFrame->Y = 19;
+		//m_AreaNumberFrame->SetNumber(6);
+		//m_StageNumberFrame = new GUI::NumberFrame(m_LevelIndicator, "HUDScoreNumberFrameawdawdwa");
+		//m_StageNumberFrame->X = 165;
+		//m_StageNumberFrame->Y = 19;
+		//m_StageNumberFrame->SetNumber(5);
 
-		m_ScoreIndicator = new GUI::TextureFrame(this, "HUDScoreIndicator");
-		m_ScoreIndicator->SetTexture("Textures/GUI/HUD/ScoreIndicatorBG.png");
-		m_ScoreIndicator->SetRight(Right());
-		m_ScoreNumberFrame = new GUI::NumberFrame(m_ScoreIndicator, "HUDScoreNumberFrame");
-		m_ScoreNumberFrame->X = 15;
-		m_ScoreNumberFrame->Y = 21;
+		//m_ScoreIndicator = new GUI::TextureFrame(this, "HUDScoreIndicator");
+		//m_ScoreIndicator->SetTexture("Textures/GUI/HUD/ScoreIndicatorBG.png");
+		m_ScoreNumberFrame = new GUI::NumberFrame(this, "HUDScoreNumberFrame");
+		m_ScoreNumberFrame->SetTexture("Textures/GUI/Numbers/Background.png");
+		//m_ScoreNumberFrame->X = 15;
+		m_ScoreNumberFrame->Y = 18;
 
 		m_FPSCounter = new GUI::FPSCounter(this, "FPSCounter");
 
@@ -60,6 +60,11 @@ public:
 		EVENT_SUBSCRIBE_MEMBER(m_KrakenAttack, &HUD::OnKrakenAttack);
 	}
 
+	void Update(double dt) override
+	{
+		m_ScoreNumberFrame->SetLeft(Width / 2.f - m_ScoreNumberFrame->Width / 2.f);
+	}
+
 private:
 	TextureFrame* m_LevelIndicator = nullptr;
 	TextureFrame* m_ScoreIndicator = nullptr;

include/Game/LevelSystem.h

@@ -16,11 +16,15 @@
 #include "Core/World.h"
 #include "Rendering/CSprite.h"
 #include "Rendering/CModel.h"
+
 #include "Game/CBrick.h"
 #include "Game/CBall.h"
 #include "Game/CLife.h"
 #include "Game/CProjectile.h"
 #include "Game/CPowerUp.h"
+
+#include "Game/BrickComponents.h"
+
 #include "Game/EStageCleared.h"
 #include "Game/ELifeLost.h"
 #include "Game/EResetBall.h"
@@ -38,7 +42,7 @@
 #include "Game/EClusterClear.h"
 #include "Game/ECreatePowerUp.h"
 #include "Game/EPowerUpTaken.h"
-//#include "Game/Bricks/CPowerUpBrick.h"
+
 #include "Physics/CPhysics.h"
 #include "Physics/CCircleShape.h"
 #include "Physics/CRectangleShape.h"
@@ -79,6 +83,7 @@ public:
     void CreateBasicLevel(int, int, glm::vec2, float);
     void CreateLevel(int);
     void CreateBrick(int, int, glm::vec2, float, int, int, int, glm::vec4);
+	void BrickHit(EntityID, EntityID, int);
 
     void OnEntityRemoved(EntityID entity);
 

include/Game/PadSystem.h

@@ -24,8 +24,12 @@
 #include "Game/CBall.h"
 #include "Game/CPad.h"
 #include "Game/CPowerUp.h"
+#include "Game/CStickyAim.h"
 #include "Game/EResetBall.h"
 #include "Game/EMultiBall.h"
+#include "Game/EStickyPad.h"
+#include "Game/EStickyAttachedToPad.h"
+#include "Game/EInkBlaster.h"
 #include "Game/EKrakenAttack.h"
 #include "Game/EPowerUpTaken.h"
 #include "Game/EStageCleared.h"
@@ -78,12 +82,15 @@ private:
     bool m_ReplaceBall = false;
     bool m_MultiBall = false;
 	bool m_KrakenAttack = false;
+	bool m_BallStuck = false;
 	double m_KrakenCharge = 0;
 	double m_KrakenStrength = 0;
 	double m_PlayerStrength = 0;
     float m_Edge = 2.8f;
     Components::Transform* m_Transform = nullptr;
     Components::Pad* m_Pad = nullptr;
+	std::shared_ptr<Components::Transform> m_StickTransform;
+	std::shared_ptr<Components::StickyAim> m_StickyAim;
 
     bool m_Pause = false;
 
@@ -94,6 +101,8 @@ private:
     dd::EventRelay<PadSystem, dd::Events::StageCleared> m_EStageCleared;
     dd::EventRelay<PadSystem, dd::Events::Pause> m_EPause;
 	dd::EventRelay<PadSystem, dd::Events::KrakenAttack> m_EKrakenAttack;
+	dd::EventRelay<PadSystem, dd::Events::StickyPad> m_EStickyPad;
+	dd::EventRelay<PadSystem, dd::Events::StickyAttachedToPad> m_EStickyAttachedToPad;
 	dd::EventRelay<PadSystem, dd::Events::ActionButton> m_EActionButton;
 
     bool OnKeyDown(const dd::Events::KeyDown &event);
@@ -103,6 +112,8 @@ private:
     bool OnStageCleared(const dd::Events::StageCleared &event);
     bool OnPause(const dd::Events::Pause &event);
 	bool OnKrakenAttack(const dd::Events::KrakenAttack &event);
+	bool OnStickyPad(const dd::Events::StickyPad &event);
+	bool OnStickyAttachedToPad(const dd::Events::StickyAttachedToPad &event);
 	bool OnActionButton(const dd::Events::ActionButton &event);
 
     class PadSteeringInputController;

include/Physics/PhysicsSystem.h

@@ -25,12 +25,15 @@
 #include "Physics/CCircleShape.h"
 #include "Physics/CParticleEmitter.h"
 
+#include "Game/BrickComponents.h"
+
 #include "Transform/TransformSystem.h"
 #include "Transform/TransformSystem.h"
 
 #include "CRectangleShape.h"
 
 #include "Game/EStageCleared.h"
+#include "Game/EArrivedAtNewStage.h"
 #include "Game/EPause.h"
 #include "Game/CPad.h"
 #include "Game/CBrick.h"
@@ -97,6 +100,8 @@ namespace dd
             std::unordered_map<b2Body*, EntityID> m_BodiesToEntities;
 
 
+			int t_counter = 0;
+
 
             void CreateBody(EntityID entity);
             void SyncEntitiesWithBodies();

src/game/Game/BallSystem.cpp

@@ -23,12 +23,14 @@ void dd::Systems::BallSystem::Initialize()
 	EVENT_SUBSCRIBE_MEMBER(m_EInkBlasterOver, &BallSystem::OnInkBlasterOver);
     EVENT_SUBSCRIBE_MEMBER(m_EPause, &BallSystem::OnPause);
     EVENT_SUBSCRIBE_MEMBER(m_EActionButton, &BallSystem::OnActionButton);
+	EVENT_SUBSCRIBE_MEMBER(m_EStageCleared, &BallSystem::OnStageCleared);
+	EVENT_SUBSCRIBE_MEMBER(m_EArrivedAtNewStage, &BallSystem::OnArrivedToNewStage);
 
     //OctoBall
     {
         auto ent = m_World->CreateEntity();
         std::shared_ptr<Components::Transform> transform = m_World->AddComponent<Components::Transform>(ent);
-        transform->Position = glm::vec3(-0.f, 50.26f, -10.f);
+        transform->Position = glm::vec3(0.f, 0.26f, -10.f);
         transform->Scale = glm::vec3(0.3f, 0.3f, 0.3f);
         transform->Velocity = glm::vec3(0.f, 0.f, 0.f);
         auto model = m_World->AddComponent<Components::Model>(ent);
@@ -117,6 +119,7 @@ void dd::Systems::BallSystem::UpdateEntity(double dt, EntityID entity, EntityID
 
         if (ballComponent->Waiting) {
             if (!m_Waiting) {
+				m_Restarting = false;
                 ballComponent->Waiting = false;
 				auto transform = m_World->GetComponent<Components::Transform>(entity);
                 transform->Velocity = glm::normalize(glm::vec3(0.5f, 1, 0.f)) * ballComponent->Speed;
@@ -155,7 +158,7 @@ void dd::Systems::BallSystem::UpdateEntity(double dt, EntityID entity, EntityID
                 m_World->RemoveEntity(entity);
                 Events::MultiBallLost e;
                 EventBroker->Publish(e);
-            } else if (Lives() == PastLives()) {
+            } else if (Lives() == PastLives() && !m_Restarting) {
                 Events::ResetBall be;
                 EventBroker->Publish(be);
                 Events::LifeLost e;
@@ -193,6 +196,8 @@ void dd::Systems::BallSystem::UpdateEntity(double dt, EntityID entity, EntityID
     }
 
     if (ballComponent != nullptr) {
+		if (!ballComponent->Sticky)
+		{
 			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);
@@ -200,6 +205,7 @@ void dd::Systems::BallSystem::UpdateEntity(double dt, EntityID entity, EntityID
 			transform->Orientation = glm::rotate(glm::quat(), angle, glm::vec3(0.f, 0.f, -1.f));
 		}
     }
+}
 
 bool dd::Systems::BallSystem::OnPause(const dd::Events::Pause &event)
 {
@@ -287,7 +293,7 @@ bool dd::Systems::BallSystem::Contact(const Events::Contact &event)
 			if (!m_InkAttached) {
 				m_InkAttached = true;
 				m_Waiting = true;
-				m_BlockedWaiting = true;
+				m_InkBlockedWaiting = true;
 				ballComponent->Sticky = true;
 				ballComponent->StickyPlacement = glm::vec3(0, 0.5f, 0);
 				ballComponent->SavedSpeed = glm::normalize(glm::vec3(x, y, 0.f)) * ballComponent->Speed;
@@ -300,6 +306,8 @@ bool dd::Systems::BallSystem::Contact(const Events::Contact &event)
 			ballComponent->StickyPlacement = ballTransform->Position - padTransform->Position;
 			ballComponent->SavedSpeed = glm::normalize(glm::vec3(x, y, 0.f)) * ballComponent->Speed;
 			ballTransform->Velocity *= -1;
+			Events::StickyAttachedToPad e;
+			EventBroker->Publish(e);
 			return true;
 		}
 
@@ -438,7 +446,6 @@ bool dd::Systems::BallSystem::OnMultiBall(const dd::Events::MultiBall &event)
 bool dd::Systems::BallSystem::OnStickyPad(const dd::Events::StickyPad &event) 
 {
 	m_Sticky = true;
-	m_StickyCounter = 5;
 	return true;
 }
 
@@ -455,8 +462,7 @@ bool dd::Systems::BallSystem::OnInkBlasterOver(const dd::Events::InkBlasterOver
 
 	m_InkBlaster = false;
 	m_InkAttached = false;
-	m_BlockedWaiting = false;
-	m_Sticky = true;
+	m_InkBlockedWaiting = false;
 	ballComponent->SavedSpeed = glm::normalize(glm::vec3(0.f, 1.f, 0.f)) * ballComponent->Speed;
 	m_Waiting = false;
 	transform->Velocity = glm::normalize(glm::vec3(0.f, 1, 0.f)) * ballComponent->Speed;
@@ -465,9 +471,24 @@ bool dd::Systems::BallSystem::OnInkBlasterOver(const dd::Events::InkBlasterOver
 
 bool dd::Systems::BallSystem::OnActionButton(const dd::Events::ActionButton &event)
 {
-	if (!m_BlockedWaiting) {
+	if (!m_StageBlockedWaiting) {
+		if (!m_InkBlockedWaiting) {
 			m_Waiting = false;
 		}
+	}
+    return true;
+}
+
+bool dd::Systems::BallSystem::OnStageCleared(const dd::Events::StageCleared &event)
+{
+	m_Restarting = true;
+	m_StageBlockedWaiting = true;
+	return true;
+}
+
+bool dd::Systems::BallSystem::OnArrivedToNewStage(const dd::Events::ArrivedAtNewStage &event)
+{
+	m_StageBlockedWaiting = false;
 	return true;
 }
 

src/game/Game/LevelSystem.cpp

@@ -34,6 +34,7 @@ void dd::Systems::LevelSystem::Initialize()
     cPhys->Category = CollisionLayer::Type::Brick;
     cPhys->Mask = static_cast<CollisionLayer::Type>(CollisionLayer::Type::Ball | CollisionLayer::Type::Projectile | CollisionLayer::Type::Wall | CollisionLayer::LifeBuoy);
     transform->Sticky = false;
+
     model->ModelFile = "Models/Brick/WhiteBrick.obj";
 	transform->Position = glm::vec3(50, 50, -10);
 	//sound
@@ -198,22 +199,29 @@ void dd::Systems::LevelSystem::CreateBrick(int row, int line, glm::vec2 spacesBe
     auto cBrick = m_World->GetComponent<Components::Brick>(brick);
 	auto model = m_World->GetComponent<Components::Model>(brick);
     if (typeInt == StandardBrick) {
+		cBrick->Type = StandardBrick;
+		auto type = m_World->AddComponent<Components::StandardBrick>(brick);
 		model->Color = colorVec;
 		SetBrokenModel(brick);
     } else if (typeInt == MultiBallBrick) {
         cBrick->Type = MultiBallBrick;
+		auto type = m_World->AddComponent<Components::MultiBallBrick>(brick);
         model->ModelFile = "Models/Brick/IceBrick.obj";
 	} else if (typeInt == LifebuoyBrick) {
 		cBrick->Type = LifebuoyBrick;
+		auto type = m_World->AddComponent<Components::LifebuoyBrick>(brick);
 		model->ModelFile = "Models/Brick/LifeBuoyBrick.obj";
 	} else if (typeInt == StickyBrick) {
 		cBrick->Type = StickyBrick;
+		auto type = m_World->AddComponent<Components::StickyBrick>(brick);
 		model->ModelFile = "Models/Brick/StickyBrick.obj";
 	} else if (typeInt == InkBlasterBrick) {
 		cBrick->Type = InkBlasterBrick;
+		auto type = m_World->AddComponent<Components::InkBlasterBrick>(brick);
 		model->Color = glm::vec4(0.1f, 0.1f, 0.1f, 1.0f);
 	} else if (typeInt == KrakenAttackBrick) {
 		cBrick->Type = KrakenAttackBrick;
+		auto type = m_World->AddComponent<Components::KrakenAttackBrick>(brick);
 		model->Color = glm::vec4(0.f, 0.5f, 1.0f, .0f);
 	}
 
@@ -276,54 +284,15 @@ bool dd::Systems::LevelSystem::OnContact(const dd::Events::Contact &event)
 	if (entityShot != 0) {
 		// For when a brick gets shot.
 		brick->Removed = true;
-
-		auto physicsComponent = m_World->GetComponent<Components::Physics>(entityBrick);
-		physicsComponent->CollisionType = CollisionType::Type::Dynamic;
-		physicsComponent->GravityScale = 1.f;
-		physicsComponent->Mask = static_cast<CollisionLayer::Type>(CollisionLayer::Water | CollisionLayer::Wall);
-
-		auto transformComponentBrick = m_World->GetComponent<Components::Transform>(entityBrick);
-		auto transformComponentShot = m_World->GetComponent<Components::Transform>(entityShot);
-		auto brickModel = m_World->GetComponent<Components::Model>(entityBrick);
-
-		Events::SetImpulse e;
-		e.Entity = entityBrick;
-
-		glm::vec2 point = glm::vec2(transformComponentBrick->Position.x + ((transformComponentShot->Position.x - transformComponentBrick->Position.x) / 4),
-			transformComponentBrick->Position.y + ((transformComponentShot->Position.y - transformComponentBrick->Position.y) / 4));
-
-		e.Impulse = glm::normalize(point)*5.f;
-		e.Point = point;
-		EventBroker->Publish(e);
-
-
-		SetNumberOfBricks(NumberOfBricks() - 1);
-		Events::ScoreEvent es;
-		es.Score = brick->Score;
-		EventBroker->Publish(es);
-
 		m_World->RemoveEntity(entityShot);
-
-		Events::CreateParticleSequence ep;
-		ep.parent = entityBrick;
-		ep.EmitterLifeTime = 1.f;
-		ep.ParticleLifeTime = 1.5f;
-		ep.ParticlesPerTick = 1;
-		ep.SpawnRate = 0.2;
-		ep.EmittingAngle = glm::half_pi<float>();
-		ep.Spread = 1.5f;
-		ep.Position = transformComponentBrick->Position;
-		ep.Radius = 0.05;
-		ep.SpriteFile = "Textures/Particles/FadeBall.png";
-		ep.Color = brickModel->Color + glm::vec4(0.3f);
-		ep.Speed = 50;
-		EventBroker->Publish(ep);
+		BrickHit(entityShot, entityBrick, 1);
 
 		return true;
 	}
 
     if (!Restarting() && !brick->Removed) {
         brick->Removed = true;
+        
 		// Hit brick with ball code.
 		ball->Combo += 1;
 		Events::ComboEvent ec;
@@ -331,19 +300,73 @@ bool dd::Systems::LevelSystem::OnContact(const dd::Events::Contact &event)
 		ec.Ball = entityBall;
 		EventBroker->Publish(ec);
 
-        auto ballTransform = m_World->GetComponent<Components::Transform>(entityBall);
+		BrickHit(entityBall, entityBrick, ball->Combo);
+    }
 
+    return true;
+}
+
+void dd::Systems::LevelSystem::BrickHit(EntityID entityHitter, EntityID entityBrick, int combo)
+{
+	auto brick = m_World->GetComponent<Components::Brick>(entityBrick);
 	auto physicsComponent = m_World->GetComponent<Components::Physics>(entityBrick);
 		//physicsComponent->CollisionType = CollisionType::Type::Dynamic;
         //physicsComponent->GravityScale = 1.f;
         //physicsComponent->Mask = static_cast<CollisionLayer::Type>(CollisionLayer::Water | CollisionLayer::Wall);
 
 	auto transformComponentBrick = m_World->GetComponent<Components::Transform>(entityBrick);
-        auto transformComponentBall = m_World->GetComponent<Components::Transform>(entityBall);
+	auto transformComponentHitter = m_World->GetComponent<Components::Transform>(entityHitter);
 		
 
 	auto brickModel = m_World->GetComponent<Components::Model>(entityBrick);
 
+	// Check if the brick is any kind of special.
+	auto multi = m_World->GetComponent<Components::MultiBallBrick>(entityBrick);
+	if (multi != nullptr) {
+		Events::MultiBall e;
+		e.padTransform = transformComponentBrick;
+		EventBroker->Publish(e);
+	}
+	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);
+			if (sticky != nullptr) {
+				Events::StickyPad e;
+				e.Transform = transformComponentBrick;
+				e.Times = 3;
+				EventBroker->Publish(e);
+			}
+			else {
+				auto ink = m_World->GetComponent<Components::InkBlasterBrick>(entityBrick);
+				if (ink != nullptr) {
+					Events::InkBlaster e;
+					e.Transform = transformComponentBrick;
+					e.Shots = 5;
+					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 {
+
+					}
+				}
+			}
+		}
+	}
+	
 	auto brickChildren = m_World->GetEntityChildren(entityBrick);
 	for (auto b : brickChildren)
 	{
@@ -351,12 +374,9 @@ bool dd::Systems::LevelSystem::OnContact(const dd::Events::Contact &event)
 
 		auto cTransform = m_World->GetComponent<Components::Transform>(b);
 		cTransform->Position = cTransform->Position + transformComponentBrick->Position;
-			glm::vec2 ballToBrick = 4.f * glm::normalize(glm::vec2(cTransform->Position.x - ballTransform->Position.x , cTransform->Position.y - ballTransform->Position.y));
-			
+		glm::vec2 ballToBrick = 4.f * glm::normalize(glm::vec2(cTransform->Position.x - transformComponentHitter->Position.x, cTransform->Position.y - transformComponentHitter->Position.y));
 		cTransform->Velocity = glm::vec3(ballToBrick.x, ballToBrick.y, 0.f);
 
-			
-
 		auto cModel = m_World->GetComponent<Components::Model>(b);
 		cModel->Color = brickModel->Color;
 		cModel->Color *= 0.5f;
@@ -364,26 +384,17 @@ bool dd::Systems::LevelSystem::OnContact(const dd::Events::Contact &event)
 		m_World->RemoveComponent<Components::Template>(b);
 		m_World->SetEntityParent(b, 0);
 		m_World->CommitEntity(b);
-
-
-			
 	}
 
+
 	SetNumberOfBricks(NumberOfBricks() - 1);
 	Events::ScoreEvent es;
-        es.Score = brick->Score * ball->Combo;
+	es.Score = brick->Score * combo;
 	EventBroker->Publish(es);
 
-        //std::cout << "Combo: " << ball->Combo << std::endl;
-        //std::cout << NumberOfBricks() << std::endl;
-        //std::cout << "Brick Score: " << brick->Score  << std::endl;
-        //std::cout << "Score: " << Score() << std::endl;
 	m_World->RemoveEntity(entityBrick);
 }
 
-    return true;
-}
-
 bool dd::Systems::LevelSystem::OnScoreEvent(const dd::Events::ScoreEvent &event)
 {
     SetScore(Score() += event.Score);
@@ -657,14 +668,14 @@ void dd::Systems::LevelSystem::GetNextLevel()
                      1, 4, 1, 1, 1, 3, 1,
                      0, 1, 0, 1, 0, 1, 0,
                      0, 1, 0, 1, 0, 1, 0,
-                     1, 5, 1, 1, 1, 2, 1,
+                     1, 5, 1, 6, 1, 2, 1,
                      0, 1, 0, 0, 0, 1, 0};
 			color = 
 					{w, p3, w, w, w, r, w,
 					 p2, w, p1, g, w, w, w,
 					 w, p4, w, g, w, r, w,
 					 w, br, w, g, w, lb1, w,
-					 y, w, y, g, b, w, b,
+					 y, w, y, d, b, w, b,
 					 w, br, w, w, w, lb1, w};
         }
     } else if (m_CurrentCluster == 3) {

src/game/Game/PadSystem.cpp

@@ -29,6 +29,8 @@ void dd::Systems::PadSystem::Initialize()
     EVENT_SUBSCRIBE_MEMBER(m_EStageCleared, &PadSystem::OnStageCleared);
     EVENT_SUBSCRIBE_MEMBER(m_EPause, &PadSystem::OnPause);
 	EVENT_SUBSCRIBE_MEMBER(m_EKrakenAttack, &PadSystem::OnKrakenAttack);
+	EVENT_SUBSCRIBE_MEMBER(m_EStickyPad, &PadSystem::OnStickyPad);
+	EVENT_SUBSCRIBE_MEMBER(m_EStickyAttachedToPad, &PadSystem::OnStickyAttachedToPad);
 	EVENT_SUBSCRIBE_MEMBER(m_EActionButton, &PadSystem::OnActionButton);
     //EVENT_SUBSCRIBE_MEMBER(m_EBindKey, &PadSystem::OnBindKey);
 
@@ -53,6 +55,23 @@ void dd::Systems::PadSystem::Initialize()
 
         SetEdge(3.2 - (ctransform->Scale.x / 2));
     }
+
+	//Stick
+	{
+		auto ent = m_World->CreateEntity();
+		m_World->SetProperty(ent, "Name", "Stick");
+		std::shared_ptr<Components::Transform> transform = m_World->AddComponent<Components::Transform>(ent);
+		transform->Position = glm::vec3(30.f, 0.f, -10.f);
+		transform->Scale = glm::vec3(0.1f, 25.f, 0.1f);
+		std::shared_ptr<Components::Sprite> sprite = m_World->AddComponent<Components::Sprite>(ent);
+		sprite->SpriteFile = "Models/Brick/White.png";
+		sprite->Color = glm::vec4(0.f, 0.5f, 0.f, 0.5f);
+		std::shared_ptr<Components::StickyAim> sticky = m_World->AddComponent<Components::StickyAim>(ent);
+		m_World->CommitEntity(ent);
+
+		m_StickTransform = transform;
+		m_StickyAim = sticky;
+	}
 }
 
 void dd::Systems::PadSystem::UpdateEntity(double dt, EntityID entity, EntityID parent)
@@ -63,9 +82,18 @@ void dd::Systems::PadSystem::UpdateEntity(double dt, EntityID entity, EntityID p
 	auto ball = m_World->GetComponent<Components::Ball>(entity);
 	if (ball != nullptr) {
 		if (ball->Sticky) {
-			auto transform = m_World->GetComponent<Components::Transform>(entity);
-			transform->Position = Transform()->Position;
-			transform->Position += ball->StickyPlacement;
+			auto ballTransform = m_World->GetComponent<Components::Transform>(entity);
+			ballTransform->Position = Transform()->Position;
+			ballTransform->Position += ball->StickyPlacement;
+			glm::vec2 dir = glm::normalize(glm::vec2(ball->SavedSpeed.x, ball->SavedSpeed.y));
+			glm::vec2 up = glm::vec2(0.f, 1.f);
+			float angle = glm::acos(glm::dot<float>(dir, up)) * glm::sign(dir.x);
+			ballTransform->Orientation = glm::rotate(glm::quat(), angle, glm::vec3(0.f, 0.f, -1.f));
+			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);
 		}
 	}
 }
@@ -181,7 +209,15 @@ bool dd::Systems::PadSystem::OnKeyDown(const dd::Events::KeyDown &event) {
     } else if (val == GLFW_KEY_S) {
 		Events::StageCleared e;
 		EventBroker->Publish(e);
-	} else if (val == GLFW_KEY_K) {
+	} else if (val == GLFW_KEY_Y) {
+		Events::StickyPad e;
+		EventBroker->Publish(e);
+	}
+	else if (val == GLFW_KEY_I) {
+		Events::InkBlaster e;
+		EventBroker->Publish(e);
+	}
+	else if (val == GLFW_KEY_K) {
 		Events::KrakenAttack e;
 		e.ChargeUpdate = 0;
 		e.KrakenStrength = 0.1;
@@ -333,6 +369,17 @@ bool dd::Systems::PadSystem::OnKrakenAttack(const dd::Events::KrakenAttack &even
 	return true;
 }
 
+bool dd::Systems::PadSystem::OnStickyPad(const dd::Events::StickyPad &event)
+{
+	return true;
+}
+
+bool dd::Systems::PadSystem::OnStickyAttachedToPad(const dd::Events::StickyAttachedToPad &event)
+{
+	m_StickyAim->Aiming = true;
+	return true;
+}
+
 bool dd::Systems::PadSystem::OnActionButton(const dd::Events::ActionButton &event)
 {
 	if (m_KrakenAttack) {
@@ -344,6 +391,7 @@ bool dd::Systems::PadSystem::OnActionButton(const dd::Events::ActionButton &even
 		e.PlayerStrength = 0;
 		EventBroker->Publish(e);
 	}
+	m_StickyAim->Aiming = false;
 	return true;
 }
 

src/game/Game/ProjectileSystem.cpp

@@ -90,7 +90,7 @@ bool dd::Systems::ProjectileSystem::OnContact(const dd::Events::Contact &event)
 bool dd::Systems::ProjectileSystem::OnInkBlaster(const dd::Events::InkBlaster &event)
 {
 	m_InkBlaster = true;
-	m_Shots = 5;
+	m_Shots = event.Shots;
 	return true;
 }
 

src/game/Physics/PhysicsSystem.cpp

@@ -175,6 +175,8 @@ void dd::Systems::PhysicsSystem::Update(double dt)
 		if (m_DistanceTravelled > 12.f) {
 			m_DistanceTravelled = 0;
 			m_Travelling = false;
+			Events::ArrivedAtNewStage e;
+			EventBroker->Publish(e);
 		}
 
 		m_DistanceTravelled += 6.0f * dt;
@@ -559,7 +561,6 @@ void dd::Systems::PhysicsSystem::UpdateParticleEmitters(double dt)
 // 		entHandles += m_EntitiesToParticleHandle[i].size();
 // 	LOG_INFO("Entities and handles: %i", entHandles);
 	
-
 	for (int i = 0; i < emittersToDelete.size(); i++)
     {
         EntityID ent = emittersToDelete[i];
@@ -571,6 +572,36 @@ void dd::Systems::PhysicsSystem::UpdateParticleEmitters(double dt)
         }
 
         if (m_ParticleEmitters.ParticleSystem[key]->GetParticleCount() == 0 && key <= m_ParticleEmitters.ParticleSystem.size()) {
+			// DEBUG vvvvvv
+// 			int t_Entities = m_World->GetEntities()->size();
+// 			int t_Systems = m_ParticleEmitters.ParticleSystem.size();
+// 			int t_Emitters = m_ParticleEmitters.ParticleEmitter.size();
+// 			int t_Templates = m_ParticleEmitters.ParticleTemplate.size();
+// 			int t_LFunParticles = 0;
+// 			int t_EntParticles = 0;
+// 			auto t_WorldEntities = m_World->GetEntities();
+// 
+// 			for (auto &te : *t_WorldEntities)
+// 			{
+// 				if (m_World->GetComponent<Components::Particle>(te.first))
+// 				{
+// 					t_EntParticles++;
+// 				}
+// 			}
+// 
+// 			for (int i = 0; i < t_Systems; i++)
+// 			{
+// 				t_LFunParticles = m_ParticleEmitters.ParticleSystem[i]->GetParticleCount();
+// 			}
+// 
+// 			LOG_INFO("----------------------------");
+// 			LOG_INFO("Deleting emitter and other");
+// 			LOG_INFO("Total before:");
+// 			LOG_INFO("Entities: %i, Systems: %i, Emitters: %i, Templates: %i, LfunParticles: %i, EntParticles: %i, EtH: %i, HtE: %i",
+// 				t_Entities, t_Systems, t_Emitters, t_Templates, t_LFunParticles, t_EntParticles, m_EntitiesToParticleHandle.size(), m_ParticleHandleToEntities.size());
+// 			
+			// DEBUG ^^^^^
+
             m_World->RemoveEntity(ent);
             m_PhysicsWorld->DestroyParticleSystem(m_ParticleEmitters.ParticleSystem[key]);
             m_ParticleEmitters.ParticleSystem.erase(m_ParticleEmitters.ParticleSystem.begin() + key);
@@ -578,7 +609,38 @@ void dd::Systems::PhysicsSystem::UpdateParticleEmitters(double dt)
             m_ParticleEmitters.ParticleTemplate.erase(m_ParticleEmitters.ParticleTemplate.begin() + key);
             m_EntitiesToParticleHandle.erase(m_EntitiesToParticleHandle.begin() + key);
             m_ParticleHandleToEntities.erase(m_ParticleHandleToEntities.begin() + key);
+
+			// DEBUG vvvvv
+// 			t_Entities = m_World->GetEntities()->size();
+// 			t_Systems = m_ParticleEmitters.ParticleSystem.size();
+// 			t_Emitters = m_ParticleEmitters.ParticleEmitter.size();
+// 			t_Templates = m_ParticleEmitters.ParticleTemplate.size();
+// 			t_LFunParticles = 0;
+// 			t_EntParticles = 0;
+// 			t_WorldEntities = m_World->GetEntities();
+// 
+// 			for (auto &te : *t_WorldEntities)
+// 			{
+// 				if (m_World->GetComponent<Components::Particle>(te.first))
+// 				{
+// 					t_EntParticles++;
+// 				}
+// 			}
+// 
+// 			for (int i = 0; i < t_Systems; i++)
+// 			{
+// 				t_LFunParticles = m_ParticleEmitters.ParticleSystem[i]->GetParticleCount();
+// 			}
+// 
+// 			LOG_INFO("Total after:");
+// 			LOG_INFO("Entities: %i, Systems: %i, Emitters: %i, Templates: %i, LfunParticles: %i, EntParticles: %i, EtH: %i, HtE: %i",
+// 				t_Entities, t_Systems, t_Emitters, t_Templates, t_LFunParticles, t_EntParticles, m_EntitiesToParticleHandle.size(), m_ParticleHandleToEntities.size());
+// 			LOG_INFO("-----------------------------");
+// 			t_counter = 0;
+			
+			// DEBUG ^^^^^
         }
+		
     }
 
 	
@@ -688,10 +750,12 @@ bool dd::Systems::PhysicsSystem::OnContact(const dd::Events::Contact &event)
 {
 	//Check if it is a brick colliding
 	auto brick = m_World->GetComponent<Components::Brick>(event.Entity1);
+	EntityID entity = event.Entity1;
 	Components::Model* model;
 	
 	if (!brick) {
 		brick = m_World->GetComponent<Components::Brick>(event.Entity2);
+		EntityID entity = event.Entity2;
 		if (!brick) {
 			return false;
 		}
@@ -702,9 +766,41 @@ bool dd::Systems::PhysicsSystem::OnContact(const dd::Events::Contact &event)
 	else {
 		model = m_World->GetComponent<Components::Model>(event.Entity1);
 	}
+
+	//Spawn a particle when a brick collides with somthing
 	Events::CreateParticleSequence e;
+	
+	
+	e.EmitterLifeTime = 3;
+	e.EmittingAngle = glm::half_pi<float>();
+	e.Spread = 0.f;
+	e.NumberOfTicks = 1;
+	e.ParticleLifeTime = 1.f;
+	e.ParticlesPerTick = 1;
+	e.Position = glm::vec3(event.IntersectionPoint.x, event.IntersectionPoint.y, -7);
+	e.Color = glm::vec4(1.f);
+	e.Radius = 1.f;
+	e.Speed = 0;
+
+	auto PowerFriend = m_World->GetComponent<Components::MultiBallBrick>(entity);
+	auto PowerSaviour = m_World->GetComponent<Components::LifebuoyBrick>(entity);
+	auto PowerSticky = m_World->GetComponent<Components::StickyBrick>(entity);
+	auto PowerInkBlaster = m_World->GetComponent<Components::InkBlasterBrick>(entity);
+	auto PowerKraken = m_World->GetComponent<Components::KrakenAttackBrick>(entity);
+
+	if (PowerFriend) {
+		e.SpriteFile = "Textures/PowerUps/Friends.png";
+	} else if (PowerSaviour) {
+		e.SpriteFile = "Textures/PowerUps/Saviour.png";
+	} else if (PowerSticky) {
+		e.SpriteFile = "Textures/PowerUps/Sticky.png";
+	} else if (PowerInkBlaster){
+		e.SpriteFile = "Textures/PowerUps/InkBlaster.png";
+	} else if (PowerKraken) { 
+		e.SpriteFile = "Textures/PowerUps/RealeaseTheKraken.png";
+	}
+	else {
 		e.EmitterLifeTime = 4;
-	//- glm::atan(event.Normal.x, event.Normal.y
 		e.EmittingAngle = glm::half_pi<float>();
 		e.Spread = 0.5f;
 		e.NumberOfTicks = 1;
@@ -715,8 +811,12 @@ bool dd::Systems::PhysicsSystem::OnContact(const dd::Events::Contact &event)
 		e.SpriteFile = "Textures/Particles/Cloud_Particle.png";
 		e.Color = model->Color + glm::vec4(0.5f);
 		e.Speed = 100;
+	}
+
 	EventBroker->Publish(e);
 	return true;
+
+	
 }