Gate working

src/Components/Physics.h

@@ -8,6 +8,14 @@ namespace Components
 
 struct Physics : Component
 {
+	enum class CollisionLayer
+	{
+		STATIC = 1,
+		VEHICLE1_ = 2,
+		VEHICLE2 = 3,
+		EXPLOSION = 4,
+	};
+
 	Physics()
 		: Mass(1.f), Static(false), Phantom(false), CalculateCenterOfMass(true), CenterOfMass(glm::vec3(0)), InitialLinearVelocity(glm::vec3(0)), InitialAngularVelocity(glm::vec3(0)),
 	LinearDamping(0.f), AngularDamping(0.05f), GravityFactor(1.f), Friction(0.5f), Restitution(0.4f), MaxLinearVelocity(200.f), MaxAngularVelocity(200.f), 

src/Components/TriggerMove.h

@@ -0,0 +1,19 @@
+#ifndef TriggerMove_h__
+#define TriggerMove_h__
+
+#include "Component.h"
+
+namespace Components
+{
+
+	struct TriggerMove : Component
+	{
+		EntityID Entity;
+		float Time;
+		glm::vec3 GoalPosition;
+		virtual TriggerMove* Clone() const override { return new TriggerMove(*this); }
+	};
+
+}
+
+#endif // TriggerMove_h__

src/Events/LeaveTrigger.h

@@ -0,0 +1,17 @@
+#ifndef Events_LeaveTrigger_h__
+#define Events_LeaveTrigger_h__
+#include "Entity.h"
+#include "EventBroker.h"
+
+	namespace Events
+{
+
+	struct LeaveTrigger : Event
+	{
+		EntityID Entity1;
+		EntityID Entity2;
+	};
+
+}
+
+#endif // Events_LeaveTrigger_h__

src/Events/Move.h

@@ -0,0 +1,19 @@
+#ifndef Event_Move_h__
+#define Event_Move_h__
+
+#include "EventBroker.h"
+
+namespace Events
+{
+
+	struct Move : Event
+	{
+		EntityID Entity;
+		glm::vec3 GoalPosition;
+		double Time;
+		bool Queue;
+	};
+
+}
+
+#endif // Event_Move_h__

src/GameWorld.cpp

@@ -110,7 +110,7 @@ void GameWorld::Initialize()
 		auto physics = AddComponent<Components::Physics>(ground);
 		physics->Mass = 10;
 		physics->Static = true;
-		physics->CollisionLayer = 1;
+		physics->CollisionLayer = (int)Components::Physics::CollisionLayer::STATIC;
 
 		auto groundshape = CreateEntity(ground);
 		auto transformshape = AddComponent<Components::Transform>(groundshape);
@@ -200,10 +200,10 @@ void GameWorld::Initialize()
 		transform->Position = glm::vec3(0, -50, 150);
 		auto model = AddComponent<Components::Model>(gateBase);
 		model->ModelFile = "Models/Gate/Lift/Lift.obj";
-		
 		auto physics = AddComponent<Components::Physics>(gateBase);
 		physics->Static = true;
-		physics->CollisionLayer = 1; // Terrain-Layer
+		physics->CollisionLayer = (int)Components::Physics::CollisionLayer::STATIC;
+
 		{
 			auto leftBaseShape = CreateEntity(gateBase);
 			auto transform = AddComponent<Components::Transform>(leftBaseShape);
@@ -257,6 +257,63 @@ void GameWorld::Initialize()
 		CommitEntity(gateBase);
 	}
 
+	{
+		auto gate = CreateEntity();
+		auto transform = AddComponent<Components::Transform>(gate);
+		transform->Position = glm::vec3(0, -50, 150);
+		auto model = AddComponent<Components::Model>(gate);
+		model->ModelFile = "Models/Gate/Gate/Gate.obj";		
+		auto physics = AddComponent<Components::Physics>(gate);
+		physics->Static = true;
+		physics->CollisionLayer = (int)Components::Physics::CollisionLayer::STATIC;
+
+		{
+			auto mainShape = CreateEntity(gate);
+			auto transform = AddComponent<Components::Transform>(mainShape);
+			transform->Position = glm::vec3(0.f, 3.09776f, 0.f);
+			auto box = AddComponent<Components::BoxShape>(mainShape);
+			box->Width = 6.963f;
+			box->Height = 2.478f;
+			box->Depth = 0.522f;
+			CommitEntity(mainShape);
+		}
+		{
+			auto lowerShape = CreateEntity(gate);
+			auto transform = AddComponent<Components::Transform>(lowerShape);
+			transform->Position = glm::vec3(0.f, 0.35f, 0.f);
+			auto box = AddComponent<Components::BoxShape>(lowerShape);
+			box->Width = 6.963f;
+			box->Height = 0.308f;
+			box->Depth = 0.222f;
+			CommitEntity(lowerShape);
+		}
+		CommitEntity(gate);
+
+		{
+			auto gateTrigger = CreateEntity();
+			auto transform = AddComponent<Components::Transform>(gateTrigger);
+			transform->Position = glm::vec3(0, -50 + 2.8241, 150);
+			auto trigger = AddComponent<Components::Trigger>(gateTrigger);
+			auto triggerMove = AddComponent<Components::TriggerMove>(gateTrigger);
+			triggerMove->Entity = gate;
+			triggerMove->Time = 3.f;
+			triggerMove->GoalPosition = glm::vec3(0, -50 + 9.02345f, 150);
+			
+
+			{
+				auto shape = CreateEntity(gateTrigger);
+				auto transform = AddComponent<Components::Transform>(shape);
+				transform->Position = glm::vec3(0.f, 2.8241f, 0.f);
+				auto box = AddComponent<Components::BoxShape>(shape);
+				box->Width = 6.963f;
+				box->Height = 3.104f;
+				box->Depth = 10.356f;
+				CommitEntity(shape);
+			}
+			CommitEntity(gateTrigger);
+		}
+
+	}
 }
 
 void GameWorld::Update(double dt)

src/Systems/PhysicsSystem.cpp

@@ -112,20 +112,8 @@ void Systems::PhysicsSystem::Initialize()
 		m_collisionResolution = new MyCollisionResolution(this);
 	}
 	
-	enum
-	{
-		GROUND_LAYER = 1,
-		VEHICLE1_LAYER = 2,
-		VEHICLE2_LAYER = 3,
-		EXPLOSION_LAYER = 4,
-	};
-/*
-	{
-		Events::DisableCollisions e;
-		e.Layer1 = GROUND_LAYER;
-		e.Layer2 = EXPLOSION_LAYER;
-		EventBroker->Publish(e);
-	}*/
+	
+
 	/*{
 		Events::DisableCollisions e;
 		e.Layer1 = VEHICLE1_LAYER;
@@ -170,7 +158,7 @@ void Systems::PhysicsSystem::Update(double dt)
 		if (!transformComponent)
 			continue;
 
-		if(m_RigidBodies[entity]->isActive())
+		if(/*m_RigidBodies[entity]->isActive()*/ true)
 		{
 			hkVector4 position;
 			hkQuaternion rotation;

src/Systems/PhysicsSystem.h

@@ -28,6 +28,7 @@
 #include "Events/ApplyForce.h"
 #include "Events/ApplyPointImpulse.h"
 #include "Events/Collision.h"
+#include "Events/LeaveTrigger.h"
 #include "OBJ.h"
 
 // Math and base include
@@ -139,7 +140,16 @@ public:
 
 		virtual void phantomLeaveEvent( const hkpCollidable* collidableA, const hkpCollidable* collidableB )
 		{
+			EntityID entity1 = m_PhysicsSystem->m_RigidBodyEntities[hkpGetRigidBody(collidableA)];
+			EntityID entity2 = m_PhysicsSystem->m_RigidBodyEntities[hkpGetRigidBody(collidableB)];
 
+			if(m_PhysicsSystem->m_World->ValidEntity(entity1) && m_PhysicsSystem->m_World->ValidEntity(entity2))
+			{
+				Events::LeaveTrigger e;
+				e.Entity1 = entity1;
+				e.Entity2 = entity2;
+				m_PhysicsSystem->EventBroker->Publish(e);
+			}
 		}
 
 	private:
@@ -180,7 +190,6 @@ private:
 	EventRelay<PhysicsSystem, Events::DisableCollisions> m_EDisableCollisions;
 	bool OnDisableCollisions(const Events::DisableCollisions &e);
 
-
 	void SetUpPhysicsState(EntityID entity, EntityID parent);
 	void TearDownPhysicsState(EntityID entity, EntityID parent);
 

src/Systems/TransformSystem.cpp

@@ -13,6 +13,58 @@
 //	transform->Position = parentTransform->Position + transform->RelativePosition;
 //}
 
+void Systems::TransformSystem::Initialize()
+{
+	EVENT_SUBSCRIBE_MEMBER(m_EMove, &Systems::TransformSystem::OnMove);
+}
+
+void 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 move = m_MoveItems[entity].GoalPosition - transform->Position;
+		move *= m_MoveItems[entity].Time;
+		m_MoveItems[entity].Time -= dt;
+
+		if(m_MoveItems[entity].Time <= 0)
+		{
+			float movetime = dt + m_MoveItems[entity].Time;
+			transform->Position += move * movetime;
+
+			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 += move * (float)dt;
+		}
+	}
+}
+
+
+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;
+
+	if(event.Queue)
+	{
+		m_QueuedMoveItems.insert(std::make_pair(event.Entity, item));
+	}
+	return true;
+}
+
+
 glm::vec3 Systems::TransformSystem::AbsolutePosition(EntityID entity)
 {
 	glm::vec3 absPosition;
@@ -91,3 +143,6 @@ Components::Transform Systems::TransformSystem::AbsoluteTransform(EntityID entit
 
 	return transform;
 }
+
+
+

src/Systems/TransformSystem.h

@@ -3,6 +3,9 @@
 
 #include "System.h"
 #include "Components/Transform.h"
+#include "Events/Move.h"
+#include <unordered_map>
+
 
 namespace Systems
 {
@@ -14,12 +17,28 @@ public:
 		: System(world, eventBroker, resourceManager)
 	{ }
 	//void Update(double dt) override;
-	//void UpdateEntity(double dt, EntityID entity, EntityID parent) override;
+
+	void Initialize() 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);
+private:
+	struct MoveItems
+	{
+		EntityID Entity;
+		glm::vec3 GoalPosition;
+		double Time;
+	};
+	std::unordered_map<EntityID, MoveItems> m_MoveItems;
+	std::multimap<EntityID, MoveItems> m_QueuedMoveItems;
+
 };
 
 }

src/Systems/TriggerSystem.cpp

@@ -6,11 +6,13 @@ void Systems::TriggerSystem::RegisterComponents( ComponentFactory* cf )
 {
 	cf->Register<Components::Trigger>([]() { return new Components::Trigger(); });
 	cf->Register<Components::TriggerExplosion>([]() { return new Components::TriggerExplosion(); });
+	cf->Register<Components::TriggerMove>([]() { return new Components::TriggerMove(); });
 }
 
 void Systems::TriggerSystem::Initialize()
 {
 	EVENT_SUBSCRIBE_MEMBER(m_EEnterTrigger, &Systems::TriggerSystem::OnEnterTrigger);
+	EVENT_SUBSCRIBE_MEMBER(m_ELeaveTrigger, &Systems::TriggerSystem::OnLeaveTrigger);
 }
 
 void Systems::TriggerSystem::Update( double dt )
@@ -69,10 +71,64 @@ bool Systems::TriggerSystem::OnEnterTrigger( const Events::EnterTrigger &event )
 		Flag(event.Entity1, event.Entity2);
 	}
 
+
+	auto triggerComponent1 = m_World->GetComponent<Components::TriggerMove>(event.Entity1);
+	auto triggerComponent2 = m_World->GetComponent<Components::TriggerMove>(event.Entity2);
+
+	auto playerComponent1 = m_World->GetComponent<Components::Player>(event.Entity1);
+	auto playerComponent2 = m_World->GetComponent<Components::Player>(event.Entity2);
+
+	if(triggerComponent1 && playerComponent2)
+	{
+		Move(event.Entity1);
+	}
+	else if (triggerComponent2 && playerComponent1)
+	{
+		Move(event.Entity2);
+	}
+
 	return true;
 }
 
 
+bool Systems::TriggerSystem::OnLeaveTrigger( const Events::LeaveTrigger &event )
+{
+	auto triggerComponent1 = m_World->GetComponent<Components::TriggerMove>(event.Entity1);
+	auto triggerComponent2 = m_World->GetComponent<Components::TriggerMove>(event.Entity2);
+
+	auto playerComponent1 = m_World->GetComponent<Components::Player>(event.Entity1);
+	auto playerComponent2 = m_World->GetComponent<Components::Player>(event.Entity2);
+
+	if(triggerComponent1 && playerComponent2)
+	{
+		Move(event.Entity1);
+	}
+	else if (triggerComponent2 && playerComponent1)
+	{
+		Move(event.Entity2);
+	}
+
+	return true;
+}
+
+
+
+void Systems::TriggerSystem::Move( EntityID entity )
+{
+	auto trigger = m_World->GetComponent<Components::TriggerMove>(entity);
+	auto transform = m_World->GetComponent<Components::Transform>(trigger->Entity);
+	
+	Events::Move e;
+	e.Entity = trigger->Entity;
+	e.GoalPosition = trigger->GoalPosition;
+	e.Time = trigger->Time;
+	e.Queue = false;
+	EventBroker->Publish(e);
+
+	trigger->GoalPosition = transform->Position;
+}
+
+
 void Systems::TriggerSystem::Flag( EntityID entity, EntityID phantomEntity )
 {
 	auto tankSteering = m_World->GetComponent<Components::TankSteering>(entity);

src/Systems/TriggerSystem.h

@@ -14,7 +14,11 @@
 #include "Components/Trigger.h"
 #include "Components/TriggerExplosion.h"
 #include "Events/EnterTrigger.h"
+#include "Events/LeaveTrigger.h"
 #include "Components/Flag.h"
+#include "Components/TriggerMove.h"
+#include "Components/Player.h"
+#include "Events/Move.h"
 #include <math.h>
 namespace Systems
 {
@@ -36,10 +40,12 @@ namespace Systems
 
 		EventRelay<TriggerSystem, Events::EnterTrigger> m_EEnterTrigger;
 		bool OnEnterTrigger(const Events::EnterTrigger &event);
+		EventRelay<TriggerSystem, Events::LeaveTrigger> m_ELeaveTrigger;
+		bool OnLeaveTrigger(const Events::LeaveTrigger &event);
 	private:
 		void Flag(EntityID entity, EntityID phantomEntity);
 		void Explosion(EntityID entity, EntityID phantomEntity);
-
+		void Move(EntityID entity);
 	};
 
 }