diff --git a/assets/Sounds/Brick/LTTP_Boss_Hit.wav b/assets/Sounds/Brick/LTTP_Boss_Hit.wav
new file mode 100644
index 0000000..b8d4f01
Binary files /dev/null and b/assets/Sounds/Brick/LTTP_Boss_Hit.wav differ
diff --git a/include/Game/CBrick.h b/include/Game/CBrick.h
index a264125..e120fdb 100644
--- a/include/Game/CBrick.h
+++ b/include/Game/CBrick.h
@@ -19,6 +19,7 @@ struct Brick : Component
 	//0 = empty, 1 = normal, 2 = multi-brick, 3 = lifebuoy, 4 = sticky, 5 = blaster, 6 = kraken
     int Type = 0;
     bool Removed = false;
+	int Number = 0; // For the Kraken to keep track of which bricks needs replacing.
 
 	//What number of types each is.
 	const int EmptyBrickSpace = 0;
diff --git a/include/Game/CKraken.h b/include/Game/CKraken.h
index 48ac112..41c831d 100644
--- a/include/Game/CKraken.h
+++ b/include/Game/CKraken.h
@@ -16,7 +16,14 @@ namespace Components
 struct Kraken : Component {
 
     int Health = 10;
-
+	int CurrentAction = 1;
+	
+	const int Idle = 1;
+	const int Grabbing = 2;
+	const int Taunting = 3;
+	const int Moving = 4;
+	const int BrickGenerating = 5;
+	// Idle. Generating bricks. Taunting. No idea.
 };
 
 }
diff --git a/include/Game/EBrickGenerating.h b/include/Game/EBrickGenerating.h
new file mode 100644
index 0000000..6debb0b
--- /dev/null
+++ b/include/Game/EBrickGenerating.h
@@ -0,0 +1,27 @@
+//
+// Created by Adniklastrator on 2015-10-16.
+//
+
+#ifndef DAYDREAM_EBRICKGENERATING_H
+#define DAYDREAM_EBRICKGENERATING_H
+
+#include "Core/EventBroker.h"
+
+namespace dd
+{
+
+namespace Events
+{
+
+struct BrickGenerating : Event
+{
+	glm::vec3 Origin;
+	int TargetLine;
+	int Set;
+};
+
+}
+
+}
+
+#endif //DAYDREAM_EBRICKGENERATING_H
diff --git a/include/Game/KrakenSystem.h b/include/Game/KrakenSystem.h
index a94aa38..63eca64 100644
--- a/include/Game/KrakenSystem.h
+++ b/include/Game/KrakenSystem.h
@@ -5,6 +5,7 @@
 #ifndef DAYDREAM_KRAKENSYSTEM_H
 #define DAYDREAM_KRAKENSYSTEM_H
 
+#include <random>
 
 #include "Core/System.h"
 #include "Core/CTransform.h"
@@ -15,9 +16,11 @@
 #include "Physics/CRectangleShape.h"
 #include "Physics/CCircleShape.h"
 #include "Physics/CPhysics.h"
+#include "Physics/EContact.h"
 #include "Game/EPause.h"
 #include "Game/EKrakenAppear.h"
 #include "Game/EKrakenAttack.h"
+#include "Game/EBrickGenerating.h"
 #include "Game/CTravels.h"
 #include "Game/CKraken.h"
 #include "Sound/CCollisionSound.h"
@@ -40,20 +43,37 @@ public:
     void Initialize() override;
 	void InitializeObjects();
 
+	void Update(double dt) override;
 	void UpdateEntity(double dt, EntityID entity, EntityID parent) override;
 
     bool IsPaused() const { return m_Pause; }
     void SetPause(const bool& pause) { m_Pause = pause; }
 private:
+	std::mt19937 m_RandomGenerator;
+
 	bool m_Pause = false;
+	bool m_KrakenBattle = false;
+	bool m_ReturnToIdle = false;
 	EntityID m_KrakenTemplate;
+	std::string m_Action = "Idle";
+	float m_KrakenTimer = 0;
+	float m_KrakenSecondsToAction = 1;
+	const int Idle = 1;
+
+	std::array<int, 14> m_Bricks;
+	std::array<int, 14> m_Colors;
 
     dd::EventRelay<KrakenSystem, dd::Events::Pause> m_EPause;
+	dd::EventRelay<KrakenSystem, dd::Events::Contact> m_EContact;
 	dd::EventRelay<KrakenSystem, dd::Events::KrakenAppear> m_EKrakenAppear;
 	dd::EventRelay<KrakenSystem, dd::Events::KrakenAttack> m_EKrakenAttack;
+	dd::EventRelay<KrakenSystem, dd::Events::BrickGenerating> m_EBrickGenerating;
     bool OnPause(const dd::Events::Pause &event);
+	bool OnContact(const dd::Events::Contact &event);
 	bool OnKrakenAppear(const dd::Events::KrakenAppear &event);
 	bool OnKrakenAttack(const dd::Events::KrakenAttack &event);
+	bool OnBrickGenerating(const dd::Events::BrickGenerating &event);
+	void GetBrickSet();
 };
 
 }
diff --git a/include/Game/LevelSystem.h b/include/Game/LevelSystem.h
index 08a8aca..56eb49f 100755
--- a/include/Game/LevelSystem.h
+++ b/include/Game/LevelSystem.h
@@ -50,6 +50,7 @@
 #include "Game/EPowerUpTaken.h"
 
 #include "Game/EKrakenAppear.h"
+#include "Game/EBrickGenerating.h"
 
 #include "Physics/CPhysics.h"
 #include "Physics/CCircleShape.h"
@@ -91,7 +92,7 @@ public:
 
     void CreateBasicLevel(int, int, glm::vec2, float);
     void CreateLevel(int);
-    void CreateBrick(int, int, glm::vec2, float, int, int, int, glm::vec4);
+    EntityID CreateBrick(int, int, glm::vec2, float, int, int, int, glm::vec4);
 	void BrickHit(EntityID, EntityID, int);
 
     void OnEntityRemoved(EntityID entity);
@@ -135,7 +136,7 @@ private:
     bool m_Initialized = false;
     bool m_Pause = false;
     int m_LooseBricks = 0;
-    int m_CurrentCluster = 0;
+    int m_CurrentCluster = 1;
     int m_CurrentLevel = 1;
     int m_MultiBalls = 0;
     int m_PowerUps = 0;
@@ -162,6 +163,9 @@ private:
     std::array<int, 42> m_Bricks;
 	std::array<glm::vec4, 42> m_Colors;
 
+	std::array<int, 14> m_BrickSet;
+	std::array<glm::vec4, 14> m_ColorSet;
+
     dd::EventRelay<LevelSystem, dd::Events::Contact> m_EContact;
     dd::EventRelay<LevelSystem, dd::Events::ScoreEvent> m_EScoreEvent;
     dd::EventRelay<LevelSystem, dd::Events::MultiBall> m_EMultiBall;
@@ -171,6 +175,7 @@ private:
     dd::EventRelay<LevelSystem, dd::Events::StageCleared> m_EStageCleared;
     dd::EventRelay<LevelSystem, dd::Events::Pause> m_EPause;
     dd::EventRelay<LevelSystem, dd::Events::HitPad> m_EHitPad;
+	dd::EventRelay<LevelSystem, dd::Events::BrickGenerating> m_EBrickGenerating;
 
     bool OnContact(const dd::Events::Contact &event);
     bool OnScoreEvent(const dd::Events::ScoreEvent &event);
@@ -181,6 +186,8 @@ private:
     bool OnStageCleared(const dd::Events::StageCleared &event);
     bool OnPause(const dd::Events::Pause &event);
     bool OnHitPad(const dd::Events::HitPad &event);
+	bool OnBrickGenerating(const dd::Events::BrickGenerating &event);
+	void GetBrickSet(int Set);
 
     void GetNextLevel();
 	void SetBrokenModel(EntityID entity);
diff --git a/include/Game/PadSystem.h b/include/Game/PadSystem.h
index b1cd6ce..28ace94 100755
--- a/include/Game/PadSystem.h
+++ b/include/Game/PadSystem.h
@@ -49,6 +49,8 @@
 #include "Game/EScreenShake.h"
 #include "Game/EActionButton.h"
 
+#include "Game/EBrickGenerating.h"
+
 
 namespace dd
 {
diff --git a/include/Game/ScreenShakeSystem.h b/include/Game/ScreenShakeSystem.h
index 4755fbb..2f8b15f 100644
--- a/include/Game/ScreenShakeSystem.h
+++ b/include/Game/ScreenShakeSystem.h
@@ -5,6 +5,7 @@
 #ifndef DAYDREAM_SCREENSHAKESYSTEM_H
 #define DAYDREAM_SCREENSHAKESYSTEM_H
 
+#include <random>
 
 #include "Core/System.h"
 #include "Core/CTransform.h"
@@ -38,6 +39,8 @@ public:
     bool IsPaused() const { return m_Pause; }
     void SetPause(const bool& pause) { m_Pause = pause; }
 private:
+	std::mt19937 m_RandomGenerator;
+
     bool m_Pause;
 	bool m_ScreenShake;
 	int m_ShakeIntensity;
diff --git a/src/game/Game/BallSystem.cpp b/src/game/Game/BallSystem.cpp
index 1d90cc5..462084e 100644
--- a/src/game/Game/BallSystem.cpp
+++ b/src/game/Game/BallSystem.cpp
@@ -31,7 +31,7 @@ void dd::Systems::BallSystem::Initialize()
     {
         auto ent = m_World->CreateEntity();
         std::shared_ptr<Components::Transform> transform = m_World->AddComponent<Components::Transform>(ent);
-        transform->Position = glm::vec3(0.f, 0.26f, -10.f);
+        transform->Position = glm::vec3(-20.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);
diff --git a/src/game/Game/KrakenSystem.cpp b/src/game/Game/KrakenSystem.cpp
index 0fe0614..5c8aad8 100644
--- a/src/game/Game/KrakenSystem.cpp
+++ b/src/game/Game/KrakenSystem.cpp
@@ -7,15 +7,20 @@
 
 void dd::Systems::KrakenSystem::Initialize()
 {
+	std::random_device rd;
+	m_RandomGenerator = std::mt19937(rd());
     EVENT_SUBSCRIBE_MEMBER(m_EPause, &KrakenSystem::OnPause);
 	EVENT_SUBSCRIBE_MEMBER(m_EKrakenAppear, &KrakenSystem::OnKrakenAppear);
 	EVENT_SUBSCRIBE_MEMBER(m_EKrakenAttack, &KrakenSystem::OnKrakenAttack);
+	EVENT_SUBSCRIBE_MEMBER(m_EBrickGenerating, &KrakenSystem::OnBrickGenerating);
 
 	EntityID ent = m_World->CreateEntity();
 	auto transform = m_World->AddComponent<Components::Transform>(ent);
 	auto model = m_World->AddComponent<Components::Model>(ent);
-	std::shared_ptr<Components::CircleShape> cCircle = m_World->AddComponent<Components::CircleShape>(ent);
-	cCircle->Radius = 2;
+	auto kraken = m_World->AddComponent<Components::Kraken>(ent);
+	std::shared_ptr<Components::RectangleShape> cCircle = m_World->AddComponent<Components::RectangleShape>(ent);
+	cCircle->Dimensions = glm::vec2(2, 4);
+	//cCircle->Radius = 2;
 	std::shared_ptr<Components::Physics> cPhys = m_World->AddComponent<Components::Physics>(ent);
 	std::shared_ptr<Components::Template> cTemplate = m_World->AddComponent<Components::Template>(ent);
 
@@ -31,7 +36,7 @@ void dd::Systems::KrakenSystem::Initialize()
 	transform->Position = glm::vec3(50, 50, -10);
 	//sound
 	auto collisionSound = m_World->AddComponent<Components::CollisionSound>(ent);
-	collisionSound->FilePath = "Sounds/Brick/shortbrickbreak.wav";
+	collisionSound->FilePath = "Sounds/Brick/LTTP_Boss_Hit.wav";
 	m_World->CommitEntity(ent);
 
 	m_KrakenTemplate = ent;
@@ -44,16 +49,66 @@ void dd::Systems::KrakenSystem::InitializeObjects()
 
 }
 
+void dd::Systems::KrakenSystem::Update(double dt)
+{
+
+}
+
 void dd::Systems::KrakenSystem::UpdateEntity(double dt, EntityID entity, EntityID parent)
 {
     if (IsPaused()) {
         return;
     }
 
+	auto templateCheck = m_World->GetComponent<Components::Template>(entity);
+	if (templateCheck != nullptr){ return; }
+
+	auto kraken = m_World->GetComponent<Components::Kraken>(entity);
+	if (kraken != nullptr) {
+		Events::KrakenAttack krakenAttack;
+		switch (kraken->CurrentAction)
+		{
+		case 1: // Idle
+			//m_KrakenTimer += dt;
+			if (m_KrakenTimer > m_KrakenSecondsToAction) {
+				m_KrakenTimer = 0;
+				std::uniform_real_distribution<float> dist(1, 2.999f);
+				float random = dist(m_RandomGenerator);
+				std::cout << random << std::endl;
+				kraken->CurrentAction = random;
+				std::cout << kraken->CurrentAction << std::endl;
+			}
+			break;
+		case 2: // Grabbing
+			kraken->CurrentAction = 5;
+			krakenAttack.ChargeUpdate = 0;
+			krakenAttack.KrakenStrength = 0.1;
+			krakenAttack.PlayerStrength = 0.05;
+			EventBroker->Publish(krakenAttack);
+			break;
+		case 3: // Brick Generating
+			break;
+		case 4: // Moving
+			break;
+		case 5: // Taunting
+			if (m_ReturnToIdle) {
+				m_ReturnToIdle = false;
+				kraken->CurrentAction = Idle;
+			}
+			break;
+		default:
+			//LOG_INFO("Something's probably off about the random number generator.");
+			break;
+		}
+	}
 }
 
 bool dd::Systems::KrakenSystem::OnPause(const dd::Events::Pause &event)
 {
+	if (event.Type != "KrakenSystem" && event.Type != "All") {
+		return false;
+	}
+
     if (IsPaused()) {
         SetPause(false);
     } else {
@@ -68,11 +123,19 @@ bool dd::Systems::KrakenSystem::OnKrakenAppear(const dd::Events::KrakenAppear &e
 	m_World->RemoveComponent<Components::Template>(ent);
 	auto transform = m_World->GetComponent<Components::Transform>(ent);
 	transform->Position = event.Position;
+	m_KrakenBattle = true;
 	return true;
 }
 
 bool dd::Systems::KrakenSystem::OnKrakenAttack(const dd::Events::KrakenAttack &event)
 {
-	
+	if (event.ChargeUpdate >= 1) {
+		m_ReturnToIdle = true;
+	}
 	return true;
 }
+
+bool dd::Systems::KrakenSystem::OnBrickGenerating(const dd::Events::BrickGenerating &event)
+{
+	return true;
+}
\ No newline at end of file
diff --git a/src/game/Game/LevelSystem.cpp b/src/game/Game/LevelSystem.cpp
index 9f93bfa..000a9d3 100755
--- a/src/game/Game/LevelSystem.cpp
+++ b/src/game/Game/LevelSystem.cpp
@@ -20,6 +20,7 @@ void dd::Systems::LevelSystem::Initialize()
 	EVENT_SUBSCRIBE_MEMBER(m_EStageCleared, &LevelSystem::OnStageCleared);
 	EVENT_SUBSCRIBE_MEMBER(m_EPause, &LevelSystem::OnPause);
 	EVENT_SUBSCRIBE_MEMBER(m_EHitPad, &LevelSystem::OnHitPad);
+	EVENT_SUBSCRIBE_MEMBER(m_EBrickGenerating, &LevelSystem::OnBrickGenerating);
 
 	//PointLightTest
 	{
@@ -389,11 +390,11 @@ void dd::Systems::LevelSystem::CreateLevel(int aboveBasicLevel)
     SetRestarting(false);
 }
 
-void dd::Systems::LevelSystem::CreateBrick(int row, int line, glm::vec2 spacesBetweenBricks, float spaceToEdge, int aboveLevel, int num, int typeInt, glm::vec4 colorVec)
+EntityID dd::Systems::LevelSystem::CreateBrick(int row, int line, glm::vec2 spacesBetweenBricks, float spaceToEdge, int aboveLevel, int num, int typeInt, glm::vec4 colorVec)
 {
     if (typeInt == EmptyBrickSpace) {
         SetNumberOfBricks(NumberOfBricks() - 1);
-        return;
+        return NULL;
     }
     auto brick = m_World->CloneEntity(m_BrickTemplate);
     m_World->RemoveComponent<Components::Template>(brick);
@@ -436,13 +437,128 @@ void dd::Systems::LevelSystem::CreateBrick(int row, int line, glm::vec2 spacesBe
 		e.Health = 10;
 		EventBroker->Publish(e);
 		m_World->RemoveEntity(brick);
-		return;
+		return brick;
 	}
 
     cBrick->Score = 10 * num;
-    return;
+    return brick;
 }
 
+bool dd::Systems::LevelSystem::OnBrickGenerating(const dd::Events::BrickGenerating &event)
+{
+	GetBrickSet(event.Set);
+	LOG_DEBUG("This is happening.");
+
+	int rows = 2;
+	int lines = 7;
+	int getter = 0;
+	for (int i = 0; i < rows; i++) {
+		for (int j = 0; j < lines; j++) {
+			auto ent = CreateBrick(i, j, SpaceBetweenBricks(), SpaceToEdge(), -4, 1, m_BrickSet[getter], m_ColorSet[getter]);
+			if (ent != NULL) {
+				auto transform = m_World->GetComponent<Components::Transform>(ent);
+				Events::Move e;
+				e.GoalPosition = transform->Position;
+				transform->Position = event.Origin;
+				e.Entity = ent;
+				e.Speed = 6;
+				e.Queue = false;
+				EventBroker->Publish(e);
+				m_LooseBricks++;
+				SetNumberOfBricks(NumberOfBricks() + 1);
+			}
+			getter++;
+		}
+	}
+	return true;
+}
+
+void dd::Systems::LevelSystem::GetBrickSet(int set)
+{
+	std::array<int, 14> level;
+	std::array<glm::vec4, 14> color;
+	// Level array indicates type of brick.
+	// 0 is empty space.
+	// 1 is standard brick.
+	// 2 is multiball brick.
+	// 3 is lifebuoy brick.
+	// 4 is sticky brick.
+	// 5 is ink blaster brick.
+	// 6 is kraken attack brick.
+
+	// color array determines the color of standard bricks.
+	// w is white.
+	// r is red.
+	// g is green.
+	// b is blue.
+	// y is yellow.
+	// c is cyan.
+	// m is magenta.
+	// d is dark.
+	// Feel free to make your own.
+	glm::vec4 w = glm::vec4(1, 1, 1, 0);
+	glm::vec4 r = glm::vec4(1, 0, 0, 0);
+	glm::vec4 g = glm::vec4(0, 1, 0, 0);
+	glm::vec4 b = glm::vec4(0, 0, 1, 0);
+	glm::vec4 y = glm::vec4(1, 1, 0, 0);
+	glm::vec4 c = glm::vec4(0, 1, 1, 0);
+	glm::vec4 m = glm::vec4(1, 0, 1, 0);
+	glm::vec4 d = glm::vec4(0, 0, 0, 0);
+
+	if (set == 1) {
+		level =
+		{1, 1, 1, 1, 1, 1, 1,
+		 1, 1, 1, 1, 1, 1, 1 };
+		color =
+		{r, r, r, r, r, r, r,
+		 r, r, r, r, r, r, r };
+	}
+	else if (set == 2) {
+		level =
+		{2, 2, 2, 2, 2, 2, 2,
+		 2, 2, 2, 2, 2, 2, 2 };
+		color =
+		{w, w, w, w, w, w, w,
+		 w, w, w, w, w, w, w };
+	}
+	else if (set == 3) {
+		level =
+		{0, 0, 0, 0, 0, 0, 0,
+		 0, 0, 0, 0, 0, 0, 0 };
+		color =
+		{w, w, w, w, w, w, w,
+		 w, w, w, w, w, w, w };
+	}
+	else if (set == 4) {
+		level =
+		{0, 0, 0, 0, 0, 0, 0,
+		 0, 0, 0, 0, 0, 0, 0 };
+		color =
+		{w, w, w, w, w, w, w,
+		 w, w, w, w, w, w, w };
+	}
+	else if (set == 5) {
+		level =
+		{0, 0, 0, 0, 0, 0, 0,
+		 0, 0, 0, 0, 0, 0, 0 };
+		color =
+		{w, w, w, w, w, w, w,
+		 w, w, w, w, w, w, w };
+	}
+	else if (set == 6) {
+		level =
+		{0, 0, 0, 1, 0, 0, 0,
+		 0, 0, 0, 0, 0, 0, 0 };
+		color =
+		{w, w, w, w, w, w, w,
+		 w, w, w, w, w, w, w };
+	}
+
+	std::copy(std::begin(level), std::end(level), std::begin(m_BrickSet));
+	std::copy(std::begin(color), std::end(color), std::begin(m_ColorSet));
+}
+
+
 void dd::Systems::LevelSystem::OnEntityRemoved(EntityID entity)
 {
 
@@ -710,7 +826,7 @@ void dd::Systems::LevelSystem::GetNextLevel()
 
 	// 100 is KRAKEN!
 
-	// wolor array determines the color of standard bricks.
+	// color array determines the color of standard bricks.
 	// w is white.
 	// r is red.
 	// g is green.
@@ -746,12 +862,12 @@ void dd::Systems::LevelSystem::GetNextLevel()
     if (m_CurrentCluster == 0) {
         if (m_CurrentLevel == 1) {
             level =
-                    {1, 0, 0, 0, 0, 0, 0,
+                    {0, 0, 0, 0, 0, 0, 0,
                      0, 0, 0, 0, 0, 0, 0,
                      0, 0, 0, 0, 0, 0, 0,
                      0, 0, 0, 0, 0, 0, 0,
                      0, 0, 0, 0, 0, 0, 0,
-                     0, 0, 0, 0, 0, 0, 0};
+                     0, 0, 0, 0, 0, 0, 1};
 			color = 
 					{w, w, w, w, w, w, w,
 					 w, w, w, w, w, w, w,
@@ -761,9 +877,9 @@ void dd::Systems::LevelSystem::GetNextLevel()
 					 w, w, w, w, w, w, w};
         } else if (m_CurrentLevel == 2) {
             level =
-                    {0, 0, 0, 0, 0, 0, 1,
-                     0, 0, 0, 0, 0, 0, 0,
+                    {0, 0, 0, 0, 0, 0, 0,
                      0, 0, 0, 0, 0, 0, 0,
+                     0, 0, 0, 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};
@@ -808,7 +924,7 @@ 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, 1, 0, 0, 0,
                      0, 0, 0, 0, 0, 0, 0,
                      0, 0, 0, 0, 0, 0, 0,
                      0, 0, 0, 0, 0, 0, 0};
diff --git a/src/game/Game/PadSystem.cpp b/src/game/Game/PadSystem.cpp
index bc58553..97fb384 100755
--- a/src/game/Game/PadSystem.cpp
+++ b/src/game/Game/PadSystem.cpp
@@ -234,6 +234,11 @@ bool dd::Systems::PadSystem::OnKeyDown(const dd::Events::KeyDown &event) {
 		e.Time = 3;
 		e.TimeTakenToCoolDown = 10;
 		EventBroker->Publish(e);
+	} else if (val == GLFW_KEY_G) {
+		Events::BrickGenerating e;
+		e.Origin = glm::vec3(-5, 7, -10);
+		e.Set = 1;
+		EventBroker->Publish(e);
 	} else if (val == GLFW_KEY_L) {
 		Events::Lifebuoy e;
 		e.Transform = Transform();
diff --git a/src/game/Game/ScreenShakeSystem.cpp b/src/game/Game/ScreenShakeSystem.cpp
index e5166fa..ec322da 100644
--- a/src/game/Game/ScreenShakeSystem.cpp
+++ b/src/game/Game/ScreenShakeSystem.cpp
@@ -7,6 +7,8 @@
 
 void dd::Systems::ScreenShakeSystem::Initialize()
 {
+	std::random_device rd;
+	m_RandomGenerator = std::mt19937(rd());
     EVENT_SUBSCRIBE_MEMBER(m_EPause, &ScreenShakeSystem::OnPause);
     EVENT_SUBSCRIBE_MEMBER(m_EScreenShake, &ScreenShakeSystem::OnScreenShake);
 
@@ -55,13 +57,15 @@ void dd::Systems::ScreenShakeSystem::UpdateEntity(double dt, EntityID entity, En
 			else {
 				//std::cout << "Timer: " << m_ShakeTimer << " End: " << m_ShakeEndTime << std::endl;
 			}
-			m_Random.x = (rand() % m_ShakeIntensity);
-			m_Random.y = (rand() % m_ShakeIntensity);
+			std::uniform_real_distribution<float> dist(-m_ShakeIntensity, m_ShakeIntensity);
+			//float impulseStrength = dist(m_RandomGenerator);
+			m_Random.x = dist(m_RandomGenerator) / 20;
+			m_Random.y = dist(m_RandomGenerator) / 20;
 
-			float half = m_ShakeIntensity / 2;
+			//float half = m_ShakeIntensity / 2;
 
-			m_Random.x = (m_Random.x - half) / 20;
-			m_Random.y = (m_Random.y - half) / 20;
+			//m_Random.x = (m_Random.x - half) / 20;
+			//m_Random.y = (m_Random.y - half) / 20;
 
 			//std::cout << "X: " << randomX << " Y: " << randomY << std::endl;
 			transform->Position = glm::vec3(m_Random);
@@ -73,6 +77,10 @@ void dd::Systems::ScreenShakeSystem::UpdateEntity(double dt, EntityID entity, En
 
 bool dd::Systems::ScreenShakeSystem::OnPause(const dd::Events::Pause &event)
 {
+	if (event.Type != "ScreenShakeSystem" && event.Type != "All") {
+		return false;
+	}
+
     if (IsPaused()) {
         SetPause(false);
     } else {