Added TravellingSystem for travelling to the next stage. Added incomplete ScreenShake. Ball now starts on pad.

include/Core/CTransform.h

@@ -43,7 +43,7 @@ struct Transform : public Component
 	glm::vec3 Scale;
 
 	// Sticky is if it sticks with the player or not. True means it will follow the camera.
-	bool Sticky;
+	bool Sticky = true;
 };
 
 }

include/Core/Engine.h

@@ -50,12 +50,15 @@
 #include "Game/CStickyAim.h"
 #include "Game/BallSystem.h"
 #include "Game/HitLagSystem.h"
+#include "Game/TravellingSystem.h"
 #include "Game/LifebuoySystem.h"
 #include "Game/ProjectileSystem.h"
 #include "Game/Bricks/CPowerUpBrick.h"
 
 #include "Game/BrickComponents.h"
 
+#include "Game/EScreenShake.h"
+
 #include "Physics/PhysicsSystem.h"
 #include "Physics/CPhysics.h"
 #include "Physics/CRectangleShape.h"
@@ -153,6 +156,9 @@ public:
 		m_World->SystemFactory.Register<Systems::PhysicsSystem>(
 				[this]() { return new Systems::PhysicsSystem(m_World.get(), m_EventBroker); });
 		m_World->AddSystem<Systems::PhysicsSystem>();
+		m_World->SystemFactory.Register<Systems::TravellingSystem>(
+			[this]() { return new Systems::TravellingSystem(m_World.get(), m_EventBroker); });
+		m_World->AddSystem<Systems::TravellingSystem>();
 
 		m_World->ComponentFactory.Register<Components::Model>();
 		m_World->ComponentFactory.Register<Components::Template>();
@@ -360,8 +366,10 @@ public:
 		//EVENT_SUBSCRIBE_MEMBER(m_EGameStart, &Engine::OnGameStart);
 		m_EGameStart = decltype(m_EGameStart)(std::bind(&Engine::OnGameStart, this, std::placeholders::_1));
 		m_EventBroker->Subscribe(m_EGameStart);
+		m_EScreenShake = decltype(m_EScreenShake)(std::bind(&Engine::OnScreenShake, this, std::placeholders::_1));
+		m_EventBroker->Subscribe(m_EScreenShake);
 
-			m_LastTime = glfwGetTime();
+		m_LastTime = glfwGetTime();
 	}
 
 	bool Running() const { return !glfwWindowShouldClose(m_Renderer->Window()); }
@@ -380,6 +388,9 @@ public:
 		//ResourceManager::Update();
 		if (m_GameIsRunning) {
 			m_World->Update(dt);
+
+			// I apologize about this.
+			ScreenShakeUpdate(dt);
 		}
 		m_EventBroker->Process<GUI::Frame>();
 		m_FrameStack->UpdateLayered(dt);
@@ -391,6 +402,8 @@ public:
 			TEMPAddToRenderQueue();
 		}
 
+		std::unique_ptr<dd::Camera> defaultCamera = nullptr;
+
 		// Render scene
 		//TODO send renderqueue to draw.
 		m_Renderer->Draw(m_RendererQueue);
@@ -550,6 +563,36 @@ public:
 		m_RendererQueue.Forward.Add(job);
 	}
 
+	void ScreenShakeUpdate(double dt)
+	{
+		if (m_ScreenShake) {
+			m_ShakeTimer += dt;
+			if (m_ShakeTimer >= m_ShakeEndTime) {
+				m_ShakeRepresentativeIntensity -= m_ShakeRepresentativeIntensity * 0.1 * dt;
+				m_ShakeIntensity = m_ShakeRepresentativeIntensity;
+				if (m_ShakeRepresentativeIntensity < 0.1) {
+					m_ScreenShake = false;
+					m_Renderer->PlaceCamera(glm::vec3(0, 0, 0));
+					return;
+				}
+			} else {
+				std::cout << "Timer: " << m_ShakeTimer << " End: " << m_ShakeEndTime << std::endl;
+			}
+			//float randomX = (rand() % m_ShakeIntensity);
+			//float randomY = (rand() % m_ShakeIntensity);
+
+			float randomX = 0;
+			float randomY = 0;
+
+			std::cout << "X: " << randomX << " Y: " << randomY << std::endl;
+			float half = m_ShakeIntensity / 2;
+
+			//m_Renderer->PlaceCamera(glm::vec3(randomX - half, randomY - half, 0));
+		} else {
+
+		}
+	}
+
 private:
 	std::shared_ptr<EventBroker> m_EventBroker;
 	GUI::Frame* m_FrameStack = nullptr;
@@ -557,6 +600,7 @@ private:
 	RenderQueueCollection m_RendererQueue;
 	std::shared_ptr<InputManager> m_InputManager;
 	std::shared_ptr<World> m_World;
+	glm::vec3 m_CameraPosition = glm::vec3(0.f, 0.f, 0.f);
 
 	//TODO: Redo
 	bool m_GameIsRunning = false;
@@ -581,6 +625,22 @@ private:
 
 		return true;
 	};
+
+	//TODO: Extreme Redo.
+	bool m_ScreenShake = false;
+	int m_ShakeIntensity = 0;
+	float m_ShakeRepresentativeIntensity = 0;
+	float m_ShakeTimer = 0;
+	float m_ShakeEndTime = 0;
+	dd::EventRelay<Engine, dd::Events::ScreenShake> m_EScreenShake;
+	bool OnScreenShake(const dd::Events::ScreenShake &event)
+	{
+		m_ScreenShake = true;
+		m_ShakeIntensity = event.Intensity;
+		m_ShakeEndTime = event.Time;
+		m_ShakeTimer = 0;
+		return true;
+	}
 	double m_LastTime;
 };
 

include/Core/Renderer.h

@@ -20,6 +20,12 @@
 #define DD_RENDERER_H__
 
 #include "Util/Rectangle.h"
+#include "Core/System.h"
+#include "Core/CTransform.h"
+#include "Core/CTemplate.h"
+#include "Core/EventBroker.h"
+#include "Core/World.h"
+#include "Game/EScreenShake.h"
 #include "Camera.h"
 #include "RenderQueue.h"
 #include "ShaderProgram.h"
@@ -48,6 +54,7 @@ public:
 	}
 	void Initialize();
 	void Draw(RenderQueueCollection& rq);
+	void PlaceCamera(glm::vec3 position);
 
 private:
 	Rectangle m_Resolution = Rectangle(1280, 720);
@@ -107,6 +114,12 @@ 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;
 };
 
 }

include/Game/EScreenShake.h

@@ -0,0 +1,26 @@
+//
+// Created by Administrator on 2015-10-13.
+//
+
+#ifndef DAYDREAM_ESCREENSHAKE_H
+#define DAYDREAM_ESCREENSHAKE_H
+
+#include "Core/EventBroker.h"
+
+namespace dd
+{
+
+namespace Events
+{
+
+struct ScreenShake : Event
+{
+    float Time;
+	int Intensity;
+};
+
+}
+
+}
+
+#endif //DAYDREAM_ESCREENSHAKE_H

include/Game/PadSystem.h

@@ -35,6 +35,7 @@
 #include "Game/EStageCleared.h"
 #include "Game/EPause.h"
 #include "Game/EHitLag.h"
+#include "Game/EScreenShake.h"
 #include "Game/EActionButton.h"
 
 
@@ -92,6 +93,7 @@ private:
 	std::shared_ptr<Components::Transform> m_StickTransform;
 	std::shared_ptr<Components::StickyAim> m_StickyAim;
 
+	bool m_ResetBall = false;
     bool m_Pause = false;
 
     dd::EventRelay<PadSystem, dd::Events::KeyDown> m_EKeyDown;
@@ -99,6 +101,7 @@ private:
     dd::EventRelay<PadSystem, dd::Events::Contact> m_EContact;
     dd::EventRelay<PadSystem, dd::Events::Contact> m_EContactPowerUp;
     dd::EventRelay<PadSystem, dd::Events::StageCleared> m_EStageCleared;
+	dd::EventRelay<PadSystem, dd::Events::ResetBall> m_EResetBall;
     dd::EventRelay<PadSystem, dd::Events::Pause> m_EPause;
 	dd::EventRelay<PadSystem, dd::Events::KrakenAttack> m_EKrakenAttack;
 	dd::EventRelay<PadSystem, dd::Events::StickyPad> m_EStickyPad;
@@ -110,6 +113,7 @@ private:
     bool OnContact(const dd::Events::Contact &event);
     bool OnContactPowerUp(const dd::Events::Contact &event);
     bool OnStageCleared(const dd::Events::StageCleared &event);
+	bool OnResetBall(const dd::Events::ResetBall &event);
     bool OnPause(const dd::Events::Pause &event);
 	bool OnKrakenAttack(const dd::Events::KrakenAttack &event);
 	bool OnStickyPad(const dd::Events::StickyPad &event);

include/Game/TravellingSystem.h

@@ -0,0 +1,56 @@
+//
+// Created by Adniklastrator on 2015-10-13.
+//
+
+#ifndef DAYDREAM_TRAVELLINGSYSTEM_H
+#define DAYDREAM_TRAVELLINGSYSTEM_H
+
+
+#include "Core/System.h"
+#include "Core/CTransform.h"
+#include "Core/EventBroker.h"
+#include "Core/World.h"
+#include "Game/EPause.h"
+#include "Game/EArrivedAtNewStage.h"
+#include "Game/EStageCleared.h"
+
+
+namespace dd
+{
+
+namespace Systems
+{
+
+class TravellingSystem : public System
+{
+public:
+    TravellingSystem(World* world, std::shared_ptr<dd::EventBroker> eventBroker)
+    : System(world, eventBroker)
+    { }
+
+    
+	void Initialize() override;
+	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:
+	bool m_Pause = false;
+
+	bool m_Travelling = false;
+	float m_DistanceTravelled = 0;
+
+    dd::EventRelay<TravellingSystem, dd::Events::Pause> m_EPause;
+	dd::EventRelay<TravellingSystem, dd::Events::StageCleared> m_EStageCleared;
+
+    bool OnPause(const dd::Events::Pause &event);
+	bool OnStageCleared(const dd::Events::StageCleared &event);
+};
+
+}
+
+}
+
+#endif //DAYDREAM_TRAVELLINGSYSTEM_H

include/Physics/PhysicsSystem.h

@@ -31,9 +31,6 @@
 #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"
@@ -115,12 +112,8 @@ namespace dd
             bool SetImpulse(const Events::SetImpulse &event);
             dd::EventRelay<PhysicsSystem, dd::Events::Pause> m_EPause;
             bool OnPause(const dd::Events::Pause &event);
-			dd::EventRelay<PhysicsSystem, dd::Events::StageCleared> m_EStageCleared;
-			bool OnStageCleared(const dd::Events::StageCleared &event);
 			dd::EventRelay<PhysicsSystem, dd::Events::Contact> m_EContact;
 			bool OnContact(const dd::Events::Contact &event);
-			bool m_Travelling = false;
-			float m_DistanceTravelled = 0;
 
             //TODO: Fill struct with info needed.
         struct EmitterHandler //TODO CHANGE NAMES

src/game/Core/Renderer.cpp

@@ -72,6 +72,7 @@ void dd::Renderer::Initialize()
 
 	m_CurrentScreenBuffer = m_TFinal;
 }
+
 void dd::Renderer::LoadShaders()
 {
 	/*
@@ -384,6 +385,11 @@ void dd::Renderer::DrawForward(RenderQueue &objects, RenderQueue &lights)
 	DrawWater(objects);
 }
 
+void dd::Renderer::PlaceCamera(glm::vec3 position)
+{
+	m_DefaultCamera->SetPosition(position);
+}
+
 void dd::Renderer::DrawScene(RenderQueue &objects, ShaderProgram &program)
 {
 	GLuint shaderProgramHandle = program;

src/game/Game/BallSystem.cpp

@@ -126,7 +126,7 @@ void dd::Systems::BallSystem::UpdateEntity(double dt, EntityID entity, EntityID
             } else 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);
+                //transform->Position = glm::vec3(0.0f, -3.f, -10.f);
                 transform->Orientation = glm::quat();
                 return;
             }
@@ -288,27 +288,29 @@ bool dd::Systems::BallSystem::Contact(const Events::Contact &event)
         float y = glm::cos((abs(x) / (1.6f)) * glm::pi<float>() / 2.f) + 1.f;
 
 		ballComponent->Combo = 0;
-
+		if (!ballComponent->Waiting) {
-		if (m_InkBlaster) {
+			if (m_InkBlaster) {
-			if (!m_InkAttached) {
+				if (!m_InkAttached) {
-				m_InkAttached = true;
+					m_InkAttached = true;
-				m_Waiting = true;
+					m_Waiting = true;
-				m_InkBlockedWaiting = true;
+					m_InkBlockedWaiting = true;
-				ballComponent->Sticky = true;
+					ballComponent->Sticky = true;
-				ballComponent->StickyPlacement = glm::vec3(0, 0.5f, 0);
+					ballComponent->StickyPlacement = glm::vec3(0, 0.5f, 0);
-				ballComponent->SavedSpeed = glm::normalize(glm::vec3(x, y, 0.f)) * ballComponent->Speed;
+					ballComponent->SavedSpeed = glm::normalize(glm::vec3(x, y, 0.f)) * ballComponent->Speed;
-				ballTransform->Velocity = glm::vec3(0.f, 0.f, 0.f);
+					ballTransform->Velocity = glm::vec3(0.f, 0.f, 0.f);
+				}
+			}
+			else if (m_Sticky) {
+				m_Sticky = false;
+				m_Waiting = true;
+				ballComponent->Sticky = true;
+				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;
 			}
-		} else if (m_Sticky) {
-			m_Sticky = false;
-			m_Waiting = true;
-			ballComponent->Sticky = true;
-			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;
 		}
 
         ballTransform->Velocity = glm::normalize(glm::vec3(x, y ,0.f)) * ballComponent->Speed;

src/game/Game/PadSystem.cpp

@@ -27,6 +27,7 @@ void dd::Systems::PadSystem::Initialize()
     EVENT_SUBSCRIBE_MEMBER(m_EContact, &PadSystem::OnContact);
     EVENT_SUBSCRIBE_MEMBER(m_EContactPowerUp, &PadSystem::OnContactPowerUp);
     EVENT_SUBSCRIBE_MEMBER(m_EStageCleared, &PadSystem::OnStageCleared);
+	EVENT_SUBSCRIBE_MEMBER(m_EResetBall, &PadSystem::OnResetBall);
     EVENT_SUBSCRIBE_MEMBER(m_EPause, &PadSystem::OnPause);
 	EVENT_SUBSCRIBE_MEMBER(m_EKrakenAttack, &PadSystem::OnKrakenAttack);
 	EVENT_SUBSCRIBE_MEMBER(m_EStickyPad, &PadSystem::OnStickyPad);
@@ -72,6 +73,8 @@ void dd::Systems::PadSystem::Initialize()
 		m_StickTransform = transform;
 		m_StickyAim = sticky;
 	}
+
+	m_ResetBall = true;
 }
 
 void dd::Systems::PadSystem::UpdateEntity(double dt, EntityID entity, EntityID parent)
@@ -81,7 +84,12 @@ 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) {
+		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;
+				m_ResetBall = false;
+			}
 			auto ballTransform = m_World->GetComponent<Components::Transform>(entity);
 			ballTransform->Position = Transform()->Position;
 			ballTransform->Position += ball->StickyPlacement;
@@ -89,8 +97,10 @@ void dd::Systems::PadSystem::UpdateEntity(double dt, EntityID entity, EntityID p
 			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));
+			if (ball->Sticky) {
-			m_StickTransform->Position = ballTransform->Position;
+				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);
@@ -103,6 +113,7 @@ void dd::Systems::PadSystem::Update(double dt)
     if (IsPaused()) {
         return;
     }
+
     if (Entity() == 0) {
         for (auto it = m_World->GetEntities()->begin(); it != m_World->GetEntities()->end(); it++) {
             if (m_World->GetProperty<std::string>(it->first, "Name") == "Pad") {
@@ -209,6 +220,11 @@ 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_E) {
+		Events::ScreenShake e;
+		e.Intensity = 20;
+		e.Time = 3;
+		EventBroker->Publish(e);
 	} else if (val == GLFW_KEY_Y) {
 		Events::StickyPad e;
 		EventBroker->Publish(e);
@@ -345,6 +361,12 @@ bool dd::Systems::PadSystem::OnStageCleared(const dd::Events::StageCleared &even
     return true;
 }
 
+bool dd::Systems::PadSystem::OnResetBall(const dd::Events::ResetBall &event)
+{
+	m_ResetBall = true;
+	return true;
+}
+
 bool dd::Systems::PadSystem::OnKrakenAttack(const dd::Events::KrakenAttack &event)
 {
 	if (!m_KrakenAttack) {

src/game/Game/TravellingSystem.cpp

@@ -0,0 +1,66 @@
+//
+// Created by Adniklastrator on 2015-10-13.
+//
+
+#include "PrecompiledHeader.h"
+#include "Game/TravellingSystem.h"
+
+void dd::Systems::TravellingSystem::Initialize()
+{
+	EVENT_SUBSCRIBE_MEMBER(m_EPause, &TravellingSystem::OnPause);
+    EVENT_SUBSCRIBE_MEMBER(m_EStageCleared, &TravellingSystem::OnStageCleared);
+}
+
+void dd::Systems::TravellingSystem::Update(double dt)
+{
+	if (m_Pause) {
+		return;
+	}
+	if (m_Travelling) {
+		if (m_DistanceTravelled > 12.f) {
+			m_DistanceTravelled = 0;
+			m_Travelling = false;
+			Events::ArrivedAtNewStage e;
+			EventBroker->Publish(e);
+		}
+
+		m_DistanceTravelled += 6.0f * dt;
+	}
+}
+
+void dd::Systems::TravellingSystem::UpdateEntity(double dt, EntityID entity, EntityID parent)
+{
+	if (m_Travelling) {
+		auto transform = m_World->GetComponent<Components::Transform>(entity);
+		if (transform != nullptr) {
+			if (!transform->Sticky) {
+				transform->Position.y -= 6.0f * dt;
+			}
+		}
+		else {
+			transform->Position.y -= 6.0f * dt;
+		}
+	}
+}
+
+bool dd::Systems::TravellingSystem::OnPause(const dd::Events::Pause &event)
+{
+	if (event.Type != "TravellingSystem" && event.Type != "All") {
+		return false;
+	}
+
+    if (IsPaused()) {
+        SetPause(false);
+    } else {
+        SetPause(true);
+    }
+    return true;
+}
+
+bool dd::Systems::TravellingSystem::OnStageCleared(const dd::Events::StageCleared &event)
+{
+	if (event.ClearedStage < 5) {
+		m_Travelling = true;
+	}
+	return true;
+}

src/game/Physics/PhysicsSystem.cpp

@@ -23,7 +23,6 @@ void dd::Systems::PhysicsSystem::Initialize()
     InitializeWater();
     EVENT_SUBSCRIBE_MEMBER(m_SetImpulse, &PhysicsSystem::SetImpulse);
     EVENT_SUBSCRIBE_MEMBER(m_EPause, &PhysicsSystem::OnPause);
-	EVENT_SUBSCRIBE_MEMBER(m_EStageCleared, &PhysicsSystem::OnStageCleared);
     EVENT_SUBSCRIBE_MEMBER(m_ECreateParticleSequence, &PhysicsSystem::CreateParticleSequence);
 	EVENT_SUBSCRIBE_MEMBER(m_EContact, &PhysicsSystem::OnContact);
 }
@@ -170,17 +169,6 @@ void dd::Systems::PhysicsSystem::Update(double dt)
 	if (m_Pause) {
 		return;
 	}
-
-	if (m_Travelling) {
-		if (m_DistanceTravelled > 12.f) {
-			m_DistanceTravelled = 0;
-			m_Travelling = false;
-			Events::ArrivedAtNewStage e;
-			EventBroker->Publish(e);
-		}
-
-		m_DistanceTravelled += 6.0f * dt;
-	}
     m_Accumulator += dt;
 
     while(m_Accumulator >= m_TimeStep)
@@ -254,20 +242,8 @@ void dd::Systems::PhysicsSystem::Update(double dt)
 
 void dd::Systems::PhysicsSystem::UpdateEntity(double dt, EntityID entity, EntityID parent)
 {    
-	if (m_Travelling) {
-		auto transform = m_World->GetComponent<Components::Transform>(entity);
-		if (transform != nullptr) {
-			if (!transform->Sticky) {
-				transform->Position.y -= 6.0f * dt;
-			}
-		} else {
-			transform->Position.y -= 6.0f * dt;
-		}
-	}
     auto particle = m_World->GetComponent<Components::Particle>(entity);
 	auto pTemplate = m_World->GetComponent<Components::Template>(entity);
-	
-
 
     if (particle && !pTemplate) {
         particle->LifeTime -= dt;
@@ -360,15 +336,6 @@ void dd::Systems::PhysicsSystem::OnEntityRemoved(EntityID entity)
 }
 
 
-bool dd::Systems::PhysicsSystem::OnStageCleared(const dd::Events::StageCleared &event)
-{
-	if (event.ClearedStage < 5) {
-		m_Travelling = true;
-	}
-	return true;
-}
-
-
 void dd::Systems::PhysicsSystem::CreateBody(EntityID entity)
 {
     auto physicsComponent = m_World->GetComponent<Components::Physics>(entity);