TravellingSystem uses EMove. EMove and ERotate copied from Returngeance into TransportSystem.

include/Game/CBackground.h

@@ -15,7 +15,7 @@ namespace Components
 
 struct Background : Component
 {
-
+	float distanceLeftToCorrectTravelPosition;
 };
 
 }

include/Game/CKraken.h

@@ -0,0 +1,26 @@
+//
+// Created by Adniklastrator on 2015-09-15.
+//
+
+#ifndef DAYDREAM_CLIFE_H
+#define DAYDREAM_CLIFE_H
+
+#include "Core/Component.h"
+
+namespace dd
+{
+
+namespace Components
+{
+
+struct Life : Component {
+
+    int Number = 0;
+
+};
+
+}
+
+}
+
+#endif //DAYDREAM_CLIFE_H

include/Game/CTravels.h

@@ -17,6 +17,8 @@ struct Travels : Component
 {
 	//This indicates that the object moves upon moving to the next stage. Place this on an object that is to move.
 	//The camera does not move. Things that are to follow the camera should not have this component.
+
+	bool CurrentlyTraveling = false;
 };
 
 }

include/Game/KrakenSystem.h

@@ -0,0 +1,51 @@
+//
+// Created by Adniklastrator on 2015-10-15.
+//
+
+#ifndef DAYDREAM_KRAKENSYSTEM_H
+#define DAYDREAM_KRAKENSYSTEM_H
+
+
+#include "Core/System.h"
+#include "Core/CTransform.h"
+#include "Core/CTemplate.h"
+#include "Core/EventBroker.h"
+#include "Core/World.h"
+#include "Game/EPause.h"
+//#include "Core/Camera.h" Camera Component
+
+
+namespace dd
+{
+
+namespace Systems
+{
+
+class KrakenSystem : public System
+{
+public:
+    KrakenSystem(World* world, std::shared_ptr<dd::EventBroker> eventBroker)
+    : System(world, eventBroker)
+    { }
+
+    void Initialize() override;
+	void InitializeObjects();
+
+	void UpdateEntity(double dt, EntityID entity, EntityID parent) override;
+
+    bool IsPaused() const { return m_Pause; }
+    void SetPause(const bool& pause) { m_Pause = pause; }
+private:
+
+    dd::EventRelay<KrakenSystem, dd::Events::Pause> m_EPause;
+    bool OnPause(const dd::Events::Pause &event);
+
+
+
+};
+
+}
+
+}
+
+#endif //DAYDREAM_KRAKENSYSTEM_H

include/Game/LevelSystem.h

@@ -18,6 +18,8 @@
 #include "Rendering/CModel.h"
 #include "Rendering/CPointLight.h"
 
+#include "Transform/EMove.h"
+
 #include "Game/CBrick.h"
 #include "Game/CBall.h"
 #include "Game/CLife.h"

include/Game/PadSystem.h

@@ -13,15 +13,22 @@
 #include "Core/EventBroker.h"
 #include "Core/EKeyDown.h"
 #include "Core/EKeyUp.h"
+
 #include "Input/EBindKey.h"
+
 #include "Physics/EContact.h"
 #include "Physics/CRectangleShape.h"
 #include "Physics/CWaterVolume.h"
 #include "Physics/CPhysics.h"
 #include "Physics/CCircleShape.h"
 #include "Physics/ESetImpulse.h"
+
 #include "Rendering/CSprite.h"
 #include "Rendering/CModel.h"
+
+#include "Transform/EMove.h"
+#include "Transform/ERotate.h"
+
 #include "Game/CBall.h"
 #include "Game/CPad.h"
 #include "Game/CPowerUp.h"

include/Game/TravellingSystem.h

@@ -8,12 +8,15 @@
 
 #include "Core/System.h"
 #include "Core/CTransform.h"
+#include "Core/CTemplate.h"
 #include "Core/EventBroker.h"
 #include "Core/World.h"
+#include "Transform/EMove.h"
 #include "Game/EPause.h"
 #include "Game/EArrivedAtNewStage.h"
 #include "Game/EStageCleared.h"
 #include "Game/CTravels.h"
+#include "Game/CBackground.h"
 
 
 namespace dd
@@ -45,9 +48,11 @@ private:
 
     dd::EventRelay<TravellingSystem, dd::Events::Pause> m_EPause;
 	dd::EventRelay<TravellingSystem, dd::Events::StageCleared> m_EStageCleared;
+	dd::EventRelay<TravellingSystem, dd::Events::ArrivedAtNewStage> m_EArrivedAtNewStage;
 
     bool OnPause(const dd::Events::Pause &event);
 	bool OnStageCleared(const dd::Events::StageCleared &event);
+	bool OnArrivedAtNewStage(const dd::Events::ArrivedAtNewStage &event);
 };
 
 }

include/Transform/TransformSystem.h

@@ -39,14 +39,38 @@ public:
 	TransformSystem(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;
 
 	Components::Transform AbsoluteTransform(EntityID entity);
 	glm::vec3 AbsolutePosition(EntityID entity);
 	glm::quat AbsoluteOrientation(EntityID entity);
 	glm::vec3 AbsoluteScale(EntityID entity);
 
+	// Events
+	EventRelay<TransformSystem, Events::Move> m_EMove;
+	bool OnMove(const Events::Move &event);
+	EventRelay<TransformSystem, Events::Rotate> m_ERotate;
+	bool OnRotate(const Events::Rotate &event);
 private:
+	struct MoveItems
+	{
+		EntityID Entity;
+		glm::vec3 GoalPosition;
+		float Speed;
+	};
+	std::unordered_map<EntityID, MoveItems> m_MoveItems;
+	std::multimap<EntityID, MoveItems> m_QueuedMoveItems;
+	struct RotationItems
+	{
+		EntityID Entity;
+		glm::quat GoalRotation;
+		double Time;
+	};
+	std::unordered_map<EntityID, RotationItems> m_RotationItems;
+	std::multimap<EntityID, RotationItems> m_QueuedRotationItems;
 };
 
 }

src/game/Game/BallSystem.cpp

@@ -167,7 +167,7 @@ void dd::Systems::BallSystem::UpdateEntity(double dt, EntityID entity, EntityID
                 return;
             }
         } //Removing this made the wall collisions work again
-         else if (transformBall->Position.x > EdgeX()) {
+        /* else if (transformBall->Position.x > EdgeX()) {
             if (transformBall->Velocity.x > 0) {
                 glm::vec2 reflectedVelocity = glm::reflect(glm::vec2(transformBall->Velocity.x, transformBall->Velocity.y), glm::vec2(1, 0));
                 transformBall->Velocity = glm::vec3(reflectedVelocity, 0.f);
@@ -322,9 +322,6 @@ bool dd::Systems::BallSystem::Contact(const Events::Contact &event)
 			EventBroker->Publish(particleEvent);
 		}
 		
-
-		
-
 		ballComponent->Combo = 56;
 		if (!ballComponent->Waiting) {
 			if (m_InkBlaster) {
@@ -342,7 +339,8 @@ bool dd::Systems::BallSystem::Contact(const Events::Contact &event)
 				m_Sticky = false;
 				m_Waiting = true;
 				ballComponent->Sticky = true;
-				ballComponent->StickyPlacement = ballTransform->Position - padTransform->Position;
+				//ballComponent->StickyPlacement = ballTransform->Position - padTransform->Position;
+				ballComponent->StickyPlacement = glm::vec3(0, 0.5f, 0);
 				ballComponent->SavedSpeed = glm::normalize(glm::vec3(x, y, 0.f)) * ballComponent->Speed;
 				ballTransform->Velocity *= -1;
 				Events::StickyAttachedToPad e;
@@ -485,6 +483,7 @@ 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 = event.Times;
 	return true;
 }
 

src/game/Game/KrakenSystem.cpp

@@ -0,0 +1,36 @@
+//
+// Created by Adniklastrator on 2015-10-15.
+//
+
+#include "PrecompiledHeader.h"
+#include "Game/KrakenSystem.h"
+
+void dd::Systems::KrakenSystem::Initialize()
+{
+    EVENT_SUBSCRIBE_MEMBER(m_EPause, &KrakenSystem::OnPause);
+
+	InitializeObjects();
+}
+
+void dd::Systems::KrakenSystem::InitializeObjects()
+{
+
+}
+
+void dd::Systems::KrakenSystem::UpdateEntity(double dt, EntityID entity, EntityID parent)
+{
+    if (IsPaused()) {
+        return;
+    }
+
+}
+
+bool dd::Systems::KrakenSystem::OnPause(const dd::Events::Pause &event)
+{
+    if (IsPaused()) {
+        SetPause(false);
+    } else {
+        SetPause(true);
+    }
+    return true;
+}

src/game/Game/LevelSystem.cpp

@@ -53,6 +53,7 @@ void dd::Systems::LevelSystem::Initialize()
 		transform->Position = glm::vec3(0.f, 0.f, -15.f);
 		transform->Scale = glm::vec3(6.f, 6.f, 10.f);
 		auto travels = m_World->AddComponent<Components::Travels>(t_halfPipe);
+		travels->CurrentlyTraveling = false;
 		auto model = m_World->AddComponent<Components::Model>(t_halfPipe);
 		model->ModelFile = "Models/Test/halfpipe/Halfpipe.obj";
 		model->Color = glm::vec4(0.8f, 0.8f, 0.8f, 0.3f);
@@ -60,22 +61,23 @@ 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);
+		transform2->Position = glm::vec3(0.f, 34.6f, -15.f); //Halfpipe Value
 	}
 
 	//Background
 
-	{
+	/*{
 		auto background = m_World->CreateEntity();
 		auto transform = m_World->AddComponent<Components::Transform>(background);
 		auto travels = m_World->AddComponent<Components::Travels>(background);
+		travels->CurrentlyTraveling = false;
 		auto backgroundComponent = m_World->AddComponent<Components::Background>(background);
 		transform->Position = glm::vec3(0.f, 0.f, -30.f);
 		transform->Scale = glm::vec3(2681.f / 50.f, 1080.f / 50.f, 1.f);
 		auto sprite = m_World->AddComponent<Components::Sprite>(background);
 		sprite->SpriteFile = "Textures/Background.png";
 		m_World->CommitEntity(background);
-	}
+	}*/
 
 	//			auto particleEmitter= m_World->AddComponent<Components::Emitter>(Pe);
 	//Water test
@@ -184,7 +186,7 @@ void dd::Systems::LevelSystem::Initialize()
 		std::shared_ptr<Components::Physics> physics = m_World->AddComponent<Components::Physics>(leftWall);
 		physics->CollisionType = CollisionType::Type::Static;
 		physics->Category = CollisionLayer::Wall;
-		physics->Mask = static_cast<CollisionLayer::Type>(/*CollisionLayer::Ball |*/ CollisionLayer::Brick);
+		physics->Mask = static_cast<CollisionLayer::Type>(CollisionLayer::Ball | CollisionLayer::Brick);
 
 		m_World->CommitEntity(leftWall);
 	}
@@ -207,7 +209,7 @@ void dd::Systems::LevelSystem::Initialize()
 		std::shared_ptr<Components::Physics> physics = m_World->AddComponent<Components::Physics>(rightWall);
 		physics->CollisionType = CollisionType::Type::Static;
 		physics->Category = CollisionLayer::Wall;
-		physics->Mask = static_cast<CollisionLayer::Type>(/*CollisionLayer::Ball |*/ CollisionLayer::Brick);
+		physics->Mask = static_cast<CollisionLayer::Type>(CollisionLayer::Ball | CollisionLayer::Brick);
 
 		m_World->CommitEntity(rightWall);
 	}
@@ -222,6 +224,7 @@ void dd::Systems::LevelSystem::Initialize()
     std::shared_ptr<Components::Template> cTemplate = m_World->AddComponent<Components::Template>(m_BrickTemplate);
 
 	auto travels = m_World->AddComponent<Components::Travels>(m_BrickTemplate);
+	travels->CurrentlyTraveling = false;
 
     cPhys->CollisionType = CollisionType::Type::Static;
     cPhys->GravityScale = 0.f;
@@ -255,15 +258,19 @@ void dd::Systems::LevelSystem::UpdateEntity(double dt, EntityID entity, EntityID
     if (templateCheck != nullptr){ return; }
 
     // Check the background.
-    auto model = m_World->GetComponent<Components::Model>(entity);
-    if (model != nullptr) {
-		if (model->ModelFile == "Models/Test/halfpipe/Halfpipe.obj") {
-            auto transform = m_World->GetComponent<Components::Transform>(entity);
-            if (transform->Position.y <= -34.6) {
-                transform->Position.y = 34.6;
-            }
-        }
-    }
+    auto background = m_World->GetComponent<Components::Background>(entity);
+	if (background != nullptr) {
+		auto transform = m_World->GetComponent<Components::Transform>(entity);
+		if (transform->Position.y <= -34.6) { //Halfpipe Value.
+			transform->Position.y = 34.6;
+			Events::Move e;
+			e.Entity = entity;
+			e.GoalPosition = glm::vec3(transform->Position.x, 34.6 + background->distanceLeftToCorrectTravelPosition, transform->Position.z);
+			e.Speed = 6.0f;
+			e.Queue = false;
+			EventBroker->Publish(e);
+		}
+	}
 
     auto brick = m_World->GetComponent<Components::Brick>(entity);
     if (brick != nullptr) {
@@ -281,9 +288,11 @@ void dd::Systems::LevelSystem::UpdateEntity(double dt, EntityID entity, EntityID
 				EventBroker->Publish(e);
 			} else if (brick->Type == StickyBrick) {
 				Events::StickyPad e;
+				e.Times = 3;
 				EventBroker->Publish(e);
 			} else if (brick->Type == InkBlasterBrick) {
 				Events::InkBlaster e;
+				e.Shots = 5;
 				EventBroker->Publish(e);
 			} else if(brick->Type == KrakenAttackBrick) {
 				Events::KrakenAttack e;
@@ -664,7 +673,7 @@ bool dd::Systems::LevelSystem::OnStageCleared(const dd::Events::StageCleared &ev
         m_CurrentLevel++;
         if (m_CurrentLevel < 6) {
             GetNextLevel();
-            CreateLevel(12);
+            CreateLevel(12); //NextLevelDistance
 		} else {
 			// Win
 			Events::ClusterClear e;

src/game/Game/PadSystem.cpp

@@ -240,9 +240,11 @@ bool dd::Systems::PadSystem::OnKeyDown(const dd::Events::KeyDown &event) {
 		EventBroker->Publish(e);
 	} else if (val == GLFW_KEY_Y) {
 		Events::StickyPad e;
+		e.Times = 3;
 		EventBroker->Publish(e);
 	} else if (val == GLFW_KEY_I) {
 		Events::InkBlaster e;
+		e.Shots = 5;
 		EventBroker->Publish(e);
 	} else if (val == GLFW_KEY_K) {
 		Events::KrakenAttack e;
@@ -250,6 +252,13 @@ bool dd::Systems::PadSystem::OnKeyDown(const dd::Events::KeyDown &event) {
 		e.KrakenStrength = 0.1;
 		e.PlayerStrength = 0.05;
 		EventBroker->Publish(e);
+	} else if (val == GLFW_KEY_Q) {
+		Events::Move e;
+		e.Entity = Entity();
+		e.GoalPosition = glm::vec3(0, 0, -10);
+		e.Speed = 5;
+		e.Queue = false;
+		EventBroker->Publish(e);
 	} else if (val == GLFW_KEY_SPACE) {
         Events::ActionButton e;
 		e.Position = Transform()->Position;

src/game/Game/TravellingSystem.cpp

@@ -17,7 +17,7 @@ void dd::Systems::TravellingSystem::Update(double dt)
 		return;
 	}
 	if (m_Travelling) {
-		if (m_DistanceTravelled > 12.f) {
+		if (m_DistanceTravelled > 12.f) { //NextLevelDistance
 			m_DistanceTravelled = 0;
 			m_Travelling = false;
 			Events::ArrivedAtNewStage e;
@@ -30,14 +30,47 @@ void dd::Systems::TravellingSystem::Update(double dt)
 
 void dd::Systems::TravellingSystem::UpdateEntity(double dt, EntityID entity, EntityID parent)
 {
+	auto templateCheck = m_World->GetComponent<Components::Template>(entity);
+	if (templateCheck != nullptr){ return; }
+
 	if (m_Travelling) {
 		auto travels = m_World->GetComponent<Components::Travels>(entity);
 		if (travels != nullptr) {
-			auto transform = m_World->GetComponent<Components::Transform>(entity);
-			if (transform != nullptr) {
-				transform->Position.y -= 6.0f * dt;
+			if (!travels->CurrentlyTraveling) {
+				auto transform = m_World->GetComponent<Components::Transform>(entity);
+				if (transform != nullptr) {
+					Events::Move e;
+					e.Entity = entity;
+					glm::vec3 position = transform->Position;
+					glm::vec3 goalPosition = position;
+					e.Queue = false;
+					e.Speed = 6;
+					goalPosition.y -= 12; //NextLevelDistance
+					if (goalPosition.y < -34.6) { //Halfpipe Value
+						auto background = m_World->GetComponent<Components::Background>(entity);
+						if (background != nullptr) {
+							float yValue = position.y; // A negative value between -34.6 and -22.6;
+							yValue += 22.6; // A positive value between -12 and 0. The distance it should travel from 34.6;
+							background->distanceLeftToCorrectTravelPosition = yValue;
+							std::cout << "This happened." << std::endl;
+						} else {
+							m_World->RemoveEntity(entity);
+							return;
+						}
+					}
+					e.GoalPosition = goalPosition;
+					
+					travels->CurrentlyTraveling = true;
+					EventBroker->Publish(e);
+					//transform->Position.y -= 6.0f * dt;
+				}
 			}
 		}
+	} else {
+		auto travels = m_World->GetComponent<Components::Travels>(entity);
+		if (travels != nullptr) {
+			travels->CurrentlyTraveling = false;
+		}
 	}
 }
 
@@ -60,5 +93,11 @@ bool dd::Systems::TravellingSystem::OnStageCleared(const dd::Events::StageCleare
 	if (event.ClearedStage < 5) {
 		m_Travelling = true;
 	}
+	return true;
+}
+
+bool dd::Systems::TravellingSystem::OnArrivedAtNewStage(const dd::Events::ArrivedAtNewStage &event)
+{
+	
 	return true;
 }

src/game/Transform/TransformSystem.cpp

@@ -20,12 +20,125 @@
 #include "Transform/TransformSystem.h"
 #include "Core/World.h"
 
+void dd::Systems::TransformSystem::Initialize()
+{
+	EVENT_SUBSCRIBE_MEMBER(m_EMove, &Systems::TransformSystem::OnMove);
+	EVENT_SUBSCRIBE_MEMBER(m_ERotate, &Systems::TransformSystem::OnRotate);
+}
+
 void dd::Systems::TransformSystem::Update(double dt)
 {
 
 	return;
 }
 
+void dd::Systems::TransformSystem::UpdateEntity(double dt, EntityID entity, EntityID parent)
+{
+	if (m_MoveItems.find(entity) != m_MoveItems.end())
+	{
+		auto transform = m_World->GetComponent<Components::Transform>(entity);
+
+		glm::vec3 direction = glm::normalize(m_MoveItems[entity].GoalPosition - transform->Position);
+		glm::vec3 movement = direction * m_MoveItems[entity].Speed * (float)dt;
+
+		glm::vec3 v1 = m_MoveItems[entity].GoalPosition - transform->Position;
+		glm::vec3 v2 = movement;
+
+		if (glm::length(v2) >= glm::length(v1))
+		{
+			transform->Position = m_MoveItems[entity].GoalPosition;
+			//transform->Velocity = glm::vec3(0, 0, 0);
+
+			m_MoveItems.erase(entity);
+
+			if (m_QueuedMoveItems.find(entity) != m_QueuedMoveItems.end())
+			{
+				auto it = m_QueuedMoveItems.find(entity);
+				m_MoveItems[entity] = it->second;
+				m_QueuedMoveItems.erase(it->first);
+			}
+		}
+		else
+		{
+			transform->Position += movement;
+			//transform->Velocity = movement;
+		}
+	}
+
+	if (m_RotationItems.find(entity) != m_RotationItems.end())
+	{
+		auto transform = m_World->GetComponent<Components::Transform>(entity);
+		auto absolutetransform = AbsoluteTransform(entity);
+
+		float percentage = dt / m_RotationItems[entity].Time;
+		m_RotationItems[entity].Time -= dt;
+		glm::clamp(percentage, 0.f, 1.0f);
+		transform->Orientation = glm::slerp(transform->Orientation, m_RotationItems[entity].GoalRotation, percentage);
+
+		if (m_RotationItems[entity].Time <= 0)
+		{
+			m_RotationItems.erase(entity);
+
+			if (m_QueuedRotationItems.find(entity) != m_QueuedRotationItems.end())
+			{
+				auto it = m_QueuedRotationItems.find(entity);
+				m_RotationItems[entity] = it->second;
+				m_QueuedRotationItems.erase(it->first);
+			}
+		}
+	}
+}
+
+bool dd::Systems::TransformSystem::OnRotate(const Events::Rotate &event)
+{
+	RotationItems item;
+	item.Entity = event.Entity;
+	item.GoalRotation = event.GoalRotation;
+	item.Time = event.Time;
+
+	if (event.Queue)
+	{
+		if (m_RotationItems.find(event.Entity) != m_RotationItems.end())
+		{
+			m_QueuedRotationItems.insert(std::make_pair(event.Entity, item));
+		}
+		else
+		{
+			m_RotationItems[event.Entity] = item;
+		}
+	}
+	else
+	{
+		m_RotationItems[event.Entity] = item;
+	}
+	return true;
+}
+
+bool dd::Systems::TransformSystem::OnMove(const Events::Move &event)
+{
+	MoveItems item;
+	item.Entity = event.Entity;
+	item.GoalPosition = event.GoalPosition;
+	item.Speed = event.Speed;
+
+	if (event.Queue)
+	{
+		if (m_MoveItems.find(event.Entity) != m_MoveItems.end())
+		{
+			m_QueuedMoveItems.insert(std::make_pair(event.Entity, item));
+		}
+		else
+		{
+			m_MoveItems[event.Entity] = item;
+		}
+	}
+	else
+	{
+		m_MoveItems[event.Entity] = item;
+	}
+	return true;
+}
+
 glm::vec3 dd::Systems::TransformSystem::AbsolutePosition(EntityID entity)
 {
 	glm::vec3 absPosition;