Merge remote-tracking branch 'origin' into Tobias

include/Game/CBrick.h

@@ -19,7 +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.
+	int Number = 100; // For the Kraken to keep track of which bricks needs replacing.
 
 	//What number of types each is.
 	const int EmptyBrickSpace = 0;

include/Game/CKraken.h

@@ -15,7 +15,8 @@ namespace Components
 
 struct Kraken : Component {
 
-    int Health = 10;
+    int MaxHealth = 30;
+	int Health = MaxHealth;
 	int CurrentAction = 1;
 	
 	const int Idle = 1;

include/Game/EBrickGenerating.h

@@ -15,7 +15,8 @@ namespace Events
 
 struct BrickGenerating : Event
 {
-	glm::vec3 Origin;
+	glm::vec3 Origin1;
+	glm::vec3 Origin2;
 	int TargetLine;
 	int Set;
 };

include/Game/EKrakenHit.h

@@ -17,6 +17,9 @@ struct KrakenHit : Event
 {
 	EntityID Kraken;
 	EntityID Hitter;
+	int MaxHealth;
+	int CurrentHealth;
+	int NewHealth;
 };
 
 }

include/Game/GUI/HUD.h

@@ -76,17 +76,17 @@ private:
 	{
 		m_ScoreNumberFrame->SetLeft(Width / 2.f - m_ScoreNumberFrame->Width / 2.f);
 
-		m_ScoreBackMid->SetLeft(m_ScoreNumberFrame->Left());
 		m_ScoreBackMid->Width = m_ScoreNumberFrame->Width;
 		m_ScoreBackMid->Height = m_ScoreNumberFrame->Height + 35;
+		m_ScoreBackMid->SetLeft(m_ScoreNumberFrame->Left() + 4);
 
-		m_ScoreBackLeft->SetRight(m_ScoreBackMid->Left());
+		//m_ScoreBackLeft->Width = 40;
-		m_ScoreBackLeft->Width = 40;
 		m_ScoreBackLeft->Height = m_ScoreBackMid->Height;
+		m_ScoreBackLeft->SetRight(m_ScoreBackMid->Left());
 
-		m_ScoreBackRight->SetLeft(m_ScoreBackMid->Right());
+		//m_ScoreBackRight->Width = 40;
-		m_ScoreBackRight->Width = 40;
 		m_ScoreBackRight->Height = m_ScoreBackMid->Height;
+		m_ScoreBackRight->SetLeft(m_ScoreBackMid->Right());
 	}
 
 	bool OnScore(const Events::ScoreEvent& event)

include/Game/KrakenSystem.h

@@ -62,12 +62,13 @@ private:
 	bool m_ReturnToIdle = false;
 	EntityID m_KrakenTemplate;
 	std::string m_Action = "Idle";
+	int m_NumberOfActions;
 	float m_KrakenTimer = 0;
-	float m_KrakenSecondsToAction = 1;
+	float m_KrakenSecondsToAction = 10;
 	const int Idle = 1;
 
-	std::array<int, 14> m_Bricks;
+	std::array<int, 42> m_Bricks;
-	std::array<int, 14> m_Colors;
+	std::array<int, 42> m_Colors;
 
     dd::EventRelay<KrakenSystem, dd::Events::Pause> m_EPause;
 	dd::EventRelay<KrakenSystem, dd::Events::Resume> m_EResume;

include/Game/LevelSystem.h

@@ -172,8 +172,12 @@ private:
     std::array<int, 42> m_Bricks;
 	std::array<glm::vec4, 42> m_Colors;
 
-	std::array<int, 14> m_BrickSet;
+	std::array<int, 42> m_BrickSet;
-	std::array<glm::vec4, 14> m_ColorSet;
+	std::array<glm::vec4, 42> m_ColorSet;
+	std::array<bool, 42> m_KrakenBricks;
+
+	bool m_BrickGenerating = false;
+	dd::Events::BrickGenerating m_BrickGeneratingEvent;
 
     dd::EventRelay<LevelSystem, dd::Events::Contact> m_EContact;
     dd::EventRelay<LevelSystem, dd::Events::ScoreEvent> m_EScoreEvent;
@@ -201,6 +205,7 @@ private:
 	bool OnResume(const dd::Events::Resume &event);
     bool OnHitPad(const dd::Events::HitPad &event);
 	bool OnBrickGenerating(const dd::Events::BrickGenerating &event);
+	bool BrickGenerating(const dd::Events::BrickGenerating &event);
 	void GetBrickSet(int Set);
 	bool OnKrakenDefeated(const dd::Events::KrakenDefeated &event);
 

src/game/Game/KrakenSystem.cpp

@@ -80,10 +80,14 @@ void dd::Systems::KrakenSystem::UpdateEntity(double dt, EntityID entity, EntityI
 		switch (kraken->CurrentAction)
 		{
 		case 1: // Idle
-			//m_KrakenTimer += dt;
+			m_KrakenTimer += dt;
 			if (m_KrakenTimer > m_KrakenSecondsToAction) {
+				if (m_NumberOfActions == 0) {
+					kraken->CurrentAction = 3;
+					break;
+				}
 				m_KrakenTimer = 0;
-				std::uniform_real_distribution<float> dist(1, 2.999f);
+				std::uniform_real_distribution<float> dist(1, 4.999f);
 				float random = dist(m_RandomGenerator);
 				//std::cout << random << std::endl;
 				kraken->CurrentAction = random;
@@ -98,9 +102,29 @@ void dd::Systems::KrakenSystem::UpdateEntity(double dt, EntityID entity, EntityI
 			EventBroker->Publish(krakenAttack);
 			break;
 		case 3: // Brick Generating
-			break;
+			{
-		case 4: // Moving
+				kraken->CurrentAction = 1;
-			break;
+				Events::BrickGenerating e;
+				e.Origin1 = glm::vec3(-5, 7, -10);
+				e.Origin2 = glm::vec3(5, 7, -10);
+				std::uniform_real_distribution<float> dist(1, 5.999f);
+				float random = dist(m_RandomGenerator);
+				e.Set = random;
+				EventBroker->Publish(e);
+				break;
+			}
+		case 4: // Brick Generating second case
+			{
+				kraken->CurrentAction = 1;
+				Events::BrickGenerating e;
+				e.Origin1 = glm::vec3(-5, 7, -10);
+				e.Origin2 = glm::vec3(5, 7, -10);
+				std::uniform_real_distribution<float> dist(1, 5.999f);
+				float random = dist(m_RandomGenerator);
+				e.Set = random;
+				EventBroker->Publish(e);
+				break;
+			}
 		case 5: // Taunting
 			if (m_ReturnToIdle) {
 				m_ReturnToIdle = false;
@@ -166,6 +190,9 @@ bool dd::Systems::KrakenSystem::OnContact(const dd::Events::Contact &event)
 		Events::KrakenHit e;
 		e.Kraken = krakenEntity;
 		e.Hitter = otherEntitiy;
+		e.MaxHealth = kraken->MaxHealth;
+		e.CurrentHealth = kraken->Health;
+		e.NewHealth = kraken->Health - 1;
 		EventBroker->Publish(e);
 	}
 }
@@ -191,9 +218,9 @@ bool dd::Systems::KrakenSystem::OnKrakenAttack(const dd::Events::KrakenAttack &e
 bool dd::Systems::KrakenSystem::OnKrakenHit(const dd::Events::KrakenHit &event)
 {
 	auto kraken = m_World->GetComponent<Components::Kraken>(event.Kraken);
-	//kraken->Health--;
+	kraken->Health--;
 	//std::cout << kraken->Health << std::endl;
-	kraken->Health = -1;
+	//kraken->Health = -1;
 	if (kraken->Health < 0) {
 		Events::KrakenDefeated e;
 		e.Kraken = event.Kraken;
@@ -210,9 +237,9 @@ bool dd::Systems::KrakenSystem::OnKrakenDefeated(const dd::Events::KrakenDefeate
 	auto kraken = m_World->GetComponent<Components::Kraken>(event.Kraken);
 	auto physicsComponent = m_World->GetComponent<Components::Physics>(event.Kraken);
 	/*physicsComponent->CollisionType = CollisionType::Type::Dynamic;
-	physicsComponent->GravityScale = 1.f;
+	physicsComponent->GravityScale = 1.f;*/
 	physicsComponent->Mask = static_cast<CollisionLayer::Type>(CollisionLayer::Water | CollisionLayer::Wall);
-	physicsComponent->Calculate = false;*/
+	/*physicsComponent->Calculate = false;*/
 
 	auto transformComponentBrick = m_World->GetComponent<Components::Transform>(event.Kraken);
 	auto transformComponentHitter = m_World->GetComponent<Components::Transform>(event.Hitter);

src/game/Game/LevelSystem.cpp

@@ -248,6 +248,9 @@ void dd::Systems::LevelSystem::Update(double dt)
     if (!m_Initialized) {
         GetNextLevel();
         CreateLevel(0);
+		for (int i = 0; i < m_KrakenBricks.size(); i++) {
+			m_KrakenBricks[i] = false;
+		}
         m_Initialized = true;
     }
 }
@@ -456,26 +459,41 @@ EntityID dd::Systems::LevelSystem::CreateBrick(int row, int line, glm::vec2 spac
 
 bool dd::Systems::LevelSystem::OnBrickGenerating(const dd::Events::BrickGenerating &event)
 {
-	GetBrickSet(event.Set);
+	m_BrickGenerating = true;
-	LOG_DEBUG("This is happening.");
+	m_BrickGeneratingEvent = event;
+	return true;
+}
 
-	int rows = 2;
+bool dd::Systems::LevelSystem::BrickGenerating(const dd::Events::BrickGenerating &event)
+{
+	GetBrickSet(event.Set);
+
+	int rows = 6;
 	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 (!m_KrakenBricks[getter]) {
-			if (ent != NULL) {
+				auto ent = CreateBrick(i, j, SpaceBetweenBricks(), SpaceToEdge(), -3.2, 1, m_BrickSet[getter], m_ColorSet[getter]);
-				auto transform = m_World->GetComponent<Components::Transform>(ent);
+				if (ent != NULL) {
-				Events::Move e;
+					auto brick = m_World->GetComponent<Components::Brick>(ent);
-				e.GoalPosition = transform->Position;
+					brick->Number = getter;
-				transform->Position = event.Origin;
+					m_KrakenBricks[getter] = true;
-				e.Entity = ent;
+					auto transform = m_World->GetComponent<Components::Transform>(ent);
-				e.Speed = 6;
+					Events::Move e;
-				e.Queue = false;
+					e.GoalPosition = transform->Position;
-				EventBroker->Publish(e);
+					if (j < 4) {
-				m_LooseBricks++;
+						transform->Position = event.Origin1;
-				SetNumberOfBricks(NumberOfBricks() + 1);
+					} else {
+						transform->Position = event.Origin2;
+					}
+					e.Entity = ent;
+					e.Speed = 6;
+					e.Queue = false;
+					EventBroker->Publish(e);
+					m_LooseBricks++;
+					SetNumberOfBricks(NumberOfBricks() + 1);
+				}
 			}
 			getter++;
 		}
@@ -483,10 +501,10 @@ bool dd::Systems::LevelSystem::OnBrickGenerating(const dd::Events::BrickGenerati
 	return true;
 }
 
-void dd::Systems::LevelSystem::GetBrickSet(int set)
+void dd::Systems::LevelSystem::GetBrickSet(int set) // These are sets the Kraken gets!
 {
-	std::array<int, 14> level;
+	std::array<int, 42> level;
-	std::array<glm::vec4, 14> color;
+	std::array<glm::vec4, 42> color;
 	// Level array indicates type of brick.
 	// 0 is empty space.
 	// 1 is standard brick.
@@ -517,51 +535,99 @@ void dd::Systems::LevelSystem::GetBrickSet(int set)
 
 	if (set == 1) {
 		level =
-		{1, 1, 1, 1, 1, 1, 1,
+		{1, 0, 0, 0, 0, 0, 1,
-		 1, 1, 1, 1, 1, 1, 1 };
+		 1, 0, 0, 0, 0, 0, 1,
+		 1, 0, 0, 0, 0, 0, 1,
+		 1, 1, 1, 1, 1, 1, 2,
+		 1, 1, 1, 1, 1, 1, 1,
+		 0, 0, 0, 0, 0, 0, 0};
 		color =
 		{r, r, r, r, r, r, r,
-		 r, r, r, r, r, r, r };
+		 r, r, r, r, r, r, r,
+		 r, r, r, r, r, r, r,
+		 r, r, r, r, r, r, r,
+		 r, r, r, r, r, r, r, 
+		 r, r, r, r, r, r, r};
 	}
 	else if (set == 2) {
 		level =
-		{2, 2, 2, 2, 2, 2, 2,
+		{0, 0, 0, 0, 0, 0, 0,
-		 2, 2, 2, 2, 2, 2, 2 };
+		 0, 0, 0, 0, 0, 0, 0,
+		 3, 0, 1, 0, 1, 0, 1,
+		 0, 1, 0, 1, 0, 1, 0,
+		 1, 0, 1, 0, 1, 0, 1,
+		 0, 0, 0, 0, 0, 0, 0};
 		color =
-		{w, w, w, w, w, w, w,
+		{y, y, y, y, y, y, y,
-		 w, w, w, w, w, w, w };
+		 y, y, y, y, y, y, y,
+		 y, y, y, y, y, y, y,
+		 y, y, y, y, y, y, y,
+		 y, y, y, y, y, y, y, 
+		 y, y, y, y, y, y, y};
 	}
 	else if (set == 3) {
 		level =
 		{0, 0, 0, 0, 0, 0, 0,
-		 0, 0, 0, 0, 0, 0, 0 };
+		 0, 0, 0, 0, 0, 0, 0,
+		 1, 0, 1, 0, 1, 0, 1,
+		 0, 1, 1, 1, 1, 1, 0,
+		 0, 0, 4, 1, 1, 0, 0,
+		 0, 0, 0, 1, 0, 0, 0};
 		color =
-		{w, w, w, w, w, w, w,
+		{b, b, b, b, b, b, b,
-		 w, w, w, w, w, w, w };
+		 b, b, b, b, b, b, b,
+		 b, b, b, b, b, b, b,
+		 b, b, b, b, b, b, b,
+		 b, b, b, b, b, b, b, 
+		 b, b, b, b, b, b, b};
 	}
 	else if (set == 4) {
 		level =
 		{0, 0, 0, 0, 0, 0, 0,
-		 0, 0, 0, 0, 0, 0, 0 };
+		 1, 1, 1, 1, 1, 3, 1,
+		 0, 0, 0, 0, 0, 0, 0,
+		 1, 1, 1, 1, 1, 1, 1,
+		 0, 0, 0, 0, 0, 0, 0,
+		 0, 0, 0, 0, 0, 0, 0};
 		color =
-		{w, w, w, w, w, w, w,
+		{m, m, m, m, m, m, m,
-		 w, w, w, w, w, w, w };
+		 m, m, m, m, m, m, m,
+		 m, m, m, m, m, m, m,
+		 m, m, m, m, m, m, m,
+		 m, m, m, m, m, m, m, 
+		 m, m, m, m, m, m, m};
 	}
 	else if (set == 5) {
 		level =
 		{0, 0, 0, 0, 0, 0, 0,
-		 0, 0, 0, 0, 0, 0, 0 };
+		 0, 1, 1, 0, 1, 1, 0,
+		 0, 1, 2, 0, 1, 1, 0,
+		 0, 1, 1, 0, 1, 1, 0,
+		 0, 1, 1, 0, 1, 1, 0,
+		 0, 0, 0, 0, 0, 0, 0};
 		color =
-		{w, w, w, w, w, w, w,
+		{g, g, g, g, g, g, g,
-		 w, w, w, w, w, w, w };
+		 g, g, g, g, g, g, g,
+		 g, g, g, g, g, g, g,
+		 g, g, g, g, g, g, g,
+		 g, g, g, g, g, g, g, 
+		 g, g, g, g, g, g, g};
 	}
 	else if (set == 6) {
 		level =
-		{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,
+		 0, 0, 0, 0, 0, 0, 0,
+		 1, 1, 1, 1, 1, 1, 1,
+		 1, 1, 1, 1, 1, 1, 1,
+		 0, 0, 0, 0, 0, 0, 0};
 		color =
-		{w, w, w, w, w, w, w,
+		{r, r, r, r, r, r, r, 
-		 w, w, w, w, w, w, w };
+		 r, r, r, r, r, r, r,
+		 r, r, r, r, r, r, r,
+		 r, r, r, r, r, r, r,
+		 r, r, r, r, r, r, r, 
+		 r, r, r, r, r, r, r};
 	}
 
 	std::copy(std::begin(level), std::end(level), std::begin(m_BrickSet));
@@ -576,6 +642,11 @@ void dd::Systems::LevelSystem::OnEntityRemoved(EntityID entity)
 
 bool dd::Systems::LevelSystem::OnContact(const dd::Events::Contact &event)
 {
+	auto templateCheck = m_World->GetComponent<Components::Template>(event.Entity1);
+	if (templateCheck != nullptr){ return false; }
+	templateCheck = m_World->GetComponent<Components::Template>(event.Entity2);
+	if (templateCheck != nullptr){ return false; }
+
     EntityID entityBrick;
     EntityID entityBall;
 	EntityID entityShot = 0;
@@ -653,10 +724,12 @@ void dd::Systems::LevelSystem::BrickHit(EntityID entityHitter, EntityID entityBr
 
 	auto transformComponentBrick = m_World->GetComponent<Components::Transform>(entityBrick);
 	auto transformComponentHitter = m_World->GetComponent<Components::Transform>(entityHitter);
-		
-
 	auto brickModel = m_World->GetComponent<Components::Model>(entityBrick);
 
+	if (brick->Number < 50) {
+		m_KrakenBricks[brick->Number] = false;
+	}
+
 	// Check if the brick is any kind of special.
 	auto multi = m_World->GetComponent<Components::MultiBallBrick>(entityBrick);
 	if (multi != nullptr) {
@@ -1121,6 +1194,10 @@ void dd::Systems::LevelSystem::GetNextLevel()
 bool dd::Systems::LevelSystem::OnHitPad(const dd::Events::HitPad &event)
 {
     m_Cleared = false;
+	if (m_BrickGenerating) {
+		m_BrickGenerating = false;
+		BrickGenerating(m_BrickGeneratingEvent);
+	}
     return true;
 }
 

src/game/Game/PadSystem.cpp

@@ -270,7 +270,8 @@ bool dd::Systems::PadSystem::OnKeyDown(const dd::Events::KeyDown &event) {
 		EventBroker->Publish(e);
 	} else if (val == GLFW_KEY_G) {
 		Events::BrickGenerating e;
-		e.Origin = glm::vec3(-5, 7, -10);
+		e.Origin1 = glm::vec3(-5, 7, -10);
+		e.Origin2 = glm::vec3(5, 7, -10);
 		e.Set = 1;
 		EventBroker->Publish(e);
 	} else if (val == GLFW_KEY_L) {