Merge branch 'master' into particles

Conflicts:
	src/GameWorld.cpp
	vs11/Returngeance/Returngeance.vcxproj
	vs11/Returngeance/Returngeance.vcxproj.filters

src/Systems/DebugSystem.cpp

@@ -19,10 +19,10 @@ bool Systems::DebugSystem::OnKeyDown(const Events::KeyDown &event)
 {
 	if (event.KeyCode == GLFW_KEY_ENTER)
 	{
-		Events::PlaySound e;
+		Events::PlaySFX e;
 		e.Emitter = 0;
 		e.Resource = "Sounds/korvring.wav";
-		EventBroker->Publish<Events::PlaySound>(e);
+		EventBroker->Publish<Events::PlaySFX>(e);
 
 		return true;
 	}

src/Systems/DebugSystem.h

@@ -4,7 +4,7 @@
 #include "System.h"
 #include "Components/Transform.h"
 #include "Events/KeyDown.h"
-#include "Events/PlaySound.h"
+#include "Events/PlaySFX.h"
 
 namespace Systems
 {

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/GarageSystem.cpp

@@ -0,0 +1,142 @@
+#include "PrecompiledHeader.h"
+#include "GarageSystem.h"
+#include "World.h"
+
+void Systems::GarageSystem::RegisterComponents( ComponentFactory* cf )
+{
+	cf->Register<Components::Garage>([]() { return new Components::Garage(); });
+	cf->Register<Components::SpawnPoint>([]() { return new Components::SpawnPoint(); });
+}
+
+void Systems::GarageSystem::Initialize()
+{
+	EVENT_SUBSCRIBE_MEMBER(m_EEnterTrigger, &Systems::GarageSystem::OnEnterTrigger);
+	EVENT_SUBSCRIBE_MEMBER(m_ELeaveTrigger, &Systems::GarageSystem::OnLeaveTrigger);
+	EVENT_SUBSCRIBE_MEMBER(m_ECommand, &Systems::GarageSystem::OnCommand);
+}
+
+void Systems::GarageSystem::Update(double dt)
+{
+
+}
+
+void Systems::GarageSystem::UpdateEntity(double dt, EntityID entity, EntityID parent)
+{
+
+}
+
+bool Systems::GarageSystem::OnEnterTrigger(const Events::EnterTrigger &event)
+{
+	EntityID garage = m_World->GetEntityParent(event.Trigger);
+	if (garage == 0)
+		return false;
+	auto garageComponent = m_World->GetComponent<Components::Garage>(garage);
+	if (!garageComponent)
+		return false;
+
+	std::string name = m_World->GetProperty<std::string>(event.Trigger, "Name");
+
+	if (name == "BoundsTrigger")
+	{
+		ToggleGarage(garageComponent);
+	}
+
+	m_EntitiesInTrigger[event.Trigger].insert(event.Entity);
+
+	return true;
+}
+
+
+bool Systems::GarageSystem::OnLeaveTrigger(const Events::LeaveTrigger &event)
+{
+	EntityID garage = m_World->GetEntityParent(event.Trigger);
+	if (garage == 0)
+		return false;
+	auto garageComponent = m_World->GetComponent<Components::Garage>(garage);
+	if (!garageComponent)
+		return false;
+
+	std::string name = m_World->GetProperty<std::string>(event.Trigger, "Name");
+
+	if (name == "BoundsTrigger")
+	{
+		ToggleGarage(garageComponent);
+	}
+
+	m_EntitiesInTrigger[event.Trigger].erase(event.Entity);
+
+	return true;
+}
+
+bool Systems::GarageSystem::OnCommand(const Events::InputCommand &event)
+{
+	if (event.Command == "use" && event.Value > 0)
+	{
+		for (auto &pair : m_EntitiesInTrigger)
+		{
+			EntityID trigger = pair.first;
+			auto entities = pair.second;
+
+			std::string name = m_World->GetProperty<std::string>(trigger, "Name");
+			if (name != "ElevatorShaftTrigger")
+				continue;
+
+			auto triggerBaseParent = m_World->GetEntityBaseParent(trigger);
+			auto triggerPlayerComponent = m_World->GetComponent<Components::Player>(triggerBaseParent);
+
+			for (EntityID entity : entities)
+			{
+				auto entityPlayerComponent = m_World->GetComponent<Components::Player>(triggerBaseParent);
+				if (triggerPlayerComponent == entityPlayerComponent)
+				{
+					EntityID garage = m_World->GetEntityParent(trigger);
+					auto garageComponent = m_World->GetComponent<Components::Garage>(garage);
+					ToggleGarage(garageComponent);
+				}
+			}
+		}
+	}
+
+	return true;
+}
+
+void Systems::GarageSystem::ToggleGarage(Components::Garage* garageComponent)
+{
+	// Elevator
+	if (garageComponent->Elevator != 0)
+	{
+		auto move = m_World->GetComponent<Components::Move>(garageComponent->Elevator);
+		Events::Move e;
+		e.Entity = garageComponent->Elevator;
+		e.GoalPosition = move->GoalPosition;
+		e.Speed = move->Speed;
+		e.Queue = true;
+		EventBroker->Publish(e);
+		std::swap(move->GoalPosition, move->StartPosition);
+	}
+	
+	// Left door
+	if (garageComponent->DoorLeft != 0)
+	{
+		auto rotate = m_World->GetComponent<Components::Rotate>(garageComponent->DoorLeft);
+		Events::Rotate e;
+		e.Entity = garageComponent->DoorLeft;
+		e.GoalRotation = rotate->GoalRotation;
+		e.Time = rotate->Time;
+		e.Queue = true;
+		EventBroker->Publish(e);
+		std::swap(rotate->GoalRotation, rotate->StartRotation);
+	}
+	// Right door
+	if (garageComponent->DoorRight != 0)
+	{
+		auto rotate = m_World->GetComponent<Components::Rotate>(garageComponent->DoorRight);
+		Events::Rotate e;
+		e.Entity = garageComponent->DoorRight;
+		e.GoalRotation = rotate->GoalRotation;
+		e.Time = rotate->Time;
+		e.Queue = true;
+		EventBroker->Publish(e);
+		std::swap(rotate->GoalRotation, rotate->StartRotation);
+	}
+}

src/Systems/GarageSystem.h

@@ -0,0 +1,51 @@
+#ifndef GarageSystem_h__
+#define GarageSystem_h__
+
+#include <set>
+
+#include "System.h"
+#include "Components/Transform.h"
+#include "Components/Trigger.h"
+#include "Components/Garage.h"
+#include "Components/SpawnPoint.h"
+#include "Events/EnterTrigger.h"
+#include "Events/LeaveTrigger.h"
+#include "Events/SpawnVehicle.h"
+#include "Events/InputCommand.h"
+
+#include "Components/Player.h"
+#include "Events/Move.h"
+#include "Events/Rotate.h"
+#include "Components/Move.h"
+#include "Components/Rotate.h"
+
+namespace Systems
+{
+	class GarageSystem : public System
+	{
+	public:
+
+		GarageSystem(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;
+
+	private:
+		std::map<EntityID, std::set<EntityID>> m_EntitiesInTrigger;
+		
+		EventRelay<GarageSystem, Events::EnterTrigger> m_EEnterTrigger;
+		bool OnEnterTrigger(const Events::EnterTrigger &event);
+		EventRelay<GarageSystem, Events::LeaveTrigger> m_ELeaveTrigger;
+		bool OnLeaveTrigger(const Events::LeaveTrigger &event);
+		EventRelay<GarageSystem, Events::InputCommand> m_ECommand;
+		bool OnCommand(const Events::InputCommand &event);
+
+		void ToggleGarage(Components::Garage* garageComponent);
+	
+	};
+
+}
+#endif // GarageSystem_h__

src/Systems/InputSystem.cpp

@@ -46,8 +46,8 @@ void Systems::InputSystem::Update(double dt)
 
 bool Systems::InputSystem::OnKeyDown(const Events::KeyDown &event)
 {
-	auto bindingIt = m_KeyBindings.find(event.KeyCode);
-	if (bindingIt != m_KeyBindings.end())
+	auto range = m_KeyBindings.equal_range(event.KeyCode);
+	for (auto bindingIt = range.first; bindingIt != range.second; bindingIt++)
 	{
 		std::string command;
 		float value;
@@ -61,8 +61,8 @@ bool Systems::InputSystem::OnKeyDown(const Events::KeyDown &event)
 
 bool Systems::InputSystem::OnKeyUp(const Events::KeyUp &event)
 {
-	auto bindingIt = m_KeyBindings.find(event.KeyCode);
-	if (bindingIt != m_KeyBindings.end())
+	auto range = m_KeyBindings.equal_range(event.KeyCode);
+	for (auto bindingIt = range.first; bindingIt != range.second; bindingIt++)
 	{
 		std::string command;
 		float value;
@@ -76,8 +76,8 @@ bool Systems::InputSystem::OnKeyUp(const Events::KeyUp &event)
 
 bool Systems::InputSystem::OnMousePress(const Events::MousePress &event)
 {
-	auto bindingIt = m_MouseButtonBindings.find(event.Button);
-	if (bindingIt != m_MouseButtonBindings.end())
+	auto range = m_MouseButtonBindings.equal_range(event.Button);
+	for (auto bindingIt = range.first; bindingIt != range.second; bindingIt++)
 	{
 		std::string command;
 		float value;
@@ -91,8 +91,8 @@ bool Systems::InputSystem::OnMousePress(const Events::MousePress &event)
 
 bool Systems::InputSystem::OnMouseRelease(const Events::MouseRelease &event)
 {
-	auto bindingIt = m_MouseButtonBindings.find(event.Button);
-	if (bindingIt != m_MouseButtonBindings.end())
+	auto range = m_MouseButtonBindings.equal_range(event.Button);
+	for (auto bindingIt = range.first; bindingIt != range.second; bindingIt++)
 	{
 		std::string command;
 		float value;
@@ -106,8 +106,8 @@ bool Systems::InputSystem::OnMouseRelease(const Events::MouseRelease &event)
 
 bool Systems::InputSystem::OnGamepadAxis(const Events::GamepadAxis &event)
 {
-	auto bindingIt = m_GamepadAxisBindings.find(event.Axis);
-	if (bindingIt != m_GamepadAxisBindings.end())
+	auto range = m_GamepadAxisBindings.equal_range(event.Axis);
+	for (auto bindingIt = range.first; bindingIt != range.second; bindingIt++)
 	{
 		std::string command;
 		float value;
@@ -121,8 +121,8 @@ bool Systems::InputSystem::OnGamepadAxis(const Events::GamepadAxis &event)
 
 bool Systems::InputSystem::OnGamepadButtonDown(const Events::GamepadButtonDown &event)
 {
-	auto bindingIt = m_GamepadButtonBindings.find(event.Button);
-	if (bindingIt != m_GamepadButtonBindings.end())
+	auto range = m_GamepadButtonBindings.equal_range(event.Button);
+	for (auto bindingIt = range.first; bindingIt != range.second; bindingIt++)
 	{
 		std::string command;
 		float value;
@@ -136,8 +136,8 @@ bool Systems::InputSystem::OnGamepadButtonDown(const Events::GamepadButtonDown &
 
 bool Systems::InputSystem::OnGamepadButtonUp(const Events::GamepadButtonUp &event)
 {
-	auto bindingIt = m_GamepadButtonBindings.find(event.Button);
-	if (bindingIt != m_GamepadButtonBindings.end())
+	auto range = m_GamepadButtonBindings.equal_range(event.Button);
+	for (auto bindingIt = range.first; bindingIt != range.second; bindingIt++)
 	{
 		std::string command;
 		float value;
@@ -149,18 +149,13 @@ bool Systems::InputSystem::OnGamepadButtonUp(const Events::GamepadButtonUp &even
 	return true;
 }
 
-
 bool Systems::InputSystem::OnBindKey(const Events::BindKey &event)
 {
 	if (event.Command.empty())
-	{
-		m_KeyBindings.erase(event.KeyCode);
-	}
-	else
-	{
-		m_KeyBindings[event.KeyCode] = std::make_tuple(event.Command, event.Value);
-		LOG_DEBUG("Input: Bound key %c to %s", (char)event.KeyCode, event.Command.c_str());
-	}
+		return false;
+
+	m_KeyBindings.insert(std::make_pair(event.KeyCode, std::make_tuple(event.Command, event.Value)));
+	LOG_DEBUG("Input: Bound key %i to %s", event.KeyCode, event.Command.c_str());
 
 	return true;
 }
@@ -168,14 +163,10 @@ bool Systems::InputSystem::OnBindKey(const Events::BindKey &event)
 bool Systems::InputSystem::OnBindMouseButton(const Events::BindMouseButton &event)
 {
 	if (event.Command.empty())
-	{
-		m_MouseButtonBindings.erase(event.Button);
-	}
-	else
-	{
-		m_MouseButtonBindings[event.Button] = std::make_tuple(event.Command, event.Value);
-		LOG_DEBUG("Input: Bound mouse button %i to %s", event.Button, event.Command.c_str());
-	}
+		return false;
+
+	m_MouseButtonBindings.insert(std::make_pair(event.Button, std::make_tuple(event.Command, event.Value)));
+	LOG_DEBUG("Input: Bound mouse button %i to %s", event.Button, event.Command.c_str());
 
 	return true;
 }
@@ -183,14 +174,10 @@ bool Systems::InputSystem::OnBindMouseButton(const Events::BindMouseButton &even
 bool Systems::InputSystem::OnBindGamepadAxis(const Events::BindGamepadAxis &event)
 {
 	if (event.Command.empty())
-	{
-		m_GamepadAxisBindings.erase(event.Axis);
-	}
-	else
-	{
-		m_GamepadAxisBindings[event.Axis] = std::make_tuple(event.Command, event.Value);
-		LOG_DEBUG("Input: Bound gamepad axis %i to %s", event.Axis, event.Command.c_str());
-	}
+		return false;
+
+	m_GamepadAxisBindings.insert(std::make_pair(event.Axis, std::make_tuple(event.Command, event.Value)));
+	LOG_DEBUG("Input: Bound gamepad axis %i to %s", event.Axis, event.Command.c_str());
 
 	return true;
 }
@@ -198,14 +185,10 @@ bool Systems::InputSystem::OnBindGamepadAxis(const Events::BindGamepadAxis &even
 bool Systems::InputSystem::OnBindGamepadButton(const Events::BindGamepadButton &event)
 {
 	if (event.Command.empty())
-	{
-		m_GamepadButtonBindings.erase(event.Button);
-	}
-	else
-	{
-		m_GamepadButtonBindings[event.Button] = std::make_tuple(event.Command, event.Value);
-		LOG_DEBUG("Input: Bound gamepad axis %i to %s", event.Button, event.Command.c_str());
-	}
+		return false;
+
+	m_GamepadButtonBindings.insert(std::make_pair(event.Button, std::make_tuple(event.Command, event.Value)));
+	LOG_DEBUG("Input: Bound gamepad axis %i to %s", event.Button, event.Command.c_str());
 
 	return true;
 }

src/Systems/InputSystem.h

@@ -40,10 +40,10 @@ private:
 	std::unordered_map<std::string, std::unordered_map<Gamepad::Axis, float>> m_CommandGamepadAxisValues; // command string -> gamepad axis value for command
 	std::unordered_map<std::string, std::unordered_map<Gamepad::Button, float>> m_CommandGamepadButtonValues; // command string -> gamepad button value for command
 	// Input binding tables
-	std::unordered_map<int, std::tuple<std::string, float>> m_KeyBindings; // GLFW_KEY... -> command string & value
-	std::unordered_map<int, std::tuple<std::string, float>> m_MouseButtonBindings; // GLFW_MOUSE_BUTTON... -> command string
-	std::unordered_map<Gamepad::Axis, std::tuple<std::string, float>> m_GamepadAxisBindings; // Gamepad::Axis -> command string & value
-	std::unordered_map<Gamepad::Button, std::tuple<std::string, float>> m_GamepadButtonBindings; // Gamepad::Button -> command string
+	std::unordered_multimap<int, std::tuple<std::string, float>> m_KeyBindings; // GLFW_KEY... -> command string & value
+	std::unordered_multimap<int, std::tuple<std::string, float>> m_MouseButtonBindings; // GLFW_MOUSE_BUTTON... -> command string
+	std::unordered_multimap<Gamepad::Axis, std::tuple<std::string, float>> m_GamepadAxisBindings; // Gamepad::Axis -> command string & value
+	std::unordered_multimap<Gamepad::Button, std::tuple<std::string, float>> m_GamepadButtonBindings; // Gamepad::Button -> command string
 
 	// Input events
 	EventRelay<InputSystem, Events::KeyDown> m_EKeyDown;

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,31 +158,34 @@ void Systems::PhysicsSystem::Update(double dt)
 		if (!transformComponent)
 			continue;
 
-		if(m_RigidBodies[entity]->isActive())
-		{
-			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());
@@ -291,26 +282,27 @@ void Systems::PhysicsSystem::OnEntityCommit( EntityID entity )
 		m_Wheels.push_back(entity);
 	}
 
-	EntityID entityParent = m_World->GetEntityBaseParent(entity);
+	EntityID entityParent = m_World->GetEntityParent(entity);
 
 	auto sphereComponent = m_World->GetComponent<Components::SphereShape>(entity);
 	auto boxComponent = m_World->GetComponent<Components::BoxShape>(entity);
 	auto meshShapeComponent = m_World->GetComponent<Components::MeshShape >(entity);
 	
-	if(entityParent == entity && (sphereComponent || boxComponent || meshShapeComponent))
+	if(entityParent == 0 && (sphereComponent || boxComponent || meshShapeComponent))
 	{
-		LOG_ERROR("Entity: %i , Only the children can have a shapeComponent", entity);
+		LOG_ERROR("Entity: %i, Only the children can have a shapeComponent", entity);
 		return;
 	}
 
 	auto physicsComponent = m_World->GetComponent<Components::Physics>(entity);
 	if (physicsComponent && m_Shapes[entity].size() > 0)
 	{
-		if(entityParent != entity)
+		if(entityParent != 0 && !physicsComponent->Static)
 		{
-			LOG_ERROR("Entity: %i , Only the baseparent can have a PhysicsComponent", entity);
+			LOG_ERROR("Entity: %i, Only the baseparent can have a dynamic PhysicsComponent", entity);
 			return;
 		}
+
 		hkpShape* shape;	
 		if(! physicsComponent->Static) // Not static
 		{
@@ -498,7 +490,7 @@ void Systems::PhysicsSystem::OnEntityCommit( EntityID entity )
 			hkpRigidBodyCinfo rigidBodyInfo;
 			{
 				rigidBodyInfo.m_shape = shape;
-				rigidBodyInfo.m_motionType = hkpMotion::MOTION_FIXED;
+				rigidBodyInfo.m_motionType = hkpMotion::MOTION_KEYFRAMED;
 				auto absoluteTransform = m_World->GetSystem<Systems::TransformSystem>()->AbsoluteTransform(entity);
 				hkVector4 position = GLMVEC3_TO_HKVECTOR4(absoluteTransform.Position);
 				hkQuaternion rotation = GLMQUAT_TO_HKQUATERNION(absoluteTransform.Orientation);
@@ -681,11 +673,6 @@ void Systems::PhysicsSystem::TearDownPhysicsState(EntityID entity, EntityID pare
 
 }
 
-void Systems::PhysicsSystem::OnComponentCreated(std::string type, std::shared_ptr<Component> component)
-{
-
-}
-
 void Systems::PhysicsSystem::SetupVisualDebugger(hkpPhysicsContext* worlds)
 {
 	// Setup the visual debugger
@@ -737,18 +724,12 @@ bool Systems::PhysicsSystem::OnTankSteer(const Events::TankSteer &event)
 		{
 			steeringX = (1 - (glm::clamp(abs(m_Vehicles[event.Entity]->calcKMPH() /vehicleComponent->TopSpeed), 0.f, 0.7f))) * steeringX;
 		}
-
 		
 		if(abs(m_Vehicles[event.Entity]->calcKMPH()) < 2 && abs(m_Vehicles[event.Entity]->m_mainSteeringAngle) > 80.f * (HK_REAL_PI / 180))
 		{
 			deviceStatus->m_positionY = -0.4f;
 			deviceStatus->m_positionX = steeringX;
 		}
-// 		else if(m_Vehicles[event.Entity]->calcKMPH() > -2 && abs(m_Vehicles[event.Entity]->m_mainSteeringAngle) > 80.f * (HK_REAL_PI / 180))
-// 		{
-// 			deviceStatus->m_positionY = 0.4f;;
-// 			deviceStatus->m_positionX = -steeringX;
-// 		}
 		else
 		{
 			deviceStatus->m_positionX = steeringX;
@@ -769,9 +750,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/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
@@ -131,15 +132,24 @@ public:
 			if(m_PhysicsSystem->m_World->ValidEntity(entity1) && m_PhysicsSystem->m_World->ValidEntity(entity2))
 			{
 				Events::EnterTrigger e;
-				e.Entity1 = entity1;
-				e.Entity2 = entity2;
+				e.Trigger = entity1;
+				e.Entity = entity2;
 				m_PhysicsSystem->EventBroker->Publish(e);
 			}
 		}
 
 		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.Trigger = entity1;
+				e.Entity = entity2;
+				m_PhysicsSystem->EventBroker->Publish(e);
+			}
 		}
 
 	private:
@@ -155,7 +165,6 @@ public:
 
 	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;
@@ -180,7 +189,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/SoundSystem.cpp

@@ -4,157 +4,203 @@
 
 void Systems::SoundSystem::Initialize()
 {
-	//initialize OpenAL
-	ALCdevice* Device = alcOpenDevice(NULL);
-	ALCcontext* context;
-	if(Device)
+	EVENT_SUBSCRIBE_MEMBER(m_EComponentCreated, &SoundSystem::OnComponentCreated);
+	EVENT_SUBSCRIBE_MEMBER(m_EPlaySFX, &SoundSystem::PlaySFX);
+	EVENT_SUBSCRIBE_MEMBER(m_EPlayBGM, &SoundSystem::PlayBGM);
+	EVENT_SUBSCRIBE_MEMBER(m_EStopSound, &SoundSystem::StopSound);
+	
+	m_TransformSystem = m_World->GetSystem<Systems::TransformSystem>();
+	FMOD_System_Create(&m_System);
+	FMOD_RESULT result = FMOD_System_Init(m_System, 32, FMOD_INIT_3D_RIGHTHANDED, 0);
+	if(result != FMOD_OK)
 	{
-		context = alcCreateContext(Device, NULL);
-		alcMakeContextCurrent(context);
+		LOG_ERROR("Did initialized load FMOD correctly");
 	}
 	else
 	{
-		LOG_ERROR("OMG OPEN AL FAIL");
+		LOG_INFO("FMOD initialized successfully");
 	}
-
-	alGetError();
-
-	alSpeedOfSound(340.29f); // Speed of sound
-	alDistanceModel(AL_INVERSE_DISTANCE_CLAMPED);
-
-	// Subscribe to events
-	m_EPlaySound = decltype(m_EPlaySound)(std::bind(&Systems::SoundSystem::OnPlaySound, this, std::placeholders::_1));
-	EventBroker->Subscribe(m_EPlaySound);
+	FMOD_System_Set3DSettings(m_System, 1.f, 1.f, 1.f); //dopplerScale, distancefactor, rolloffscale
+	
 }
 
 void Systems::SoundSystem::RegisterComponents(ComponentFactory* cf)
 {
 	cf->Register<Components::SoundEmitter>([]() { return new Components::SoundEmitter(); });
+	cf->Register<Components::Listener>([]() { return new Components::Listener(); });
 }
 
 void Systems::SoundSystem::RegisterResourceTypes(std::shared_ptr<::ResourceManager> rm)
 {
-	rm->RegisterType("Sound", [](std::string resourceName) { return new Sound(resourceName); });
+	rm->RegisterType("Sound3D", [this](std::string resourceName) { return new Sound(resourceName, this->m_System, Components::SoundEmitter::SoundType::SOUND_3D); });
+	rm->RegisterType("Sound2D", [this](std::string resourceName) { return new Sound(resourceName, this->m_System, Components::SoundEmitter::SoundType::SOUND_2D); });
 }
 
 void Systems::SoundSystem::Update(double dt)
 {
+	FMOD_System_Update(m_System);
+	
+	//Delete sounds. Not until it's done playing
+	std::map<EntityID, FMOD_CHANNEL*>::iterator it;
+	for(it = m_DeleteChannels.begin(); it != m_DeleteChannels.end();)
+	{
+		FMOD_BOOL *isPlaying = false;
+		FMOD_Channel_IsPlaying(it->second, isPlaying);
+		if(isPlaying)
+		{
+			it++;
+		}
+		else
+		{
+			FMOD_Sound_Release(m_DeleteSounds[it->first]);
+			m_DeleteSounds.erase(it->first);
+			it = m_DeleteChannels.erase(it);
+		}
 
+	}
 }
 
 void Systems::SoundSystem::UpdateEntity(double dt, EntityID entity, EntityID parent)
 {
-	auto transformComponent = m_World->GetComponent<Components::Transform>(entity);
-	if (transformComponent == nullptr)
-		return;
-
-	auto entityName = m_World->GetProperty<std::string>(entity, "Name");
-	if (entityName == "Camera")
+	auto listener = m_World->GetComponent<Components::Listener>(entity);
+	if(listener)
 	{
-		glm::vec3 playerPos = transformComponent->Position;
-		ALfloat listenerPos[3] = { playerPos.x, playerPos.y, -playerPos.z };
+		int lID = std::find(m_Listeners.begin(), m_Listeners.end(), entity) - m_Listeners.begin();
+		auto lTransform = m_World->GetComponent<Components::Transform>(entity);
+		
+		glm::vec3 tPos = m_TransformSystem->AbsolutePosition(entity);
+		FMOD_VECTOR lPos = {tPos.x, tPos.y, tPos.z}; 
 
-		glm::vec3 playerVel = transformComponent->Velocity;
-		ALfloat listenerVel[3] = { playerVel.x, playerVel.y, -playerVel.z };
+		glm::vec3 tVel = (lTransform->Velocity * 1000.f) / (float)dt;
+		FMOD_VECTOR lVel = {tVel.x, tVel.y, tVel.z};
 
-		glm::fquat playerQuatOri = transformComponent->Orientation;
-		glm::vec3 playerOriFW = glm::rotate(playerQuatOri, glm::vec3(0, 0, -1));
-		glm::vec3 playerOriUP = glm::rotate(playerQuatOri, glm::vec3(0, 1, 0));
-		ALfloat listenerOri[6] = { playerOriFW.x, playerOriFW.y, playerOriFW.z, playerOriUP.x, playerOriUP.y, playerOriUP.z };
+		glm::vec3 tUp = glm::normalize(lTransform->Orientation * glm::vec3(0,1,0));
+		FMOD_VECTOR lUp = {tUp.x, tUp.y, tUp.z}; 
+		glm::vec3 tForward = glm::normalize(lTransform->Orientation * glm::vec3(0,0,-1));
+		FMOD_VECTOR lForward = {tForward.x, tForward.y, tForward.z};
 
-		//Listener
-		alListenerfv(AL_POSITION, listenerPos);
-		alListenerfv(AL_VELOCITY, listenerVel);
-		alListenerfv(AL_ORIENTATION, listenerOri);
+		FMOD_System_Set3DListenerAttributes(m_System, lID, (const FMOD_VECTOR*)&lPos, (const FMOD_VECTOR*)&lVel, (const FMOD_VECTOR*)&lForward, (const FMOD_VECTOR*)&lUp);
 	}
 
-	auto soundEmitter = m_World->GetComponent<Components::SoundEmitter>(entity);
-	if(soundEmitter != nullptr)
+	auto emitter = m_World->GetComponent<Components::SoundEmitter>(entity);
+	if(emitter)
 	{
-		ALuint source = m_Sources[soundEmitter];
-		alSourcef(source, AL_GAIN, soundEmitter->Gain);
-		//alSourcef(source, AL_MAX_DISTANCE, soundEmitter->MaxDistance);
-		alSourcef(source, AL_REFERENCE_DISTANCE, soundEmitter->ReferenceDistance);
-		alSourcef(source, AL_PITCH, soundEmitter->Pitch);
-		alSourcei(source, AL_LOOPING, soundEmitter->Loop);
+		FMOD_CHANNEL* channel = m_Channels[entity];
+		FMOD_SOUND* sound = m_Sounds[entity];
+		auto eTransform = m_World->GetComponent<Components::Transform>(entity);
+		
+		glm::vec3 tPos = m_TransformSystem->AbsolutePosition(entity);
+		FMOD_VECTOR ePos = {tPos.x, tPos.y, tPos.z};
 
-		glm::vec3 emitterPos = transformComponent->Position;
-		ALfloat sourcePos[3] = { emitterPos.x, emitterPos.y, -emitterPos.z };
-
-		glm::vec3 emitterVel= transformComponent->Velocity;
-		ALfloat sourceVel[3] = { emitterVel.x, emitterVel.y, -emitterVel.z };
-
-		alSourcefv(source, AL_POSITION, sourcePos);
-		alSourcefv(source, AL_VELOCITY, sourceVel);
+		glm::vec3 tVel = (eTransform->Velocity * 1000.f) / float(dt);
+		FMOD_VECTOR eVel = {tVel.x, tVel.y, tVel.z};
+		
+		FMOD_Channel_Set3DAttributes(channel, &ePos, &eVel);
 	}
 }
 
-void Systems::SoundSystem::PlaySound(Components::SoundEmitter* emitter, std::string fileName)
+bool Systems::SoundSystem::OnComponentCreated(const Events::ComponentCreated &event)
 {
-	if (m_Sources.find(emitter) == m_Sources.end())
-		return;
-
-	ALuint buffer = *ResourceManager->Load<Sound>("Sound", fileName);
-	if (buffer == 0)
-		return;
-	ALuint source = m_Sources[emitter];
-	alSourcei(source, AL_BUFFER, buffer);
-	alSourcePlay(m_Sources[emitter]);
-}
-
-void Systems::SoundSystem::PlaySound(std::shared_ptr<Components::SoundEmitter> emitter)
-{
-	ALuint buffer = *ResourceManager->Load<Sound>("Sound", emitter->Path);
-	ALuint source = m_Sources[emitter.get()];
-	alSourcei(source, AL_BUFFER, buffer);
-	alSourcePlay(m_Sources[emitter.get()]);
-}
-
-void Systems::SoundSystem::StopSound(std::shared_ptr<Components::SoundEmitter> emitter)
-{
-	alSourceStop(m_Sources[emitter.get()]);
-}
-
-void Systems::SoundSystem::OnComponentCreated(std::string type, std::shared_ptr<Component> component)
-{
-	if(type == "SoundEmitter")
+	auto listener = std::dynamic_pointer_cast<Components::Listener>(event.Component);
+	if(listener)
 	{
-		ALuint source = CreateSource();
-		m_Sources[component.get()] = source;
+		m_Listeners.push_back(listener->Entity);
+	}
+
+	auto emitter = std::dynamic_pointer_cast<Components::SoundEmitter>(event.Component);
+	if(emitter)
+	{
+		FMOD_CHANNEL* channel;
+		FMOD_SOUND* sound;
+
+		std::string path = emitter->Path;
+		float volume = emitter->Gain;
+		bool loop = emitter->Loop;
+		float maxDist = emitter->MaxDistance;
+		float minDist = emitter->MinDistance;
+		float pitch = emitter->Pitch;
+		//LoadSound(sound, path, maxDist, minDist);
+		m_Channels.insert(std::make_pair(emitter->Entity, channel));
+		m_Sounds.insert(std::make_pair(emitter->Entity, sound));
+	}
+	return true;
+}
+
+bool Systems::SoundSystem::PlaySFX(const Events::PlaySFX &event)
+{
+	auto emitter = m_World->GetComponent<Components::SoundEmitter>(event.Emitter);
+	if(!emitter)
+	{
+		LOG_ERROR("FMOD: The Entity %i does not have a SoundEmitter-component, but is trying to play a sound", event.Emitter);FMOD_CHANNEL* channel = m_Channels[event.Emitter];
+		return false;
+	}
+	
+	emitter->type = Components::SoundEmitter::SoundType::SOUND_3D;
+	Sound* sound = ResourceManager->Load<Sound>("Sound3D", event.Resource);
+	m_Sounds[event.Emitter] = *sound;
+	FMOD_Sound_Set3DMinMaxDistance(*sound, emitter->MinDistance, emitter->MaxDistance);
+
+	PlaySound(&m_Channels[event.Emitter], m_Sounds[event.Emitter], 1.0, event.Loop);
+	FMOD_System_Update(m_System);
+
+	FMOD_BOOL isPlaying = false;
+	FMOD_Channel_IsPlaying(m_Channels[event.Emitter], &isPlaying);
+	if(!isPlaying)
+		LOG_ERROR("FMOD: File %s is not playing", event.Resource.c_str());
+	else
+		LOG_INFO("Now playing sound %s", event.Resource.c_str());
+	return true;
+}
+
+bool Systems::SoundSystem::PlayBGM(const Events::PlayBGM &event)
+{
+	auto emitter = m_World->CreateEntity();
+	auto eTransform = m_World->AddComponent<Components::Transform>(emitter);
+	auto eComponent = m_World->AddComponent<Components::SoundEmitter>(emitter);
+	m_Channels[emitter] = m_BGMChannel;
+	eComponent->type = Components::SoundEmitter::SoundType::SOUND_3D;
+	Sound* sound = ResourceManager->Load<Sound>("Sound2D", event.Resource);
+	m_Sounds[emitter] = *sound;
+
+	FMOD_System_PlaySound(m_System, FMOD_CHANNEL_FREE, *sound, false, &m_Channels[emitter]);
+	return true;
+}
+
+bool Systems::SoundSystem::StopSound(const Events::StopSound &event)
+{
+	FMOD_Channel_Stop(m_Channels[event.Emitter]);
+	return true;
+}
+
+void Systems::SoundSystem::LoadSound(FMOD_SOUND* &sound, std::string filePath, float maxDist, float minDist)
+{
+	FMOD_RESULT result = FMOD_System_CreateSound(m_System, filePath.c_str(), FMOD_3D | FMOD_HARDWARE , 0, &sound);
+	if (result != FMOD_OK)
+	{
+		LOG_ERROR("FMOD did not load file: %s", filePath.c_str());
+	}
+	FMOD_Sound_Set3DMinMaxDistance(sound, minDist, maxDist);
+}
+
+void Systems::SoundSystem::PlaySound(FMOD_CHANNEL** channel, FMOD_SOUND* sound, float volume, bool loop)
+{
+	FMOD_System_PlaySound(m_System, FMOD_CHANNEL_FREE, sound, false, channel);
+	FMOD_Channel_SetVolume(*channel, volume);
+	if(loop)
+	{
+		FMOD_Channel_SetMode(*channel, FMOD_LOOP_NORMAL);
+		FMOD_Sound_SetLoopCount(sound, -1);
 	}
 }
 
 void Systems::SoundSystem::OnComponentRemoved(EntityID entity, std::string type, Component* component)
 {
-	if(type == "SoundEmitter")
+	auto emitter = dynamic_cast<Components::SoundEmitter*>(component);
+	if(emitter)
 	{
-		if (m_Sources.find(component) != m_Sources.end())
-		{
-			ALuint source = m_Sources[component];
-			alDeleteSources(1, &source);
-		}
+		m_DeleteChannels.insert(std::make_pair(entity, m_Channels[entity]));
+		m_DeleteSounds.insert(std::make_pair(entity, m_Sounds[entity]));
+		m_Channels.erase(entity);
+		m_Sounds.erase(entity);
 	}
-}
-
-ALuint Systems::SoundSystem::CreateSource()
-{
-	ALuint source;
-	alGenSources((ALuint)1, &source);
-
-	alDopplerFactor(1); // Numbers greater than 1 will increase Doppler effect, numbers lower than 1 will decrease the Doppler effect
-	alDopplerVelocity(350.f); // Defines the velocity of the sound
-
-	return source;
-}
-
-bool Systems::SoundSystem::OnPlaySound(const Events::PlaySound &event)
-{
-	LOG_DEBUG("Events::PlaySound.Resource = %s", event.Resource.c_str());
-
-	ALuint buffer = *ResourceManager->Load<Sound>("Sound", event.Resource);
-	ALuint source = m_Sources.begin()->second;
-	alSourcei(source, AL_BUFFER, buffer);
-	alSourcePlay(source);
-
-	return true;
-}
+}

src/Systems/SoundSystem.h

@@ -1,13 +1,18 @@
 #ifndef SoundEmitter_h__
 #define SoundEmitter_h__
-#include <AL/al.h>
-#include <AL/alc.h>
+#include <fmod.hpp>
+#include <fmod_errors.h>
 #include <vector>
 
 #include "System.h"
+#include "Systems/TransformSystem.h"
 #include "Components/Transform.h"
 #include "Components/SoundEmitter.h"
-#include "Events/PlaySound.h"
+#include "Components/Listener.h"
+#include "Events/ComponentCreated.h"
+#include "Events/PlaySFX.h"
+#include "Events/PlayBGM.h"
+#include "Events/StopSound.h"
 #include "Sound.h"
 
 namespace Systems
@@ -23,33 +28,34 @@ public:
 	void RegisterComponents(ComponentFactory* cf) override;
 	void RegisterResourceTypes(std::shared_ptr<::ResourceManager> rm) override;
 	void Initialize() 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(std::string type, Component* component);
 	void OnComponentRemoved(EntityID entity, std::string type, Component* component) override;
-	void PlaySound(Components::SoundEmitter* emitter, std::string path); // Use if you want to play a temporary .wav file not from component
-	void PlaySound(std::shared_ptr<Components::SoundEmitter> emitter); // Use if you want to play .wav file from component // imon no hate plx T.T
-	void StopSound(std::shared_ptr<Components::SoundEmitter> emitter);
-
+	FMOD_SYSTEM* GetFMODSystem() const { return m_System; }
 private:
-	ALuint LoadFile(std::string fileName);
-	ALuint CreateSource();
-
-	//File-info
-	//char type[4];
-	//unsigned long size, chunkSize;
-	//short formatType, channels;
-	//unsigned long sampleRate, avgBytesPerSec;
-	//short bytesPerSample, bitsPerSample;
-	//unsigned long dataSize;
-
 	// Events
-	EventRelay<SoundSystem, Events::PlaySound> m_EPlaySound;
-	bool OnPlaySound(const Events::PlaySound &event);
+	EventRelay<SoundSystem, Events::ComponentCreated> m_EComponentCreated;
+	bool OnComponentCreated(const Events::ComponentCreated &event);
+	EventRelay<SoundSystem, Events::PlaySFX> m_EPlaySFX;
+	bool PlaySFX(const Events::PlaySFX &event);
+	EventRelay<SoundSystem, Events::PlayBGM> m_EPlayBGM;
+	bool PlayBGM(const Events::PlayBGM &event);
+	EventRelay<SoundSystem, Events::StopSound> m_EStopSound;
+	bool StopSound(const Events::StopSound &event);
 
-	std::map<Component*, ALuint> m_Sources;
-	std::map<std::string, ALuint> m_BufferCache; // string = fileName
+	void LoadSound(FMOD_SOUND*&, std::string, float, float);
+	void PlaySound(FMOD_CHANNEL**, FMOD_SOUND*, float volume, bool loop);
+	
+	FMOD_SYSTEM* m_System;
+	FMOD_CHANNEL* m_BGMChannel;
+	std::vector<EntityID> m_Listeners;
+	std::map<EntityID, FMOD_CHANNEL*> m_Channels;
+	std::map<EntityID, FMOD_CHANNEL*> m_DeleteChannels;
+	std::map<EntityID, FMOD_SOUND*> m_Sounds;	
+	std::map<EntityID, FMOD_SOUND*> m_DeleteSounds;	
+	std::shared_ptr<Systems::TransformSystem> m_TransformSystem;
+	
 };
 
 }

src/Systems/TankSteeringSystem.cpp

@@ -2,7 +2,7 @@
 #include "TankSteeringSystem.h"
 #include "World.h"
 
-void Systems::TankSteeringSystem::RegisterComponents( ComponentFactory* cf )
+void Systems::TankSteeringSystem::RegisterComponents(ComponentFactory* cf)
 {
 	cf->Register<Components::TankSteering>([]() { return new Components::TankSteering(); });
 	cf->Register<Components::TowerSteering>([]() { return new Components::TowerSteering(); });
@@ -12,6 +12,7 @@ void Systems::TankSteeringSystem::RegisterComponents( ComponentFactory* cf )
 void Systems::TankSteeringSystem::Initialize()
 {
 	EVENT_SUBSCRIBE_MEMBER(m_ECollision, &Systems::TankSteeringSystem::OnCollision);
+	EVENT_SUBSCRIBE_MEMBER(m_ESpawnVehicle, &Systems::TankSteeringSystem::OnSpawnVehicle);
 
 	for (int i = 0; i < 4; i++)
 	{
@@ -68,6 +69,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);
@@ -96,7 +111,7 @@ void Systems::TankSteeringSystem::UpdateEntity(double dt, EntityID entity, Entit
 	}
 }
 
-bool Systems::TankSteeringSystem::OnCollision( const Events::Collision &e )
+bool Systems::TankSteeringSystem::OnCollision(const Events::Collision &e)
 {
 	if(m_World->ValidEntity(e.Entity1) && m_World->ValidEntity(e.Entity2))
 	{
@@ -272,6 +287,313 @@ bool Systems::TankSteeringSystem::OnCollision( const Events::Collision &e )
 	return true;
 }
 
+bool Systems::TankSteeringSystem::OnSpawnVehicle(const Events::SpawnVehicle &event)
+{
+	if (event.VehicleType != "Tank")
+		return false;
+
+	auto spawnPointComponents = m_World->GetComponentsOfType<Components::SpawnPoint>();
+	for (auto &spawnPointComponent : *spawnPointComponents)
+	{
+		auto spawnPoint = spawnPointComponent->Entity;
+		auto spawnPointBaseParent = m_World->GetEntityBaseParent(spawnPoint);
+		auto playerComponent = m_World->GetComponent<Components::Player>(spawnPointBaseParent);
+		if (!playerComponent || playerComponent->ID != event.PlayerID)
+			continue;
+		
+		Components::Transform absoluteTransform = m_World->GetSystem<Systems::TransformSystem>()->AbsoluteTransform(spawnPoint);
+
+		// Create a tank
+		EntityID tank = CreateTank(event.PlayerID);
+		auto tankTransform = m_World->GetComponent<Components::Transform>(tank);
+		tankTransform->Position = absoluteTransform.Position;
+		tankTransform->Orientation = absoluteTransform.Orientation;
+		// Set the viewport correctly
+		Events::SetViewportCamera e;
+		e.CameraEntity = m_World->GetProperty<EntityID>(tank, "Camera");
+		if (event.PlayerID == 1)
+			e.ViewportFrame = "Viewport1";
+		else if (event.PlayerID == 2)
+			e.ViewportFrame = "Viewport2";
+		EventBroker->Publish(e);
+	}
+
+	return true;
+}
+
+EntityID Systems::TankSteeringSystem::CreateTank(int playerID)
+{
+	auto tank = m_World->CreateEntity();
+	auto transform = m_World->AddComponent<Components::Transform>(tank);
+	transform->Position = glm::vec3(0, 5, 0);
+	//transform->Orientation = glm::angleAxis(0.f, glm::vec3(0, 1, 0));
+	auto physics = m_World->AddComponent<Components::Physics>(tank);
+	physics->Mass = 63000 - 16000;
+	physics->Static = false;
+	auto vehicle = m_World->AddComponent<Components::Vehicle>(tank);
+	vehicle->MaxTorque = 8000.f;
+	vehicle->MaxSteeringAngle = 90.f;
+	vehicle->MaxSpeedFullSteeringAngle = 4.f;
+	auto player = m_World->AddComponent<Components::Player>(tank);
+	player->ID = playerID;
+	auto tankSteering = m_World->AddComponent<Components::TankSteering>(tank);
+	m_World->AddComponent<Components::Input>(tank);
+	auto health = m_World->AddComponent<Components::Health>(tank);
+	health->Amount = 100.f;
+
+	{
+		auto shape = m_World->CreateEntity(tank);
+		auto transform = m_World->AddComponent<Components::Transform>(shape);
+		auto meshShape = m_World->AddComponent<Components::MeshShape>(shape);
+		meshShape->ResourceName = "Models/Tank/TankCollisionShape.obj";
+		m_World->CommitEntity(shape);
+	}
+	{
+		auto shapeTower = m_World->CreateEntity(tank);
+		auto transform = m_World->AddComponent<Components::Transform>(shapeTower);
+		transform->Position = glm::vec3(0, 1.10633f, 1.03024f);
+		auto box = m_World->AddComponent<Components::BoxShape>(shapeTower);
+		box->Width = 1.298f;
+		box->Height = 0.502f;
+		box->Depth = 1.211f;
+		m_World->CommitEntity(shapeTower);
+	}
+
+	{
+		auto chassis = m_World->CreateEntity(tank);
+		auto transform = m_World->AddComponent<Components::Transform>(chassis);
+		transform->Position = glm::vec3(0, 0, 0);
+		auto model = m_World->AddComponent<Components::Model>(chassis);
+		model->ModelFile = "Models/Tank/tankBody.obj";
+	}
+	{
+		auto tower = m_World->CreateEntity(tank);
+		m_World->SetProperty(tower, "Name", "tower");
+		auto transform = m_World->AddComponent<Components::Transform>(tower);
+		transform->Position = glm::vec3(0.f, 0.68f, 0.9f);
+		auto model = m_World->AddComponent<Components::Model>(tower);
+		model->ModelFile = "Models/Tank/tankTop.obj";
+		auto towerSteering = m_World->AddComponent<Components::TowerSteering>(tower);
+		towerSteering->Axis = glm::vec3(0.f, 1.f, 0.f);
+		towerSteering->TurnSpeed = glm::pi<float>() / 4.f;
+		{
+			auto barrel = m_World->CreateEntity(tower);
+			auto transform = m_World->AddComponent<Components::Transform>(barrel);
+			transform->Position = glm::vec3(-0.012f, 0.3f, -0.95);
+			auto model = m_World->AddComponent<Components::Model>(barrel);
+			model->ModelFile = "Models/Tank/tankBarrel.obj";
+			auto barrelSteering = m_World->AddComponent<Components::BarrelSteering>(barrel);
+			barrelSteering->Axis = glm::vec3(1.f, 0.f, 0.f);
+			barrelSteering->TurnSpeed = glm::pi<float>() / 4.f;
+			barrelSteering->ShotSpeed = 70.f;
+			barrelSteering->LowerRotationLimit = glm::radians(-10.f);
+			barrelSteering->UpperRotationLimit = glm::radians(40.f);
+			{
+				auto shot = m_World->CreateEntity(barrel);
+				auto transform = m_World->AddComponent<Components::Transform>(shot);
+				transform->Position = glm::vec3(0.35f, 0.f, -2.f);
+				transform->Orientation = glm::angleAxis(-glm::pi<float>() / 2.f, glm::vec3(1, 0, 0));
+				transform->Scale = glm::vec3(3.f);
+				m_World->AddComponent<Components::Template>(shot);
+				auto physics = m_World->AddComponent<Components::Physics>(shot);
+				physics->Mass = 25.f;
+				physics->Static = false;
+				physics->CollisionEvent = true;
+				auto modelComponent = m_World->AddComponent<Components::Model>(shot);
+				modelComponent->ModelFile = "Models/Placeholders/rocket/Rocket.obj";
+				auto tankShellComponent = m_World->AddComponent<Components::TankShell>(shot);
+				tankShellComponent->Damage = 20.f;
+				tankShellComponent->ExplosionRadius = 30.f;
+				tankShellComponent->ExplosionStrength = 300000.f;
+				{
+					auto shape = m_World->CreateEntity(shot);
+					auto transform = m_World->AddComponent<Components::Transform>(shape);
+					auto boxShape = m_World->AddComponent<Components::BoxShape>(shape);
+					boxShape->Width = 0.5f;
+					boxShape->Height = 0.5f;
+					boxShape->Depth = 0.5f;
+					m_World->CommitEntity(shape);
+				}
+				m_World->CommitEntity(shot);
+				barrelSteering->ShotTemplate = shot;
+
+
+				auto cameraTower = m_World->CreateEntity(barrel);
+				{
+					auto transform = m_World->AddComponent<Components::Transform>(cameraTower);
+					transform->Position.z = 16.f;
+					transform->Position.y = 4.f;
+					transform->Orientation = glm::quat(glm::vec3(-glm::radians(5.f), 0.f, 0.f));
+					auto cameraComp = m_World->AddComponent<Components::Camera>(cameraTower);
+					cameraComp->FarClip = 2000.f;
+					/*auto follow = m_World->AddComponent<Components::Follow>(cameraTower);
+					follow->Entity = barrel;
+					follow->Distance = 15.f;
+					follow->FollowAxis = glm::vec3(1, 1, 1);*/
+				}
+
+				m_World->SetProperty(tank, "Camera", cameraTower);
+			}
+			m_World->CommitEntity(barrel);
+			tankSteering->Barrel = barrel;
+		}
+		m_World->CommitEntity(tower);
+		tankSteering->Turret = tower;
+
+
+
+	}
+
+
+
+	//{
+	//	auto lightentity = m_World->CreateEntity(tank);
+	//	auto transform = m_World->AddComponent<Components::Transform>(lightentity);
+	//	transform->Position = glm::vec3(0, 0, 0);
+	//	auto light = m_World->AddComponent<Components::PointLight>(lightentity);
+	//	//light->Diffuse = glm::vec3(128.f/255.f, 172.f/255.f, 242.f/255.f);
+	//	//light->Specular = glm::vec3(1.f);
+	//	/*light->ConstantAttenuation = 0.3f;
+	//	light->LinearAttenuation = 0.003f;
+	//	light->QuadraticAttenuation = 0.002f;*/
+	//}
+
+	// 		auto wheelpair = m_World->CreateEntity(tank);
+	// 		SetProperty(wheelpair, "Name", "WheelPair");
+	// 		AddComponent(wheelpair, "WheelPairThingy");
+
+#pragma region Wheels
+	//Create wheels
+	float wheelOffset = -0.83f;
+	const float suspensionStrength = 15.f;
+	const float springLength = 0.3f;
+
+	AddTankWheelPair(tank, glm::vec3(1.68f, wheelOffset, -1.715f), 0, true);
+	AddTankWheelPair(tank, glm::vec3(-1.68f, wheelOffset, -1.715f), 0, true);
+	AddTankWheelPair(tank, glm::vec3(1.68f, wheelOffset, 2.375), 1, false);
+	AddTankWheelPair(tank, glm::vec3(-1.68f, wheelOffset, 2.375), 1, false);
+#pragma endregion
+
+	{
+		auto entity = m_World->CreateEntity(tank);
+		auto transformComponent = m_World->AddComponent<Components::Transform>(entity);
+		transformComponent->Position = glm::vec3(-2, -1.7, 2.0);
+		transformComponent->Scale = glm::vec3(3, 3, 3);
+		transformComponent->Orientation = glm::angleAxis(glm::pi<float>() / 2, glm::vec3(1, 0, 0));
+		auto emitterComponent = m_World->AddComponent<Components::ParticleEmitter>(entity);
+		emitterComponent->SpawnCount = 2;
+		emitterComponent->SpawnFrequency = 0.005;
+		emitterComponent->SpreadAngle = glm::pi<float>();
+		emitterComponent->UseGoalVelocity = false;
+		emitterComponent->LifeTime = 0.5;
+		//emitterComponent->AngularVelocitySpectrum.push_back(glm::pi<float>() / 100);
+		emitterComponent->ScaleSpectrum.push_back(glm::vec3(0.05));
+		m_World->CommitEntity(entity);
+
+		auto particleEntity = m_World->CreateEntity(entity);
+		auto TEMP = m_World->AddComponent<Components::Transform>(particleEntity);
+		TEMP->Scale = glm::vec3(0);
+		auto spriteComponent = m_World->AddComponent<Components::Sprite>(particleEntity);
+		spriteComponent->SpriteFile = "Models/Textures/Sprites/Dust.png";
+		emitterComponent->ParticleTemplate = particleEntity;
+
+		m_World->CommitEntity(particleEntity);
+	}
+
+	m_World->CommitEntity(tank);
+
+	return tank;
+}
+
+void Systems::TankSteeringSystem::AddTankWheelPair(EntityID tankEntity, glm::vec3 position, int axleID, bool front)
+{
+	const float separation = 1.77f;
+	const float suspensionStrength = 15.f;
+	const float springLength = 0.3f;
+
+	bool steering = front;
+
+	auto wheelFront = m_World->CreateEntity(tankEntity);
+	{
+		auto transform = m_World->AddComponent<Components::Transform>(wheelFront);
+		transform->Position = position - glm::vec3(0, 0, separation / 2.f);  // glm::vec3(1.68f, -0.83f - wheelOffset, -0.83f);
+		//transform->Orientation = glm::angleAxis(glm::pi<float>(), glm::vec3(0, 1, 0));
+#ifdef DEBUG
+		auto model = m_World->AddComponent<Components::Model>(wheelFront);
+		model->ModelFile = "Models/Tank/Fix/WheelPhysics.obj";
+#endif
+		auto Wheel = m_World->AddComponent<Components::Wheel>(wheelFront);
+		Wheel->Hardpoint = transform->Position + glm::vec3(0.f, springLength, 0.f);
+		Wheel->AxleID = axleID;
+		Wheel->Mass = 2000;
+		Wheel->Radius = 0.6f;
+		Wheel->Steering = steering;
+		Wheel->SuspensionStrength = suspensionStrength;
+		Wheel->Friction = 4.f;
+		Wheel->ConnectedToHandbrake = true;
+		Wheel->TorqueRatio = 0.125f;
+		Wheel->Width = 0.6f;
+		m_World->CommitEntity(wheelFront);
+	}
+
+	auto wheelBack = m_World->CreateEntity(tankEntity);
+	{
+		auto transform = m_World->AddComponent<Components::Transform>(wheelBack);
+		transform->Position = position + glm::vec3(0, 0, separation / 2.f); // glm::vec3(1.68f, -0.83f - wheelOffset, -2.6f);
+		//transform->Orientation = glm::angleAxis(glm::pi<float>(), glm::vec3(0, 1, 0));
+#ifdef DEBUG
+		auto model = m_World->AddComponent<Components::Model>(wheelBack);
+		model->ModelFile = "Models/Tank/Fix/WheelPhysics.obj";
+#endif
+		auto Wheel = m_World->AddComponent<Components::Wheel>(wheelBack);
+		Wheel->Hardpoint = transform->Position + glm::vec3(0.f, springLength, 0.f);
+		Wheel->AxleID = axleID;
+		Wheel->Mass = 2000;
+		Wheel->Radius = 0.6f;
+		Wheel->Steering = steering;
+		Wheel->SuspensionStrength = suspensionStrength;
+		Wheel->Friction = 4.f;
+		Wheel->ConnectedToHandbrake = true;
+		Wheel->TorqueRatio = 0.125f;
+		Wheel->Width = 0.6f;
+		m_World->CommitEntity(wheelBack);
+	}
+
+	auto wheelPair = m_World->CreateEntity(tankEntity);
+	{
+		{
+			auto transform = m_World->AddComponent<Components::Transform>(wheelPair);
+			transform->Position = position;
+			//transform->Orientation = glm::quat(glm::vec3(0, glm::pi<float>() / 4.f, 0));
+
+			auto pair = m_World->AddComponent<Components::WheelPair>(wheelPair);
+			pair->FakeWheelFront = wheelFront;
+			pair->FakeWheelBack = wheelBack;
+		}
+
+		auto modelEntity = m_World->CreateEntity(wheelPair);
+		{
+			auto transform = m_World->AddComponent<Components::Transform>(modelEntity);
+			//transform->Position = glm::vec3(0.f, 0.35f, 0.f);
+			if (front)
+			{
+				transform->Position = glm::vec3(0.f, 0.03f, 0.f);
+				transform->Orientation = glm::quat(glm::vec3(0, glm::pi<float>(), 0));
+			}
+			else
+			{
+				transform->Position = glm::vec3(0.f, 0.17f, 0.f);
+				transform->Scale = glm::vec3(1.f, 1.2f, 1.2f);
+			}
+
+			auto model = m_World->AddComponent<Components::Model>(modelEntity);
+			model->ModelFile = "Models/Tank/tankWheel.obj";
+		}
+		m_World->CommitEntity(modelEntity);
+	}
+	m_World->CommitEntity(wheelPair);
+}
+
 void Systems::TankSteeringSystem::TankSteeringInputController::Update( double dt )
 {
 	PositionX = m_Horizontal;
@@ -336,5 +658,3 @@ bool Systems::TankSteeringSystem::TankSteeringInputController::OnCommand(const E
 	return true;
 }
 
-
-

src/Systems/TankSteeringSystem.h

@@ -33,6 +33,18 @@
 #include "Components/Vehicle.h"
 #include "Components/Player.h"
 
+#include "Events/SpawnVehicle.h"
+#include "Components/SpawnPoint.h"
+
+#include "Components/Wheel.h"
+#include "Components/MeshShape.h"
+#include "Components/Camera.h"
+#include "Components/BoxShape.h"
+#include "Components/WheelPair.h"
+#include "Components/Input.h"
+
+#include "Events/SetViewportCamera.h"
+
 namespace Systems
 {
 
@@ -50,13 +62,18 @@ namespace Systems
 		void UpdateEntity(double dt, EntityID entity, EntityID parent) override;
 
 	private:
+		std::map<EntityID, double> m_TimeSinceLastShot;
+
 		EventRelay<TankSteeringSystem, Events::Collision> m_ECollision;
 		bool OnCollision(const Events::Collision &e);
+		EventRelay<TankSteeringSystem, Events::SpawnVehicle> m_ESpawnVehicle;
+		bool OnSpawnVehicle(const Events::SpawnVehicle &e);
 
 		class TankSteeringInputController;
 		std::array<std::shared_ptr<TankSteeringInputController>, 4> m_TankInputControllers;
 
-		std::map<EntityID, double> m_TimeSinceLastShot;
+		EntityID CreateTank(int playerID);
+		void AddTankWheelPair(EntityID tankEntity, glm::vec3 position, int axleID, bool front);
 	};
 
 	class TankSteeringSystem::TankSteeringInputController : InputController<TankSteeringSystem>

src/Systems/TransformSystem.cpp

@@ -13,6 +13,118 @@
 //	transform->Position = parentTransform->Position + transform->RelativePosition;
 //}
 
+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 )
+{
+	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;
+
+			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;
+		}
+		
+	}
+
+	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.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 Systems::TransformSystem::AbsolutePosition(EntityID entity)
 {
 	glm::vec3 absPosition;
@@ -91,3 +203,6 @@ Components::Transform Systems::TransformSystem::AbsoluteTransform(EntityID entit
 
 	return transform;
 }
+
+
+

src/Systems/TransformSystem.h

@@ -3,6 +3,10 @@
 
 #include "System.h"
 #include "Components/Transform.h"
+#include "Events/Move.h"
+#include "Events/Rotate.h"
+#include <unordered_map>
+
 
 namespace Systems
 {
@@ -14,12 +18,37 @@ 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);
+	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/Systems/TriggerSystem.cpp

@@ -6,11 +6,14 @@ 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(); });
+	cf->Register<Components::TriggerRotate>([]() { return new Components::TriggerRotate(); });
 }
 
 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 )
@@ -23,10 +26,6 @@ void Systems::TriggerSystem::UpdateEntity( double dt, EntityID entity, EntityID
 
 }
 
-void Systems::TriggerSystem::OnComponentCreated( std::string type, std::shared_ptr<Component> component )
-{
-
-}
 
 void Systems::TriggerSystem::OnComponentRemoved(EntityID entity, std::string type, Component* component )
 {
@@ -45,34 +44,92 @@ void Systems::TriggerSystem::OnEntityRemoved( EntityID entity )
 
 bool Systems::TriggerSystem::OnEnterTrigger( const Events::EnterTrigger &event )
 {
-	/*auto explosionComponent1 = m_World->GetComponent<Components::TriggerExplosion>(event.Entity1);
-	auto explosionComponent2 = m_World->GetComponent<Components::TriggerExplosion>(event.Entity2);
-
-	if(explosionComponent1)
-	{
-		Explosion(event.Entity2, event.Entity1);
-	}
-	else if (explosionComponent2)
-	{
-		Explosion(event.Entity1, event.Entity2);
-	}*/
-
-	auto flagComponent1 = m_World->GetComponent<Components::Flag>(event.Entity1);
-	auto flagComponent2 = m_World->GetComponent<Components::Flag>(event.Entity2);
+	
 
+	auto flagComponent1 = m_World->GetComponent<Components::Flag>(event.Trigger);
+	auto flagComponent2 = m_World->GetComponent<Components::Flag>(event.Entity);
+	 //HACK: SIMON IS DISSING AMERICA
 	if(flagComponent1)
 	{
-		Flag(event.Entity2, event.Entity1);
+		Flag(event.Entity, event.Trigger);
 	}
 	else if (flagComponent2)
 	{
-		Flag(event.Entity1, event.Entity2);
+		Flag(event.Trigger, event.Entity);
+	}
+
+
+	auto triggerMoveComponent = m_World->GetComponent<Components::TriggerMove>(event.Trigger);
+	if (triggerMoveComponent)
+	{
+		Move(triggerMoveComponent->Entity, triggerMoveComponent->Queue, triggerMoveComponent->Swap);
+	}
+
+	auto triggerRotateComponent = m_World->GetComponent<Components::TriggerRotate>(event.Trigger);
+	if (triggerRotateComponent)
+	{
+		Rotate(triggerMoveComponent->Entity, triggerMoveComponent->Queue, triggerMoveComponent->Swap);
 	}
 
 	return true;
 }
 
 
+bool Systems::TriggerSystem::OnLeaveTrigger( const Events::LeaveTrigger &event )
+{
+	auto triggerMoveComponent = m_World->GetComponent<Components::TriggerMove>(event.Trigger);
+	if (triggerMoveComponent)
+	{
+		Move(triggerMoveComponent->Entity, triggerMoveComponent->Queue, triggerMoveComponent->Swap);
+	}
+
+	auto triggerRotateComponent = m_World->GetComponent<Components::TriggerRotate>(event.Trigger);
+	if (triggerRotateComponent)
+	{
+		Rotate(triggerMoveComponent->Entity, triggerMoveComponent->Queue, triggerMoveComponent->Swap);
+	}
+
+	return true;
+}
+
+
+void Systems::TriggerSystem::Rotate(EntityID entity, bool queue, bool swap)
+{
+	auto transform = m_World->GetComponent<Components::Transform>(entity);
+	auto rotate = m_World->GetComponent<Components::Rotate>(entity);
+
+	Events::Rotate e;
+	e.Entity = entity;
+	e.GoalRotation = rotate->GoalRotation;
+	e.Time = rotate->Time;
+	e.Queue = queue;
+	EventBroker->Publish(e);
+
+	if (swap)
+	{
+		std::swap(rotate->GoalRotation, rotate->StartRotation);
+	}
+}
+
+
+
+void Systems::TriggerSystem::Move(EntityID entity, bool queue, bool swap)
+{
+	auto move = m_World->GetComponent<Components::Move>(entity);
+	Events::Move e;
+	e.Entity = entity;
+	e.GoalPosition = move->GoalPosition;
+	e.Speed = move->Speed;
+	e.Queue = queue;
+	EventBroker->Publish(e);
+
+	if (swap)
+	{
+		std::swap(move->GoalPosition, move->StartPosition);
+	}
+}
+
+
 void Systems::TriggerSystem::Flag( EntityID entity, EntityID phantomEntity )
 {
 	auto tankSteering = m_World->GetComponent<Components::TankSteering>(entity);

src/Systems/TriggerSystem.h

@@ -14,7 +14,15 @@
 #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/TriggerRotate.h"
+#include "Components/Move.h"
+#include "Components/Rotate.h"
+#include "Components/Player.h"
+#include "Events/Move.h"
+#include "Events/Rotate.h"
 #include <math.h>
 namespace Systems
 {
@@ -29,17 +37,20 @@ namespace Systems
 		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 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;
 
 		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, bool queue, bool swap);
+		void Rotate(EntityID entity, bool queue, bool swap);
 	};
 
 }