Movement/rotation queue fixed and Simon force push

src/Systems/FollowSystem.cpp

@@ -0,0 +1,26 @@
+#include "PrecompiledHeader.h"
+#include "FollowSystem.h"
+#include "World.h"
+
+void Systems::FollowSystem::RegisterComponents( ComponentFactory* cf )
+{
+	cf->Register<Components::Follow>([]() { return new Components::Follow(); });
+}
+
+void Systems::FollowSystem::Update( double dt )
+{
+
+}
+
+void Systems::FollowSystem::UpdateEntity( double dt, EntityID entity, EntityID parent )
+{
+	auto followComponent = m_World->GetComponent<Components::Follow>(entity);
+	auto transformComponent = m_World->GetComponent<Components::Transform>(entity);
+	if(!followComponent || !transformComponent)
+		return;
+	auto absoluteTransformTarget = m_World->GetSystem<Systems::TransformSystem>()->AbsoluteTransform(followComponent->Entity);
+
+	glm::vec3 Offset = (absoluteTransformTarget.Orientation * glm::normalize(absoluteTransformTarget.Position) * followComponent->Distance);
+	transformComponent->Position = (absoluteTransformTarget.Position + Offset);
+	transformComponent->Orientation = -glm::quat(glm::eulerAngles(absoluteTransformTarget.Orientation) * followComponent->FollowAxis);
+}

src/Systems/FollowSystem.h

@@ -0,0 +1,37 @@
+#ifndef FollowSystem_h__
+#define FollowSystem_h__
+
+
+#include "System.h"
+#include "Systems/TransformSystem.h"
+#include "Components/Transform.h"
+#include "Components/Follow.h"
+
+#include "Events/Move.h"
+#include "Events/Rotate.h"
+
+
+namespace Systems
+{
+	class FollowSystem : public System
+	{
+	public:
+
+		FollowSystem(World* world, std::shared_ptr<::EventBroker> eventBroker, std::shared_ptr<::ResourceManager> resourceManager)
+			: System(world, eventBroker, resourceManager) { }
+
+		//void Initialize() override;
+		void RegisterComponents(ComponentFactory* cf) override;
+		void Update(double dt) override;
+		void UpdateEntity(double dt, EntityID entity, EntityID parent) override;
+		/*void OnComponentCreated(std::string type, std::shared_ptr<Component> component) override;
+		void OnComponentRemoved(EntityID entity, std::string type, Component* component) override;
+		void OnEntityCommit(EntityID entity) override;
+		void OnEntityRemoved(EntityID entity) override;*/
+
+	private:
+
+	};
+
+}
+#endif // FollowSystem_h__

src/Systems/PhysicsSystem.cpp

@@ -158,31 +158,34 @@ void Systems::PhysicsSystem::Update(double dt)
 		if (!transformComponent)
 			continue;
 
-		if(/*m_RigidBodies[entity]->isActive()*/ true)
-		{
-			hkVector4 position;
-			hkQuaternion rotation;
-			hkVector4 velocity;
+		
+		hkVector4 position;
+		hkQuaternion rotation;
+		hkVector4 velocity;
 
-			if (parent)
-			{
-				auto absoluteTransform = m_World->GetSystem<Systems::TransformSystem>()->AbsoluteTransform(entity);
-				position = GLMVEC3_TO_HKVECTOR4(absoluteTransform.Position);
-				rotation = GLMQUAT_TO_HKQUATERNION(absoluteTransform.Orientation);
-				velocity = GLMVEC3_TO_HKVECTOR4(absoluteTransform.Velocity);
-			}
-			else
-			{
-				position = GLMVEC3_TO_HKVECTOR4(transformComponent->Position);
-				rotation = GLMQUAT_TO_HKQUATERNION(transformComponent->Orientation);
-				velocity = GLMVEC3_TO_HKVECTOR4(transformComponent->Velocity);
-			}
-			m_PhysicsWorld->markForWrite();
-			m_RigidBodies[entity]->setPositionAndRotation(position, rotation);
-			m_RigidBodies[entity]->setLinearVelocity(velocity);
-			m_PhysicsWorld->unmarkForWrite();
-			
+		if (parent)
+		{
+			auto absoluteTransform = m_World->GetSystem<Systems::TransformSystem>()->AbsoluteTransform(entity);
+			position = GLMVEC3_TO_HKVECTOR4(absoluteTransform.Position);
+			rotation = GLMQUAT_TO_HKQUATERNION(absoluteTransform.Orientation);
+			velocity = GLMVEC3_TO_HKVECTOR4(absoluteTransform.Velocity);
 		}
+		else
+		{
+			position = GLMVEC3_TO_HKVECTOR4(transformComponent->Position);
+			rotation = GLMQUAT_TO_HKQUATERNION(transformComponent->Orientation);
+			velocity = GLMVEC3_TO_HKVECTOR4(transformComponent->Velocity);
+		}
+		m_PhysicsWorld->markForWrite();
+		m_RigidBodies[entity]->setPositionAndRotation(position, rotation);
+
+		if(m_RigidBodies[entity]->getMotionType() != hkpMotion::MOTION_FIXED)
+		{
+			m_RigidBodies[entity]->setLinearVelocity(velocity);
+		}
+		m_PhysicsWorld->unmarkForWrite();
+
+		
 /*
 
 		glm::vec3 pos1 = HKVECTOR4_TO_GLMVEC3(m_RigidBodies[m_World->m_Terrain]->getPosition());
@@ -751,9 +754,9 @@ bool Systems::PhysicsSystem::OnSetVelocity( const Events::SetVelocity &event )
 {
 	if(m_RigidBodies.find(event.Entity) != m_RigidBodies.end())
 	{
+
 		m_PhysicsWorld->markForWrite();
 		m_RigidBodies[event.Entity]->setLinearVelocity(GLMVEC3_TO_HKVECTOR4(event.Velocity));
-
 		auto transformComponent = m_World->GetComponent<Components::Transform>(event.Entity);
 		transformComponent->Velocity = event.Velocity;
 		m_PhysicsWorld->unmarkForWrite();

src/Systems/TankSteeringSystem.cpp

@@ -68,6 +68,20 @@ void Systems::TankSteeringSystem::UpdateEntity(double dt, EntityID entity, Entit
 		glm::quat orientation =  glm::angleAxis(barrelSteeringComponent->TurnSpeed * inputController->BarrelDirection * (float)dt, barrelSteeringComponent->Axis);
 		transformComponent->Orientation *= orientation;
 
+		glm::vec3 angles = glm::eulerAngles(transformComponent->Orientation);
+		if(angles.x > barrelSteeringComponent->UpperRotationLimit)
+		{
+			angles.x  = barrelSteeringComponent->UpperRotationLimit;
+			transformComponent->Orientation = glm::quat(angles);
+		}
+		else if(angles.x < barrelSteeringComponent->LowerRotationLimit)
+		{
+			angles.x  = barrelSteeringComponent->LowerRotationLimit;
+			transformComponent->Orientation = glm::quat(angles);
+		}
+
+		
+
 		if(inputController->Shoot && m_TimeSinceLastShot[tankSteeringComponent->Barrel] > 0.5)
 		{
 			EntityID clone = m_World->CloneEntity(barrelSteeringComponent->ShotTemplate);

src/Systems/TransformSystem.cpp

@@ -16,6 +16,7 @@
 void Systems::TransformSystem::Initialize()
 {
 	EVENT_SUBSCRIBE_MEMBER(m_EMove, &Systems::TransformSystem::OnMove);
+	EVENT_SUBSCRIBE_MEMBER(m_ERotate, &Systems::TransformSystem::OnRotate);
 }
 
 void Systems::TransformSystem::UpdateEntity( double dt, EntityID entity, EntityID parent )
@@ -23,14 +24,16 @@ void Systems::TransformSystem::UpdateEntity( double dt, EntityID entity, EntityI
 	if(m_MoveItems.find(entity) != m_MoveItems.end())
 	{
 		auto transform = m_World->GetComponent<Components::Transform>(entity);
-		glm::vec3 move = m_MoveItems[entity].GoalPosition - transform->Position;
-		move /= m_MoveItems[entity].Time;
-		m_MoveItems[entity].Time -= dt;
 
-		if(m_MoveItems[entity].Time <= 0)
+		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))
 		{
-			float movetime = dt + m_MoveItems[entity].Time;
-			transform->Position += move * movetime;
+			transform->Position = m_MoveItems[entity].GoalPosition;
 
 			m_MoveItems.erase(entity);
 
@@ -43,23 +46,80 @@ void Systems::TransformSystem::UpdateEntity( double dt, EntityID entity, EntityI
 		}
 		else
 		{
-			transform->Position += move * (float)dt;
+			transform->Position += movement;
+		}
+		
+	}
+
+	if(m_RotationItems.find(entity) != m_RotationItems.end())
+	{
+		auto transform = m_World->GetComponent<Components::Transform>(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 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 Systems::TransformSystem::OnMove( const Events::Move &event )
 {
 	MoveItems item;
 	item.Entity = event.Entity;
 	item.GoalPosition = event.GoalPosition;
-	item.Time = event.Time;
-	m_MoveItems[event.Entity] = item;
-
+	item.Speed = event.Speed;
+	
 	if(event.Queue)
 	{
-		m_QueuedMoveItems.insert(std::make_pair(event.Entity, item));
+		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;
 }

src/Systems/TransformSystem.h

@@ -4,6 +4,7 @@
 #include "System.h"
 #include "Components/Transform.h"
 #include "Events/Move.h"
+#include "Events/Rotate.h"
 #include <unordered_map>
 
 
@@ -29,16 +30,25 @@ public:
 	// 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;
-		double Time;
+		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/Systems/TriggerSystem.cpp

@@ -121,11 +121,13 @@ void Systems::TriggerSystem::Move( EntityID entity )
 	Events::Move e;
 	e.Entity = trigger->Entity;
 	e.GoalPosition = trigger->GoalPosition;
-	e.Time = trigger->Time;
+	e.Speed = trigger->Speed;
 	e.Queue = false;
 	EventBroker->Publish(e);
 
-	trigger->GoalPosition = transform->Position;
+	glm::vec3 temp = trigger->GoalPosition;
+	trigger->GoalPosition = trigger->StartPosition;
+	trigger->StartPosition = temp;
 }
 
 

src/Systems/TriggerSystem.h

@@ -19,6 +19,7 @@
 #include "Components/TriggerMove.h"
 #include "Components/Player.h"
 #include "Events/Move.h"
+#include "Events/Rotate.h"
 #include <math.h>
 namespace Systems
 {