Merge remote-tracking branch 'origin/master' into deffered_rendering

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

src/Components/DamageModel.h

@@ -0,0 +1,27 @@
+#ifndef Components_DamageModel_h__
+#define Components_DamageModel_h__
+
+#include <string>
+
+#include "Component.h"
+
+namespace Components
+{
+
+	struct DamageModel : Component
+	{
+		DamageModel() 
+			: Color(glm::vec4(1.0f, 1.0f, 1.0f, 1.0f))
+			, ShadowCaster(true)
+			, Transparent(false)
+		{ }
+		std::string ModelFile;
+		glm::vec4 Color;
+		bool ShadowCaster;
+		bool Transparent;
+
+		virtual DamageModel* Clone() const override { return new DamageModel(*this); }
+	};
+
+}
+#endif // !Components_DamageModel_h__

src/Components/Health.h

@@ -9,9 +9,12 @@ namespace Components
 	struct Health : Component
 	{
 		Health()
-			: Amount(1.0f) { }
+			: Amount(1.0f) 
+			, VulnerableToSplash(true)
+		{ }
 
 		float Amount;
+		bool VulnerableToSplash;
 
 		virtual Health* Clone() const override { return new Health(*this); }
 	};

src/Components/JeepSteering.h

@@ -0,0 +1,14 @@
+#ifndef JeepSteering_h__
+#define JeepSteering_h__
+
+#include "Component.h"
+
+namespace Components
+{
+	struct JeepSteering : Component
+	{
+		JeepSteering* Clone() const override { return new JeepSteering(*this); }
+	};
+}
+
+#endif // JeepSteering_h__

src/Components/SpawnPoint.h

@@ -8,8 +8,6 @@ namespace Components
 
 struct SpawnPoint : Component
 {
-	EntityID Player;
-
 	virtual SpawnPoint* Clone() const override { return new SpawnPoint(*this); }
 };
 

src/Components/Team.h

@@ -0,0 +1,18 @@
+#ifndef Components_Team_h__
+#define Components_Team_h__
+
+#include "Component.h"
+#include "Entity.h"
+
+namespace Components
+{
+
+	struct Team : Component
+	{
+		unsigned int TeamID;
+
+		virtual Team* Clone() const override { return new Team(*this); }
+	};
+
+}
+#endif // !Components_Team_h__

src/Components/Trigger.h

@@ -9,6 +9,7 @@ namespace Components
 	struct Trigger : Component
 	{
 		bool TriggerOnce;
+		int TeamID;
 		virtual Trigger* Clone() const override { return new Trigger(*this); }
 	};
 

src/Components/Vehicle.h

@@ -10,8 +10,8 @@ namespace Components
 struct Vehicle : Component
 {
 	Vehicle()
-		: MaxTorque(1000.0f), MinRPM(200.0f), OptimalRPM(3000.0f), MaxRPM(6000.0f), MaxSteeringAngle(35), TopSpeed(90.0f),
+		: MaxTorque(1000.0f), MinRPM(200.0f), OptimalRPM(2500.0f), MaxRPM(4000.0f), MaxSteeringAngle(35), TopSpeed(90.0f),
-	MaxSpeedFullSteeringAngle(40.0f), SpringDamping(1.f), UpshiftRPM(5500.0f), DownshiftRPM(1000.0f),
+	MaxSpeedFullSteeringAngle(40.0f), SpringDamping(1.f), UpshiftRPM(3500.0f), DownshiftRPM(1000.0f),
 	gearsRatio0(3.0f), gearsRatio1(2.25f), gearsRatio2(1.5f), gearsRatio3(1.0f){ }
 	float MaxTorque;
 	float MinRPM;

src/Events/FlagCaptured.h

@@ -0,0 +1,15 @@
+#ifndef Events_FlagCaptured_h__
+#define Events_FlagCaptured_h__
+
+#include "Entity.h"
+#include "EventBroker.h"
+
+namespace Events
+{
+	struct FlagCaptured : Event
+	{
+		EntityID Player;
+	};
+}
+
+#endif // Events_FlagCaptured_h__

src/Events/FlagDropped.h

@@ -0,0 +1,15 @@
+#ifndef Events_FlagDropped_h__
+#define Events_FlagDropped_h__
+
+#include "Entity.h"
+#include "EventBroker.h"
+
+namespace Events
+{
+	struct FlagDropped : Event
+	{
+		EntityID Player;
+	};
+}
+
+#endif // Events_FlagDropped_h__

src/Events/FlagPickup.h

@@ -0,0 +1,15 @@
+#ifndef Events_FlagPickup_h__
+#define Events_FlagPickup_h__
+
+#include "Entity.h"
+#include "EventBroker.h"
+
+namespace Events
+{
+	struct FlagPickup : Event
+	{
+		EntityID Player;
+	};
+}
+
+#endif // Events_FlagPickup_h__

src/Events/FlagReturned.h

@@ -0,0 +1,15 @@
+#ifndef Events_FlagReturned_h__
+#define Events_FlagReturned_h__
+
+#include "Entity.h"
+#include "EventBroker.h"
+
+namespace Events
+{
+	struct FlagReturned : Event
+	{
+		EntityID Player;
+	};
+}
+
+#endif // Events_FlagReturned_h__

src/Events/GameOver.h

@@ -0,0 +1,15 @@
+#ifndef Events_GameOver_h__
+#define Events_GameOver_h__
+
+#include "Entity.h"
+#include "EventBroker.h"
+
+namespace Events
+{
+	struct GameOver : Event
+	{
+		EntityID Winner;
+	};
+}
+
+#endif // Events_GameOver_h__

src/Events/GameStart.h

@@ -0,0 +1,15 @@
+#ifndef Events_GameStart_h__
+#define Events_GameStart_h__
+
+#include "Entity.h"
+#include "EventBroker.h"
+
+namespace Events
+{
+	struct GameStart : Event
+	{
+		
+	};
+}
+
+#endif // Events_GameStart_h__

src/Events/JeepSteer.h

@@ -0,0 +1,19 @@
+#ifndef Events_JeepSteer_h__
+#define Events_JeepSteer_h__
+#include "Entity.h"
+#include "EventBroker.h"
+
+namespace Events
+{
+
+	struct JeepSteer : Event
+	{
+		EntityID Entity;
+		float PositionX;
+		float PositionY;
+		bool Handbrake;
+	};
+
+}
+
+#endif // Events_JeepSteer_h__

src/GUI/Frame.h

@@ -36,6 +36,7 @@ public:
 		: EventBroker(eventBroker)
 		, ResourceManager(resourceManager)
 		, Rectangle()
+		, m_Parent(nullptr)
 		, m_Name("UIParent")
 		, m_Layer(0)
 		, m_Hidden(false)
@@ -46,12 +47,28 @@ public:
 		: m_Name(name)
 		, m_Layer(0)
 		, m_Hidden(false)
-	{ SetParent(std::shared_ptr<Frame>(parent)); Initialize(); }
+	{ SetParent(parent); Initialize(); }
+
+	~Frame()
+	{
+		/*for (auto layer : m_Children)
+		{
+			for (auto child : layer.second)
+			{
+				delete child.second;
+			}
+		}
+
+		if (m_Parent)
+		{
+			m_Parent->RemoveChild(this);
+		}*/
+	}
 
 	::RenderQueuePair RenderQueue;
 
-	std::shared_ptr<Frame> Parent() const { return m_Parent; }
+	Frame* Parent() const { return m_Parent; }
-	void SetParent(std::shared_ptr<Frame> parent) 
+	void SetParent(Frame* parent) 
 	{
 		if (parent == nullptr)
 		{
@@ -62,13 +79,13 @@ public:
 		Width = parent->Width;
 		Height = parent->Height;
 		m_Layer = parent->Layer() + 1;
-		parent->AddChild(std::shared_ptr<Frame>(this));
+		parent->AddChild(this);
 		m_Parent = parent;
 		EventBroker = parent->EventBroker;
 		ResourceManager = parent->ResourceManager;
 	}
 
-	void AddChild(std::shared_ptr<Frame> child)
+	void AddChild(Frame* child)
 	{
 		m_Children[child->m_Layer].insert(std::make_pair(child->Name(), child));
 		if (m_Parent)
@@ -77,7 +94,19 @@ public:
 		}
 	}
 
-	typedef std::map<std::string, std::shared_ptr<Frame>>::const_iterator FrameChildrenIterator;
+	void RemoveChild(Frame* child)
+	{
+		auto it = m_Children.find(child->m_Layer);
+		if (it != m_Children.end())
+		{
+			m_Children.erase(it);
+		}
+
+		if (m_Parent)
+		{
+			m_Parent->RemoveChild(child);
+		}
+	}
 
 	std::string Name() const { return m_Name; }
 	void SetName(std::string val) { m_Name = val; }
@@ -89,8 +118,14 @@ public:
 		else
 			return m_Hidden; 
 	}
-	void Hide() { m_Hidden = true; }
+
-	void Show() { m_Hidden = false; }
+	bool Visible() const
+	{
+		return !Hidden();
+	}
+
+	virtual void Hide() { m_Hidden = true; }
+	virtual void Show() { m_Hidden = false; }
 
 	int Left() const override
 	{ 
@@ -144,9 +179,6 @@ public:
 
 	void UpdateLayered(double dt)
 	{
-		if (this->Hidden())
-			return;
-
 		// Update ourselves
 		this->Update(dt);
 
@@ -157,8 +189,6 @@ public:
 			for (auto &pairChild : children)
 			{
 				auto child = pairChild.second;
-				if (child->Hidden())
-					continue;
 				child->Update(dt);
 			}
 		}
@@ -200,8 +230,8 @@ protected:
 	int m_Layer;
 	bool m_Hidden;
 
-	std::shared_ptr<Frame> m_Parent;
+	Frame* m_Parent;
-	typedef std::multimap<std::string, std::shared_ptr<Frame>> Children_t; // name -> frame
+	typedef std::multimap<std::string, Frame*> Children_t; // name -> frame
 	std::map<int, Children_t> m_Children; // layer -> Children_t
 
 	virtual bool OnKeyDown(const Events::KeyDown &event) { return false; }

src/GUI/GameFrame.h

@@ -2,13 +2,15 @@
 #define GUI_GameFrame_h__
 
 #include "GUI/Frame.h"
+#include "GUI/MainMenuFrame.h"
 #include "GUI/WorldFrame.h"
 #include "GUI/Viewport.h"
 #include "GUI/TextureFrame.h"
 #include "GUI/PlayerHUD.h"
-#include "VehicleSelection.h"
 
 #include "GameWorld.h"
+#include "Events/GameStart.h"
+#include "Events/GameOver.h"
 
 namespace GUI
 {
@@ -18,37 +20,59 @@ class GameFrame : public Frame
 public:
 	GameFrame(Frame* parent, std::string name)
 		: Frame(parent, name)
+		, m_GameOver(false)
 	{
+		EVENT_SUBSCRIBE_MEMBER(m_EGameStart, &GUI::GameFrame::OnGameStart);
+		EVENT_SUBSCRIBE_MEMBER(m_EGameOver, &GUI::GameFrame::OnGameOver);
+
 		m_World = std::make_shared<GameWorld>(EventBroker, ResourceManager);
-		auto worldFrame = new WorldFrame(this, "GameWorldFrame", m_World);
+		m_WorldFrame = new WorldFrame(this, "GameWorldFrame", m_World);
 		{
-			vp1 = new Viewport(worldFrame, "Viewport1", m_World);
+			vp1 = new Viewport(m_WorldFrame, "Viewport1", m_World);
 			vp1->X = 0;
 			vp1->Width = this->Width / 2.f;
-			//new PlayerHUD(vp1, "PlayerHUD", m_World, 1);
+			new PlayerHUD(vp1, "PlayerHUD", m_World, 1);
-			new VehicleSelection(vp1, "VehicleSelection", m_World, 1);
 
-			vp2 = new Viewport(worldFrame, "Viewport2", m_World);
+			vp2 = new Viewport(m_WorldFrame, "Viewport2", m_World);
 			vp2->X = vp1->Right();
 			vp2->Width = this->Width / 2.f;
-			//new PlayerHUD(vp2, "PlayerHUD", m_World, 2);
+			new PlayerHUD(vp2, "PlayerHUD", m_World, 2);
-			new VehicleSelection(vp2, "VehicleSelection", m_World, 2);
 
-
+			m_FreeCamViewport = new Viewport(m_WorldFrame, "ViewportFreeCam", m_World);
-			m_FreeCamViewport = new Viewport(worldFrame, "ViewportFreeCam", m_World);
 			m_FreeCamViewport->Hide();
 		}
+		//m_WorldFrame->Hide();
+		//m_MainMenuFrame = new MainMenuFrame(this, "MainMenu");
+
 		m_World->Initialize();
 	}
 
 private:
-	EventRelay<Frame, Events::KeyUp> m_EKeyUp;
+	EventRelay<Frame, Events::GameStart> m_EGameStart;
+	bool OnGameStart(const Events::GameStart &event)
+	{
+		m_WorldFrame->Show();
+
+		return true;
+	}
+	EventRelay<Frame, Events::GameOver> m_EGameOver;
+	bool OnGameOver(const Events::GameOver &event)
+	{
+		m_GameOver = true;
+
+		return true;
+	}
 
 	std::shared_ptr<GameWorld> m_World;
+
+	MainMenuFrame* m_MainMenuFrame;
+	WorldFrame* m_WorldFrame;
 	Viewport* vp1;
 	Viewport* vp2;
 	Viewport* m_FreeCamViewport;
 
+	bool m_GameOver;
+
 	bool OnKeyUp(const Events::KeyUp &event) override
 	{ 
 		if (event.KeyCode == GLFW_KEY_1)

src/GUI/GameOverFrame.h

@@ -0,0 +1,41 @@
+#ifndef GUI_GameOverFrame_h__
+#define GUI_GameOverFrame_h__
+
+#include "GUI/Frame.h"
+#include "GUI/HealthOverlay.h"
+
+namespace GUI
+{
+
+	class GameOverFrame : public Frame
+	{
+	public:
+		GameOverFrame(Frame* parent, std::string name)
+			: Frame(parent, name)
+		{
+			//Hide();
+			m_Background = new TextureFrame(this, "Background");
+			m_Background->SetTexture("Textures/GUI/black.png");
+			m_Background->SetColor(glm::vec4(1.f, 1.f, 1.f, 0.6f));
+			m_Text = new TextureFrame(this, "Message");
+			m_Text->SetTexture("Textures/GUI/GloriousVictory.png");
+		}
+
+		void Show(bool victory)
+		{
+			if (victory)
+				m_Text->SetTexture("Textures/GUI/GloriousVictory.png");
+			else
+				m_Text->SetTexture("Textures/GUI/ShamefulDefeat.png");
+
+			Frame::Show();
+		}
+
+	protected:
+		bool m_Victory;
+		TextureFrame* m_Background;
+		TextureFrame* m_Text;
+	};
+}
+
+#endif // GUI_GameOverFrame_h__

src/GUI/MainMenuFrame.h

@@ -0,0 +1,100 @@
+#ifndef GUI_MainMenuFrame_h__
+#define GUI_MainMenuFrame_h__
+
+#include "GUI/Frame.h"
+#include "GUI/HealthOverlay.h"
+
+#include "Events/GameStart.h"
+
+namespace GUI
+{
+
+class MainMenuFrame : public Frame
+{
+public:
+	MainMenuFrame(Frame* parent, std::string name)
+		: Frame(parent, name)
+	{
+		m_CurrentSelection = 0;
+
+		//Hide();
+		m_Background = new TextureFrame(this, "Background");
+		m_Background->SetTexture("Textures/GUI/MainMenu/BackGround.png");
+
+		m_Buttons = new TextureFrame(this, "Message");
+		m_Buttons->SetTexture("Textures/GUI/MainMenu/Buttons.png");
+		m_CurrentCoordinate = -m_SelectionCoordinates[0] * Scale();
+		m_TargetCoordinate = m_CurrentCoordinate;
+		m_Buttons->X = m_CurrentCoordinate.x;
+		m_Buttons->Y = m_CurrentCoordinate.y;
+	}
+
+	void Update(double dt) override
+	{
+		if (Hidden())
+			return;
+
+		glm::vec2 posDiff = m_TargetCoordinate - m_CurrentCoordinate;
+		m_CurrentCoordinate += posDiff * 4.f * (float)dt;
+
+		m_Buttons->X = m_CurrentCoordinate.x;
+		m_Buttons->Y = m_CurrentCoordinate.y;
+	}
+
+protected:
+	bool m_Victory;
+	TextureFrame* m_Background;
+	TextureFrame* m_Buttons;
+
+	int m_CurrentSelection;
+	static glm::vec2 m_SelectionCoordinates[2];
+	glm::vec2 m_CurrentCoordinate;
+	glm::vec2 m_TargetCoordinate;
+
+	bool OnCommand(const Events::InputCommand &event) override
+	{
+		if (Hidden())
+			return false;
+
+		const float deadzone = 0.5f;
+
+		if (event.Command == "interface_horizontal")
+		{
+			if (event.Value > deadzone)
+				m_CurrentSelection++;
+			else if (event.Value < -deadzone)
+				m_CurrentSelection--;
+		}
+		m_CurrentSelection = (m_CurrentSelection < 0) ? 0 : ((m_CurrentSelection > 1) ? 1 : m_CurrentSelection);
+		m_TargetCoordinate = -m_SelectionCoordinates[m_CurrentSelection] * Scale();
+
+		if (event.Command == "interface_confirm" && event.Value > 0)
+		{
+			// Play
+			if (m_CurrentSelection == 0)
+			{
+				Hide();
+				Events::GameStart e;
+				EventBroker->Publish(e);
+			}
+			// Quit
+			else if (m_CurrentSelection == 1)
+			{
+				exit(EXIT_SUCCESS);
+			}
+		}
+
+		return false;
+	}
+
+	
+};
+
+glm::vec2 MainMenuFrame::m_SelectionCoordinates[2] = {
+	glm::vec2(0, 0),
+	glm::vec2(193, 0),
+};
+
+}
+
+#endif // GUI_MainMenuFrame_h__

src/GUI/PlayerHUD.h

@@ -3,6 +3,11 @@
 
 #include "GUI/Frame.h"
 #include "GUI/HealthOverlay.h"
+#include "GUI/VehicleSelection.h"
+#include "GUI/GameOverFrame.h"
+
+#include "Events/GameOver.h"
+#include "Components/Player.h"
 
 namespace GUI
 {
@@ -15,7 +20,10 @@ namespace GUI
 			, m_World(world)
 			, m_PlayerID(playerID)
 		{
+			EVENT_SUBSCRIBE_MEMBER(m_EGameOver, &GUI::PlayerHUD::OnGameOver)
+
 			m_HealthOverlay = new HealthOverlay(this, "HealthOverlay", m_World, m_PlayerID);
+
 			m_Crosshair = new TextureFrame(this, "Crosshair");
 			m_Crosshair->Width = 45;
 			m_Crosshair->Height = 45;
@@ -23,6 +31,10 @@ namespace GUI
 			m_Crosshair->Y = this->Height / 2.f - m_Crosshair->Height / 2.f;
 			m_Crosshair->SetTexture("Textures/GUI/crosshair.png");
 			m_Crosshair->SetColor(glm::vec4(1.f, 1.f, 1.f, 0.75f));
+
+			m_VehicleSelection = new VehicleSelection(this, "VehicleSelection", m_World, m_PlayerID);
+
+			m_GameOverFrame = new GameOverFrame(this, "GameOver");
 		}
 
 	protected:
@@ -31,6 +43,42 @@ namespace GUI
 
 		HealthOverlay* m_HealthOverlay;
 		TextureFrame* m_Crosshair;
+		VehicleSelection* m_VehicleSelection;
+		GameOverFrame* m_GameOverFrame;
+
+		EventRelay<Frame, Events::GameOver> m_EGameOver;
+		bool OnGameOver(const Events::GameOver &event)
+		{
+			auto playerComponent = m_World->GetComponent<Components::Player>(event.Winner);
+			if (!playerComponent)
+			{
+				LOG_ERROR("Winner is not a valid player!");
+				return false;
+			}
+
+			if (m_PlayerID == playerComponent->ID)
+				m_GameOverFrame->Show(true);
+			else
+				m_GameOverFrame->Show(false);
+
+			return true;
+		}
+
+		bool OnCommand(const Events::InputCommand &event)
+		{
+			if (event.PlayerID != m_PlayerID)
+				return false;
+
+			if (event.Command == "interface_confirm" && event.Value > 0)
+			{
+				if (m_GameOverFrame->Visible())
+				{
+					m_GameOverFrame->Hide();
+				}
+			}
+
+			return true;
+		}
 	};
 
 }

src/GUI/VehicleSelection.h

@@ -40,6 +40,9 @@ namespace GUI
 
 		void Update(double dt) override
 		{
+			if (Hidden())
+				return;
+
 			glm::vec2 posDiff = m_TargetCoordinate - m_CurrentCoordinate;
 			m_CurrentCoordinate += posDiff * 2.f * (float)dt;
 
@@ -77,28 +80,30 @@ namespace GUI
 			if (event.PlayerID != m_PlayerID)
 				return false;
 
+			const float deadzone = 0.5f;
+
 			// Menu movement
 			if (event.Command == "interface_horizontal" || event.Command == "interface_vertical")
 			{
 				// Horizontal scrolling
 				if (event.Command == "interface_horizontal")
 				{
-					if (event.Value > 0)
+					if (event.Value > deadzone)
 						m_CurrentSelection++;
-					else if (event.Value < 0)
+					else if (event.Value < -deadzone)
 						m_CurrentSelection--;
 				}
 				// Vertical scrolling to switch between "rows" in an intuitive way
 				else if (event.Command == "interface_vertical")
 				{
-					if (event.Value > 0)
+					if (event.Value > deadzone)
 					{
 						if (m_CurrentSelection == 0)
 							m_CurrentSelection++;
 						else if (m_CurrentSelection == 3)
 							m_CurrentSelection--;
 					}
-					else if (event.Value < 0)
+					else if (event.Value < -deadzone)
 					{
 						if (m_CurrentSelection == 1)
 							m_CurrentSelection--;

src/GUI/WorldFrame.h

@@ -145,7 +145,7 @@ private:
 		auto itpair = m_Children[m_Layer + 1].equal_range(event.ViewportFrame);
 		for (auto it = itpair.first; it != itpair.second; ++it)
 		{
-			auto viewportFrame = std::dynamic_pointer_cast<GUI::Viewport>(it->second);
+			auto viewportFrame = dynamic_cast<GUI::Viewport*>(it->second);
 			if (!viewportFrame)
 				continue;
 

src/GameWorld.cpp

@@ -43,6 +43,8 @@ void GameWorld::Initialize()
 
 	BindKey(GLFW_KEY_Z, "shoot", 1.f);
 	BindGamepadAxis(Gamepad::Axis::RightTrigger, "shoot", 1.f);
+	BindGamepadAxis(Gamepad::Axis::RightTrigger, "jeep_vertical", 1.f);
+	BindGamepadAxis(Gamepad::Axis::LeftTrigger, "jeep_vertical", -1.f);
 
 	BindKey(GLFW_KEY_X, "use", 1.f);
 	BindGamepadButton(Gamepad::Button::X, "use", 1.f);
@@ -402,7 +404,6 @@ void GameWorld::Initialize()
 		}
 		CommitEntity(gateBase);
 	}
-
 }
 
 void GameWorld::Update(double dt)
@@ -418,6 +419,7 @@ void GameWorld::RegisterComponents()
 	m_ComponentFactory.Register<Components::Flag>([]() { return new Components::Flag(); });
 	m_ComponentFactory.Register<Components::Move>([]() { return new Components::Move(); });
 	m_ComponentFactory.Register<Components::Rotate>([]() { return new Components::Rotate(); });
+	m_ComponentFactory.Register<Components::Team>([]() { return new Components::Team(); });
 }
 
 void GameWorld::RegisterSystems()
@@ -433,6 +435,7 @@ void GameWorld::RegisterSystems()
 	//m_SystemFactory.Register<Systems::PlayerSystem>([this]() { return new Systems::PlayerSystem(this); });
 	m_SystemFactory.Register<Systems::FreeSteeringSystem>([this]() { return new Systems::FreeSteeringSystem(this, EventBroker, ResourceManager); });
 	m_SystemFactory.Register<Systems::TankSteeringSystem>([this]() { return new Systems::TankSteeringSystem(this, EventBroker, ResourceManager); });
+	m_SystemFactory.Register<Systems::JeepSteeringSystem>([this]() { return new Systems::JeepSteeringSystem(this, EventBroker, ResourceManager); });
 	m_SystemFactory.Register<Systems::WheelPairSystem>([this]() { return new Systems::WheelPairSystem(this, EventBroker, ResourceManager); });
 	m_SystemFactory.Register<Systems::SoundSystem>([this]() { return new Systems::SoundSystem(this, EventBroker, ResourceManager); });
 	m_SystemFactory.Register<Systems::PhysicsSystem>([this]() { return new Systems::PhysicsSystem(this, EventBroker, ResourceManager); });
@@ -457,6 +460,7 @@ void GameWorld::AddSystems()
 	//AddSystem<Systems::PlayerSystem>();
 	AddSystem<Systems::FreeSteeringSystem>();
 	AddSystem<Systems::TankSteeringSystem>();
+	AddSystem<Systems::JeepSteeringSystem>();
 	AddSystem<Systems::WheelPairSystem>();
 	AddSystem<Systems::SoundSystem>();
 	AddSystem<Systems::PhysicsSystem>();
@@ -504,7 +508,7 @@ void GameWorld::BindGamepadButton(Gamepad::Button button, std::string command, f
 	EventBroker->Publish(e);
 }
 
-void GameWorld::CreateGate(EntityID parent, glm::vec3 position, glm::quat orientation)
+void GameWorld::CreateGate(EntityID parent, glm::vec3 position, glm::quat orientation, int teamID)
 {
 	auto gateParent = CreateEntity(parent);
 	auto transform = AddComponent<Components::Transform>(gateParent);
@@ -611,9 +615,11 @@ void GameWorld::CreateGate(EntityID parent, glm::vec3 position, glm::quat orient
 		auto transform = AddComponent<Components::Transform>(gateTrigger);
 		transform->Position = glm::vec3(0, 2.8241, 0);
 		auto trigger = AddComponent<Components::Trigger>(gateTrigger);
+		trigger->TeamID = teamID;
 		auto triggerMove = AddComponent<Components::TriggerMove>(gateTrigger);
 		triggerMove->Entity = gate;
-
+		auto teamComponent = AddComponent<Components::Team>(gateTrigger);
+		teamComponent->TeamID = teamID;
 		{
 			auto shape = CreateEntity(gateTrigger);
 			auto transform = AddComponent<Components::Transform>(shape);
@@ -758,9 +764,12 @@ EntityID GameWorld::CreateWall(EntityID parent, glm::vec3 pos, glm::quat orienta
 
 	auto model = AddComponent<Components::Model>(wall);
 	model->ModelFile = "Models/Wall/WallWhole/Wall.obj";
+	auto damageModel = AddComponent<Components::DamageModel>(wall);
+	damageModel->ModelFile = "Models/Wall/WallWhole/WallCracks.obj";
 
 	auto health = AddComponent<Components::Health>(wall);
 	health->Amount = 50.f;
+	health->VulnerableToSplash = false;
 
 	auto shape = CreateEntity(wall);
 	auto shapetransform = AddComponent<Components::Transform>(shape);
@@ -774,126 +783,6 @@ EntityID GameWorld::CreateWall(EntityID parent, glm::vec3 pos, glm::quat orienta
 
 }
 
-EntityID GameWorld::CreateJeep(int playerID)
-{
-	auto jeep = CreateEntity();
-	auto transform = AddComponent<Components::Transform>(jeep);
-	transform->Position = glm::vec3(0, 5, 0);
-	transform->Orientation = glm::angleAxis(glm::pi<float>() / 2, glm::vec3(0, 1, 0));
-	auto physics = AddComponent<Components::Physics>(jeep);
-	physics->Mass = 1800;
-	physics->MotionType = Components::Physics::MotionTypeEnum::Dynamic;
-	auto vehicle = AddComponent<Components::Vehicle>(jeep);
-	vehicle->DownshiftRPM = 3500.f;
-	vehicle->UpshiftRPM = 6000.f;
-	
-	AddComponent<Components::Input>(jeep);
-	auto player = AddComponent<Components::Player>(jeep);
-	player->ID = playerID;
-	auto health = AddComponent<Components::Health>(jeep);
-	health->Amount = 100.f;
-
-	{
-		auto shape = CreateEntity(jeep);
-		auto transform = AddComponent<Components::Transform>(shape);
-		auto meshShape = AddComponent<Components::MeshShape>(shape);
-		meshShape->ResourceName = "Models/Jeep/Chassi/ChassiCollision.obj";
-		CommitEntity(shape);
-	}
-
-	{
-		auto chassis = CreateEntity(jeep);
-		auto transform = AddComponent<Components::Transform>(chassis);
-		transform->Position = glm::vec3(0, 0, 0); // 0.6577f
-		auto model = AddComponent<Components::Model>(chassis);
-		model->ModelFile = "Models/Jeep/Chassi/chassi.obj";
-	}
-
-	//Create wheels
-	float wheelOffset = 0.4f;
-	float springLength = 0.3f;
-	float suspensionStrength = 35.f;
-	{
-		auto wheel = CreateEntity(jeep);
-		auto transform = AddComponent<Components::Transform>(wheel);
-		transform->Position = glm::vec3(1.9f, 0.5546f - wheelOffset, -0.9242f);
-		transform->Scale = glm::vec3(1.0f);
-		auto model = AddComponent<Components::Model>(wheel);
-		model->ModelFile = "Models/Jeep/WheelFront/wheelFront.obj";
-		auto Wheel = AddComponent<Components::Wheel>(wheel);
-		Wheel->Hardpoint = transform->Position + glm::vec3(0.f, springLength, 0.f);
-		Wheel->AxleID = 0;
-		Wheel->Mass = 50;
-		Wheel->Radius = 0.837f;
-		Wheel->Steering = true;
-		Wheel->SuspensionStrength = suspensionStrength;
-		Wheel->Friction = 4.f;
-		Wheel->ConnectedToHandbrake = true;
-		CommitEntity(wheel);
-	}
-
-	{
-		auto wheel = CreateEntity(jeep);
-		auto transform = AddComponent<Components::Transform>(wheel);
-		transform->Position = glm::vec3(-1.9f, 0.5546f - wheelOffset, -0.9242f);
-		transform->Scale = glm::vec3(1.0f);
-		transform->Orientation = glm::angleAxis(glm::pi<float>(), glm::vec3(0, 0, 1));
-		auto model = AddComponent<Components::Model>(wheel);
-		model->ModelFile = "Models/Jeep/WheelFront/wheelFront.obj";
-		auto Wheel = AddComponent<Components::Wheel>(wheel);
-		Wheel->Hardpoint = transform->Position + glm::vec3(0.f, springLength, 0.f);
-		Wheel->AxleID = 0;
-		Wheel->Mass = 50;
-		Wheel->Radius = 0.837f;
-		Wheel->Steering = true;
-		Wheel->SuspensionStrength = suspensionStrength;
-		Wheel->Friction = 4.f;
-		Wheel->ConnectedToHandbrake = true;
-		CommitEntity(wheel);
-	}
-
-	{
-		auto wheel = CreateEntity(jeep);
-		auto transform = AddComponent<Components::Transform>(wheel);
-		transform->Position = glm::vec3(0.2726f, 0.2805f - wheelOffset, 1.9307f);
-		auto model = AddComponent<Components::Model>(wheel);
-		model->ModelFile = "Models/Jeep/WheelBack/wheelBack.obj";
-		auto Wheel = AddComponent<Components::Wheel>(wheel);
-		Wheel->Hardpoint = transform->Position + glm::vec3(0.f, springLength, 0.f);
-		Wheel->AxleID = 1;
-		Wheel->Mass = 50;
-		Wheel->Radius = 0.737f;
-		Wheel->Steering = false;
-		Wheel->SuspensionStrength = suspensionStrength;
-		Wheel->Friction = 4.f;
-		Wheel->ConnectedToHandbrake = true;
-		CommitEntity(wheel);
-	}
-
-	{
-		auto wheel = CreateEntity(jeep);
-		auto transform = AddComponent<Components::Transform>(wheel);
-		transform->Position = glm::vec3(-0.2726f, 0.2805f - wheelOffset, 1.9307f);
-		transform->Orientation = glm::angleAxis(glm::pi<float>(), glm::vec3(0, 0, 1));
-		auto model = AddComponent<Components::Model>(wheel);
-		model->ModelFile = "Models/Jeep/WheelBack/wheelBack.obj";
-		auto Wheel = AddComponent<Components::Wheel>(wheel);
-		Wheel->Hardpoint = transform->Position + glm::vec3(0.f, springLength, 0.f);
-		Wheel->AxleID = 1;
-		Wheel->Mass = 50;
-		Wheel->Radius = 0.737f;
-		Wheel->Steering = false;
-		Wheel->SuspensionStrength = suspensionStrength;
-		Wheel->Friction = 4.f;
-		Wheel->ConnectedToHandbrake = true;
-		CommitEntity(wheel);
-	}
-
-	CommitEntity(jeep);
-
-	return jeep;	
-}
-
 void GameWorld::CreateTerrain()
 {
 	{
@@ -980,7 +869,7 @@ void GameWorld::CreateTerrain()
 	}
 
 	CreateBase(glm::quat(), 1);
-	//CreateBase(glm::quat(glm::vec3(0, glm::pi<float>(), 0)), 2);
+	CreateBase(glm::quat(glm::vec3(0, glm::pi<float>(), 0)), 2);
 
 	{
 		auto tree = CreateEntity();
@@ -1049,7 +938,7 @@ void GameWorld::CreateTerrain()
 	}
 }
 
-void GameWorld::CreateBase(glm::quat orientation, int playerID)
+void GameWorld::CreateBase(glm::quat orientation, int teamID)
 {
 	auto base = CreateEntity();
 	auto transform = AddComponent<Components::Transform>(base);
@@ -1115,14 +1004,69 @@ void GameWorld::CreateBase(glm::quat orientation, int playerID)
 
 		{
 			auto shape = CreateEntity(bridge_middle);
-			auto transformshape = AddComponent<Components::Transform>(shape);
+			auto transform = AddComponent<Components::Transform>(shape);
-			auto meshShape = AddComponent<Components::MeshShape>(shape);
+			transform->Position = glm::vec3(70.31883f, 26.42735f, 0.50379f);
-			meshShape->ResourceName = "Models/TerrainFiveIstles/Bridges/MiddleBridgeCollision.obj";
+			auto box = AddComponent<Components::BoxShape>(shape);
+			box->Width = 26.324f;
+			box->Height = 2.727f;
+			box->Depth = 6.798f;
+			CommitEntity(shape);
+		}
+		{
+			auto shape = CreateEntity(bridge_middle);
+			auto transform = AddComponent<Components::Transform>(shape);
+			transform->Position = glm::vec3(70.43447f, 29.23594f, 7.37155f);
+			auto box = AddComponent<Components::BoxShape>(shape);
+			box->Width = 27.724f;
+			box->Height = 1.334f;
+			box->Depth = 0.571f;
+			CommitEntity(shape);
+		}
+		{
+			auto shape = CreateEntity(bridge_middle);
+			auto transform = AddComponent<Components::Transform>(shape);
+			transform->Position = glm::vec3(70.43447f, 29.26906f, -6.68171f);
+			auto box = AddComponent<Components::BoxShape>(shape);
+			box->Width = 27.724f;
+			box->Height = 1.334f;
+			box->Depth = 0.571f;
+			CommitEntity(shape);
+		}
+		{
+			auto shape = CreateEntity(bridge_middle);
+			auto transform = AddComponent<Components::Transform>(shape);
+			transform->Position = glm::vec3(70.36976f, 33.56011f, 9.68543f);
+			auto box = AddComponent<Components::BoxShape>(shape);
+			box->Width = 1.8f;
+			box->Height = 15.984f;
+			box->Depth = 1.456f;
+			CommitEntity(shape);
+		}
+		{
+			auto shape = CreateEntity(bridge_middle);
+			auto transform = AddComponent<Components::Transform>(shape);
+			transform->Position = glm::vec3(70.36976f, 33.56011f, -8.67785f);
+			auto box = AddComponent<Components::BoxShape>(shape);
+			box->Width = 1.799f;
+			box->Height = 15.983f;
+			box->Depth = 1.456f;
+			CommitEntity(shape);
+		}
+		{
+			auto shape = CreateEntity(bridge_middle);
+			auto transform = AddComponent<Components::Transform>(shape);
+			transform->Position = glm::vec3(99.16043f, 25.0318f, 0.54486f);
+			transform->Orientation = glm::angleAxis(glm::radians(-9.087f), glm::vec3(0, 0, 1));
+			auto box = AddComponent<Components::BoxShape>(shape);
+			box->Width = 3.566f;
+			box->Height = 3.566f;
+			box->Depth = 7.632f;
 			CommitEntity(shape);
 		}
 		CommitEntity(bridge_middle);
 	}
 
+
 	{
 		auto terrain_base = CreateEntity(base);
 		auto transform = AddComponent<Components::Transform>(terrain_base);
@@ -1203,16 +1147,60 @@ void GameWorld::CreateBase(glm::quat orientation, int playerID)
 
 		{
 			auto shape = CreateEntity(bridge_base);
-			auto transformshape = AddComponent<Components::Transform>(shape);
+			auto transform = AddComponent<Components::Transform>(shape);
-			auto meshShape = AddComponent<Components::MeshShape>(shape);
+			transform->Position = glm::vec3(166.19089f, 25.99645f, -0.50379f);
-			meshShape->ResourceName = "Models/TerrainFiveIstles/Bridges/BaseBridge.obj";
+			auto box = AddComponent<Components::BoxShape>(shape);
+			box->Width = 27.723f;
+			box->Height = 2.727f;
+			box->Depth = 6.798f;
 			CommitEntity(shape);
 		}
+		{
+			auto shape = CreateEntity(bridge_base);
+			auto transform = AddComponent<Components::Transform>(shape);
+			transform->Position = glm::vec3(166.19089f, 28.37571f, -6.68171f);
+			auto box = AddComponent<Components::BoxShape>(shape);
+			box->Width = 27.724f;
+			box->Height = 1.334f;
+			box->Depth = 0.571f;
+			CommitEntity(shape);
+		}
+		{
+			auto shape = CreateEntity(bridge_base);
+			auto transform = AddComponent<Components::Transform>(shape);
+			transform->Position = glm::vec3(166.19089f, 28.37571f, 7.68929f);
+			auto box = AddComponent<Components::BoxShape>(shape);
+			box->Width = 27.724f;
+			box->Height = 1.334f;
+			box->Depth = 0.571f;
+			CommitEntity(shape);
+		}
+		{
+			auto shape = CreateEntity(bridge_base);
+			auto transform = AddComponent<Components::Transform>(shape);
+			transform->Position = glm::vec3(166.12617f, 33.56011f, -8.67785f);
+			auto box = AddComponent<Components::BoxShape>(shape);
+			box->Width = 1.8;
+			box->Height = 15.984f;
+			box->Depth = 1.456f;
+			CommitEntity(shape);
+		}
+		{
+			auto shape = CreateEntity(bridge_base);
+			auto transform = AddComponent<Components::Transform>(shape);
+			transform->Position = glm::vec3(166.12617f, 33.56011f, 9.68543f);
+			auto box = AddComponent<Components::BoxShape>(shape);
+			box->Width = 1.8;
+			box->Height = 15.984f;
+			box->Depth = 1.456f;
+			CommitEntity(shape);
+		}
+
 		CommitEntity(bridge_base);
 	}
 #pragma endregion Terrain
 
-	CreateGate(base, glm::vec3(273.f, 40.185f, 0.06f), glm::quat(glm::vec3(0, glm::pi<float>() / 2.f, 0)));
+	CreateGate(base, glm::vec3(273.f, 40.185f, 0.06f), glm::quat(glm::vec3(0, glm::pi<float>() / 2.f, 0)), teamID);
 	CreateWall(base, glm::vec3(273.f, 40.3f, -55.f), glm::quat(glm::vec3(0, glm::pi<float>() / 2.f, 0)));
 	CreateWall(base, glm::vec3(273.f, 40.3f, -45.f), glm::quat(glm::vec3(0, glm::pi<float>() / 2.f, 0)));
 	CreateWall(base, glm::vec3(273.f, 40.3f, -35.f), glm::quat(glm::vec3(0, glm::pi<float>() / 2.f, 0)));
@@ -1222,19 +1210,16 @@ void GameWorld::CreateBase(glm::quat orientation, int playerID)
 	CreateWall(base, glm::vec3(273.f, 40.3f, 25.f), glm::quat(glm::vec3(0, glm::pi<float>() / 2.f, 0)));
 	CreateTower(base, glm::vec3(290.f, 40.3f, 15.f), playerID);
 
-	CreateGarage(base, glm::vec3(323.2f, 41.4f, -10.2f), glm::quat(glm::vec3(0, glm::pi<float>() / 2.f, 0)), playerID);
+	CreateGarage(base, glm::vec3(323.2f, 41.4f, -10.2f), glm::quat(glm::vec3(0, glm::pi<float>() / 2.f, 0)), teamID);
 }
-EntityID GameWorld::CreateGarage(EntityID parent, glm::vec3 Position, glm::quat orientation, int playerID)
+
+EntityID GameWorld::CreateGarage(EntityID parent, glm::vec3 Position, glm::quat orientation, int teamID)
 {
 	auto garage = CreateEntity(parent);
 	auto transform = AddComponent<Components::Transform>(garage);
 	transform->Position = Position;
 	transform->Orientation = orientation;
 
-	auto player = CreateEntity(garage);
-	auto playerComponent = AddComponent<Components::Player>(player);
-	playerComponent->ID = playerID;
-
 	auto ElevatorBase = CreateEntity(garage);
 	{
 		auto transform = AddComponent<Components::Transform>(ElevatorBase);
@@ -1346,7 +1331,8 @@ EntityID GameWorld::CreateGarage(EntityID parent, glm::vec3 Position, glm::quat
 			auto transform = AddComponent<Components::Transform>(spawnPoint);
 			transform->Position.y = 1.f;
 			auto spawnPointComponent = AddComponent<Components::SpawnPoint>(spawnPoint);
-			spawnPointComponent->Player = player;
+			auto teamComponent = AddComponent<Components::Team>(spawnPoint);
+			teamComponent->TeamID = teamID;
 		}
 		CommitEntity(spawnPoint);
 	}
@@ -1364,6 +1350,9 @@ EntityID GameWorld::CreateGarage(EntityID parent, glm::vec3 Position, glm::quat
 		auto transform = AddComponent<Components::Transform>(trigger);
 		transform->Position = glm::vec3(0, 44.87521f, 0);
 		auto triggerComponent = AddComponent<Components::Trigger>(trigger);
+		triggerComponent->TeamID = teamID;
+		auto teamComponent = AddComponent<Components::Team>(trigger);
+		teamComponent->TeamID = teamID;
 		{
 			auto shape = CreateEntity(trigger);
 			auto transform = AddComponent<Components::Transform>(shape);
@@ -1383,6 +1372,9 @@ EntityID GameWorld::CreateGarage(EntityID parent, glm::vec3 Position, glm::quat
 		auto transform = AddComponent<Components::Transform>(trigger);
 		transform->Position = glm::vec3(0.69385f, -6.7997f, -2.0f);
 		auto triggerComponent = AddComponent<Components::Trigger>(trigger);
+		triggerComponent->TeamID = teamID;
+		auto teamComponent = AddComponent<Components::Team>(trigger);
+		teamComponent->TeamID = teamID;
 		{
 			auto shape = CreateEntity(trigger);
 			auto transform = AddComponent<Components::Transform>(shape);

src/GameWorld.h

@@ -25,11 +25,13 @@
 #include "Systems/WallSystem.h"
 #include "Systems/TowerSystem.h"
 #include "Systems/GarageSystem.h"
+#include "Systems/JeepSteeringSystem.h"
 
 #include "Components/Camera.h"
 #include "Components/DirectionalLight.h"
 #include "Components/Input.h"
 #include "Components/Model.h"
+#include "Components/DamageModel.h"
 #include "Components/ParticleEmitter.h"
 #include "Components/Particle.h"
 #include "Components/PointLight.h"
@@ -57,6 +59,7 @@
 #include "Components/TriggerRotate.h"
 #include "Components/Move.h"
 #include "Components/Rotate.h"
+#include "Components/Team.h"
 
 class GameWorld : public World
 {
@@ -79,12 +82,12 @@ private:
 	void BindGamepadAxis(Gamepad::Axis axis, std::string command, float value);
 	void BindGamepadButton(Gamepad::Button button, std::string command, float value);
 
-	void CreateGate(EntityID parent, glm::vec3 position, glm::quat orientation);
+	void CreateGate(EntityID parent, glm::vec3 position, glm::quat orientation, int teamID);
 	void AddTankWheelPair(EntityID tankEntity, glm::vec3 position, int axleID, bool steering);
 	EntityID CreateJeep(int playerID);
 	EntityID CreateWall(EntityID parent, glm::vec3 pos, glm::quat orientation);
-	EntityID CreateTower(EntityID parent, glm::vec3 pos, int playerID);
+	EntityID CreateTower(EntityID parent, glm::vec3 pos, int teamID);
-	EntityID CreateGarage(EntityID parent, glm::vec3 Position, glm::quat orientation, int playerID);
+	EntityID CreateGarage(EntityID parent, glm::vec3 Position, glm::quat orientation, int teamID);
 	void CreateTerrain();
 	void CreateBase(glm::quat orientation, int playerID);
 	std::vector<EntityID> m_WallDebrisTemplates;

src/InputController.h

@@ -6,29 +6,63 @@
 #include "EventBroker.h"
 #include "Events/InputCommand.h"
 #include "Events/MouseMove.h"
+#include "Events/GameStart.h"
+#include "Events/GameOver.h"
 
 template <typename EventContext>
 class InputController
 {
 public:
 	InputController(std::shared_ptr<::EventBroker> eventBroker)
-		: EventBroker(eventBroker) { Initialize(); }
+		: EventBroker(eventBroker)
+		, InGame(true)
+	{ Initialize(); }
 
 	virtual void Initialize()
 	{
-		EVENT_SUBSCRIBE_MEMBER(m_EInputCommand, &InputController::OnCommand);
+		EVENT_SUBSCRIBE_MEMBER(m_EInputCommand, &InputController::_OnCommand);
-		EVENT_SUBSCRIBE_MEMBER(m_EMouseMove, &InputController::OnMouseMove);
+		EVENT_SUBSCRIBE_MEMBER(m_EMouseMove, &InputController::_OnMouseMove);
+		EVENT_SUBSCRIBE_MEMBER(m_EGameStart, &InputController::OnGameStart);
+		EVENT_SUBSCRIBE_MEMBER(m_EGameOver, &InputController::OnGameOver);
 	}
 
 	virtual bool OnCommand(const Events::InputCommand &event) { return false; }
 	virtual bool OnMouseMove(const Events::MouseMove &event) { return false; }
+	virtual bool OnGameStart(const Events::GameStart &event)
+	{
+		InGame = true;
+		return true;
+	}
+	virtual bool OnGameOver(const Events::GameOver &event) 
+	{ 
+		InGame = false;
+		return true; 
+	}
 
 protected:
 	std::shared_ptr<::EventBroker> EventBroker;
+	bool InGame;
 
 private:
 	EventRelay<EventContext, Events::InputCommand> m_EInputCommand;
 	EventRelay<EventContext, Events::MouseMove> m_EMouseMove;
+	EventRelay<EventContext, Events::GameStart> m_EGameStart;
+	EventRelay<EventContext, Events::GameOver> m_EGameOver;
+
+	virtual bool _OnCommand(const Events::InputCommand &event) 
+	{ 
+		if (InGame || event.Value == 0)
+			return OnCommand(event);
+		else
+			return false;
+	}
+	virtual bool _OnMouseMove(const Events::MouseMove &event) 
+	{ 
+		if (InGame)
+			return OnMouseMove(event);
+		else
+			return false; 
+	}
 };
 
 #endif // InputController_h__

src/Model.cpp

@@ -93,7 +93,7 @@ Model::Model(std::shared_ptr<ResourceManager> rm, OBJ &obj)
 	if (Vertices.size() > 0)
 	{
 		CreateTangents();
-		getSimilarVertexIndex();
+		//getSimilarVertexIndex();
 		CreateBuffers(Vertices, Normals, TangentNormals, BiTangentNormals, TextureCoords);
 	}
 	else

src/Physics/VehicleSetup.cpp

@@ -114,7 +114,7 @@ void VehicleSetup::setupVehicleData(const hkpWorld* world, hkpVehicleData& data
 
 	data.m_chassisUnitInertiaYaw = 0.8f;
 	data.m_chassisUnitInertiaRoll = 1.0f;
-	data.m_chassisUnitInertiaPitch = 1.0f;
+	data.m_chassisUnitInertiaPitch = 2.0f;
 
 	// Adds or removes torque around the yaw axis 
 	// based on the current steering angle.  This will 

src/Systems/DamageSystem.cpp

@@ -4,6 +4,7 @@
 void Systems::DamageSystem::RegisterComponents( ComponentFactory* cf )
 {
 	cf->Register<Components::Health>([]() { return new Components::Health(); });
+	cf->Register<Components::DamageModel>([]() { return new Components::DamageModel(); });
 }
 
 void Systems::DamageSystem::Initialize()

src/Systems/DamageSystem.h

@@ -4,6 +4,7 @@
 
 #include "System.h"
 #include "Components/Health.h"
+#include "Components/DamageModel.h"
 #include "Events/Damage.h"
 #include "Events/OnDead.h"
 

src/Systems/GameStateSystem.cpp

@@ -0,0 +1,19 @@
+#include "PrecompiledHeader.h"
+#include "GameStateSystem.h"
+#include "World.h"
+
+void Systems::GameStateSystem::Initialize()
+{
+	EVENT_SUBSCRIBE_MEMBER(m_EFlagCaptured, &Systems::GameStateSystem::OnFlagCaptured);
+}
+
+bool Systems::GameStateSystem::OnFlagCaptured(const Events::FlagCaptured &event)
+{
+	m_InGame = false;
+
+	Events::GameOver e;
+	e.Winner = event.Player;
+	EventBroker->Publish(e);
+
+	return true;
+}

src/Systems/GameStateSystem.h

@@ -0,0 +1,37 @@
+#ifndef GameStateSystem_h__
+#define GameStateSystem_h__
+
+#include <set>
+
+#include "System.h"
+#include "Components/Transform.h"
+#include "Components/Player.h"
+#include "Events/FlagCaptured.h"
+#include "Events/GameOver.h"
+
+namespace Systems
+{
+
+class GameStateSystem : public System
+{
+public:
+
+	GameStateSystem(World* world, std::shared_ptr<::EventBroker> eventBroker, std::shared_ptr<::ResourceManager> resourceManager)
+		: System(world, eventBroker, resourceManager) 
+		, m_InGame(true)
+	{ }
+
+	void Initialize() override;
+
+	bool InGame() const { return m_InGame; }
+
+private:
+	bool m_InGame;
+
+	EventRelay<GameStateSystem, Events::FlagCaptured> m_EFlagCaptured;
+	bool OnFlagCaptured(const Events::FlagCaptured &event);
+};
+
+}
+
+#endif // GameStateSystem_h__

src/Systems/GarageSystem.cpp

@@ -34,6 +34,14 @@ bool Systems::GarageSystem::OnEnterTrigger(const Events::EnterTrigger &event)
 	if (!garageComponent)
 		return false;
 
+	auto teamComponent = m_World->GetComponent<Components::Team>(event.Trigger);
+	auto playerComponent = m_World->GetComponent<Components::Player>(event.Entity);
+
+	if(!teamComponent || !playerComponent)
+		return false;
+	if (teamComponent->TeamID != playerComponent->ID)
+		return false;
+
 	std::string name = m_World->GetProperty<std::string>(event.Trigger, "Name");
 
 	if (name == "BoundsTrigger")
@@ -56,6 +64,15 @@ bool Systems::GarageSystem::OnLeaveTrigger(const Events::LeaveTrigger &event)
 	if (!garageComponent)
 		return false;
 
+	auto teamComponent = m_World->GetComponent<Components::Team>(event.Trigger);
+	auto playerComponent = m_World->GetComponent<Components::Player>(event.Entity);
+
+	if(!teamComponent || !playerComponent)
+		return false;
+	if (teamComponent->TeamID != playerComponent->ID)
+		return false;
+
+
 	std::string name = m_World->GetProperty<std::string>(event.Trigger, "Name");
 
 	if (name == "BoundsTrigger")
@@ -76,18 +93,24 @@ bool Systems::GarageSystem::OnCommand(const Events::InputCommand &event)
 		{
 			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 triggerTeamComponent = m_World->GetComponent<Components::Team>(trigger);
-			auto triggerPlayerComponent = m_World->GetComponent<Components::Player>(triggerBaseParent);
+			if (!triggerTeamComponent)
+				continue;
 
 			for (EntityID entity : entities)
 			{
-				auto entityPlayerComponent = m_World->GetComponent<Components::Player>(triggerBaseParent);
+				auto entityPlayerComponent = m_World->GetComponent<Components::Player>(entity);
-				if (triggerPlayerComponent == entityPlayerComponent)
+				if(!entityPlayerComponent)
+					continue;
+
+				if (entityPlayerComponent->ID != event.PlayerID)
+					continue;
+
+				if (triggerTeamComponent->TeamID == entityPlayerComponent->ID)
 				{
 					EntityID garage = m_World->GetEntityParent(trigger);
 					auto garageComponent = m_World->GetComponent<Components::Garage>(garage);

src/Systems/GarageSystem.h

@@ -18,6 +18,7 @@
 #include "Events/Rotate.h"
 #include "Components/Move.h"
 #include "Components/Rotate.h"
+#include "Components/Team.h"
 
 namespace Systems
 {

src/Systems/JeepSteeringSystem.cpp

@@ -0,0 +1,356 @@
+#include "PrecompiledHeader.h"
+#include "JeepSteeringSystem.h"
+#include "World.h"
+
+void Systems::JeepSteeringSystem::RegisterComponents(ComponentFactory* cf)
+{
+	cf->Register<Components::JeepSteering>([]() { return new Components::JeepSteering(); });
+}
+
+void Systems::JeepSteeringSystem::Initialize()
+{
+	EVENT_SUBSCRIBE_MEMBER(m_ESpawnVehicle, &Systems::JeepSteeringSystem::OnSpawnVehicle);
+
+	for (int i = 0; i < 4; i++)
+	{
+		m_JeepInputControllers[i] = std::shared_ptr<JeepSteeringInputController>(new JeepSteeringInputController(EventBroker, i + 1));
+	}
+}
+
+void Systems::JeepSteeringSystem::Update(double dt)
+{
+	for (int i = 0; i < 4; i++)
+	{
+		m_JeepInputControllers[i]->Update(dt);
+	}
+}
+
+void Systems::JeepSteeringSystem::UpdateEntity(double dt, EntityID entity, EntityID parent)
+{
+	auto tankSteeringComponent = m_World->GetComponent<Components::JeepSteering>(entity);
+	if(!tankSteeringComponent)
+		return;
+
+	auto playerComponent = m_World->GetComponent<Components::Player>(entity);
+	if (!playerComponent)
+		return;
+
+	if (playerComponent->ID == 0)
+		return;
+
+	auto inputController = m_JeepInputControllers[playerComponent->ID - 1];
+
+
+	Events::JeepSteer eSteering;
+	eSteering.Entity = entity;
+	eSteering.PositionX = inputController->PositionX;
+	eSteering.PositionY = inputController->PositionY;
+	eSteering.Handbrake = inputController->Handbrake;
+	EventBroker->Publish(eSteering);
+}
+
+bool Systems::JeepSteeringSystem::OnSpawnVehicle(const Events::SpawnVehicle &event)
+{
+
+	if (event.VehicleType != "Jeep")
+		return false;
+
+	auto spawnPointComponents = m_World->GetComponentsOfType<Components::SpawnPoint>();
+	if (!spawnPointComponents)
+	{
+		LOG_ERROR("Found no spawn points!");
+		return false;
+	}
+
+	for (auto &component : *spawnPointComponents)
+	{
+		auto spawnPoint = component->Entity;
+		auto spawnPointComponent = std::dynamic_pointer_cast<Components::SpawnPoint>(component);
+		auto teamComponent =  m_World->GetComponent<Components::Team>(spawnPoint);
+
+		if(!teamComponent)
+		{
+			LOG_ERROR("SpawnPoint has no TeamComponent");
+			continue;
+		}
+
+		if (teamComponent->TeamID != event.PlayerID)
+			continue;
+
+
+		Components::Transform absoluteTransform = m_World->GetSystem<Systems::TransformSystem>()->AbsoluteTransform(spawnPoint);
+
+		// Create a Jeep
+		EntityID Jeep = CreateJeep(event.PlayerID);
+		auto tankTransform = m_World->GetComponent<Components::Transform>(Jeep);
+ 		tankTransform->Position = absoluteTransform.Position;
+ 		tankTransform->Orientation = absoluteTransform.Orientation;
+		// Set the viewport correctly
+		Events::SetViewportCamera e;
+		e.CameraEntity = m_World->GetProperty<EntityID>(Jeep, "Camera");
+		if (event.PlayerID == 1)
+			e.ViewportFrame = "Viewport1";
+		else if (event.PlayerID == 2)
+			e.ViewportFrame = "Viewport2";
+		EventBroker->Publish(e);
+	}
+
+	return true;
+}
+
+EntityID Systems::JeepSteeringSystem::CreateJeep(int playerID)
+{
+	auto jeep = m_World->CreateEntity();
+	auto transform = m_World->AddComponent<Components::Transform>(jeep);
+	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>(jeep);
+	physics->Mass = 2000;
+	physics->MotionType = Components::Physics::MotionTypeEnum::Dynamic;
+	physics->CenterOfMass = glm::vec3(0, 0, 0);
+	auto vehicle = m_World->AddComponent<Components::Vehicle>(jeep);
+	vehicle->MaxTorque = 500.0f;
+	vehicle->MaxSteeringAngle = 40.f;
+	vehicle->MaxSpeedFullSteeringAngle = 12.f;
+	vehicle->MinRPM = 1000.0f; 
+	vehicle->OptimalRPM = 5500.0f,
+	vehicle->MaxRPM = 7500.0f; 
+	vehicle->TopSpeed = 90.0f;
+	vehicle->SpringDamping = 5.f;
+	vehicle->UpshiftRPM = 6500.0f;
+	vehicle->DownshiftRPM = 3500.0f;
+	vehicle->gearsRatio0 = 3.0f;
+	vehicle->gearsRatio1 = 2.25f; 
+	vehicle->gearsRatio2 = 1.5f;
+	vehicle->gearsRatio3 = 1.0f;
+
+	auto player = m_World->AddComponent<Components::Player>(jeep);
+	player->ID = playerID;
+	auto jeepSteering = m_World->AddComponent<Components::JeepSteering>(jeep);
+	m_World->AddComponent<Components::Input>(jeep);
+	auto health = m_World->AddComponent<Components::Health>(jeep);
+	health->Amount = 100.f;
+
+	/*{
+		auto shape = m_World->CreateEntity(jeep);
+		auto transform = m_World->AddComponent<Components::Transform>(shape);
+		auto meshShape = m_World->AddComponent<Components::MeshShape>(shape);
+		meshShape->ResourceName = "Models/Jeep/Chassi/ChassiCollision.obj";
+		m_World->CommitEntity(shape);
+	}*/
+	{
+		auto chassis = m_World->CreateEntity(jeep);
+		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/Jeep/Chassi/Chassi.OBJ";
+	}
+	
+	
+	{
+		auto shape = m_World->CreateEntity(jeep);
+		auto transform = m_World->AddComponent<Components::Transform>(shape);
+		transform->Position = glm::vec3(-0.0219f ,0.88937f, -0.48469f);
+		auto box = m_World->AddComponent<Components::BoxShape>(shape);
+		box->Width = 0.993f;
+		box->Height = 0.626f;
+		box->Depth = 1.316f;
+		m_World->CommitEntity(shape);
+	}
+	{
+		auto shape = m_World->CreateEntity(jeep);
+		auto transform = m_World->AddComponent<Components::Transform>(shape);
+		transform->Position = glm::vec3(-0.02551f ,0.55419f, 1.78935f);
+		auto box = m_World->AddComponent<Components::BoxShape>(shape);
+		box->Width = 0.849f;
+		box->Height = 0.415f;
+		box->Depth = 1.058f;
+		m_World->CommitEntity(shape);
+	}
+	{
+		auto shape = m_World->CreateEntity(jeep);
+		auto transform = m_World->AddComponent<Components::Transform>(shape);
+		transform->Position = glm::vec3(-1.63274f ,0.98825f, -0.89907f);
+		auto box = m_World->AddComponent<Components::BoxShape>(shape);
+		box->Width = 0.697f;
+		box->Height = 0.401f;
+		box->Depth = 0.868f;
+		m_World->CommitEntity(shape);
+	}
+	{
+		auto shape = m_World->CreateEntity(jeep);
+		auto transform = m_World->AddComponent<Components::Transform>(shape);
+		transform->Position = glm::vec3(1.63274f ,0.98825f, -0.89907f);
+		auto box = m_World->AddComponent<Components::BoxShape>(shape);
+		box->Width = 0.697f;
+		box->Height = 0.401f;
+		box->Depth = 0.868f;
+		m_World->CommitEntity(shape);
+	}
+
+	auto cameraTower = m_World->CreateEntity(jeep);
+	{
+		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;
+		m_World->SetProperty(jeep, "Camera", cameraTower);
+	}
+
+#pragma region Wheels
+	//Create wheels
+	float wheelOffset = 0.f;//-0.83f;
+	const float suspensionStrength = 15.f;
+	const float springLength = 0.3f;
+
+	AddJeepWheels(jeep);
+#pragma endregion
+
+	{
+		auto entity = m_World->CreateEntity(jeep);
+		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(jeep);
+
+	return jeep;
+}
+
+void Systems::JeepSteeringSystem::AddJeepWheels(EntityID jeepEntity)
+{
+	//Create wheels
+	float wheelOffset = 0.5f;
+	float springLength = 0.2f;
+	float suspensionStrength = 35.f;
+	{
+		auto wheel = m_World->CreateEntity(jeepEntity);
+		auto transform = m_World->AddComponent<Components::Transform>(wheel);
+		transform->Position = glm::vec3(1.9f, 0.5546f - wheelOffset, -0.9242f);
+		transform->Scale = glm::vec3(1.0f);
+		auto model = m_World->AddComponent<Components::Model>(wheel);
+		model->ModelFile = "Models/Jeep/WheelFront/wheelFront.obj";
+		auto Wheel = m_World->AddComponent<Components::Wheel>(wheel);
+		Wheel->Hardpoint = transform->Position + glm::vec3(0.f, springLength, 0.f);
+		Wheel->AxleID = 0;
+		Wheel->Mass = 50;
+		Wheel->Radius = 0.837f;
+		Wheel->Steering = true;
+		Wheel->SuspensionStrength = suspensionStrength;
+		Wheel->Friction = 2.5f;
+		Wheel->ConnectedToHandbrake = true;
+		m_World->CommitEntity(wheel);
+	}
+
+	{
+		auto wheel = m_World->CreateEntity(jeepEntity);
+		auto transform = m_World->AddComponent<Components::Transform>(wheel);
+		transform->Position = glm::vec3(-1.9f, 0.5546f - wheelOffset, -0.9242f);
+		transform->Scale = glm::vec3(1.0f);
+		transform->Orientation = glm::angleAxis(glm::pi<float>(), glm::vec3(0, 0, 1));
+		auto model = m_World->AddComponent<Components::Model>(wheel);
+		model->ModelFile = "Models/Jeep/WheelFront/wheelFront.obj";
+		auto Wheel = m_World->AddComponent<Components::Wheel>(wheel);
+		Wheel->Hardpoint = transform->Position + glm::vec3(0.f, springLength, 0.f);
+		Wheel->AxleID = 0;
+		Wheel->Mass = 50;
+		Wheel->Radius = 0.837f;
+		Wheel->Steering = true;
+		Wheel->SuspensionStrength = suspensionStrength;
+		Wheel->Friction = 2.5f;
+		Wheel->ConnectedToHandbrake = true;
+		m_World->CommitEntity(wheel);
+	}
+
+	{
+		auto wheel = m_World->CreateEntity(jeepEntity);
+		auto transform = m_World->AddComponent<Components::Transform>(wheel);
+		transform->Position = glm::vec3(0.2726f, 0.2805f - (wheelOffset/2), 1.9307f);
+		auto model = m_World->AddComponent<Components::Model>(wheel);
+		model->ModelFile = "Models/Jeep/WheelBack/wheelBack.obj";
+		auto Wheel = m_World->AddComponent<Components::Wheel>(wheel);
+		Wheel->Hardpoint = transform->Position + glm::vec3(0.f, springLength, 0.f);
+		Wheel->AxleID = 1;
+		Wheel->Mass = 150;
+		Wheel->Radius = 0.737f;
+		Wheel->Steering = false;
+		Wheel->SuspensionStrength = suspensionStrength;
+		Wheel->Friction = 2.5f;
+		Wheel->ConnectedToHandbrake = true;
+		m_World->CommitEntity(wheel);
+	}
+
+	{
+		auto wheel = m_World->CreateEntity(jeepEntity);
+		auto transform = m_World->AddComponent<Components::Transform>(wheel);
+		transform->Position = glm::vec3(-0.2726f, 0.2805f - (wheelOffset/2), 1.9307f);
+		transform->Orientation = glm::angleAxis(glm::pi<float>(), glm::vec3(0, 0, 1));
+		auto model = m_World->AddComponent<Components::Model>(wheel);
+		model->ModelFile = "Models/Jeep/WheelBack/wheelBack.obj";
+		auto Wheel = m_World->AddComponent<Components::Wheel>(wheel);
+		Wheel->Hardpoint = transform->Position + glm::vec3(0.f, springLength, 0.f);
+		Wheel->AxleID = 1;
+		Wheel->Mass = 150;
+		Wheel->Radius = 0.737f;
+		Wheel->Steering = false;
+		Wheel->SuspensionStrength = suspensionStrength;
+		Wheel->Friction = 2.5f;
+		Wheel->ConnectedToHandbrake = true;
+		m_World->CommitEntity(wheel);
+	}
+
+
+}
+
+void Systems::JeepSteeringSystem::JeepSteeringInputController::Update( double dt )
+{
+	PositionX = m_Horizontal;
+	PositionY = m_Vertical;
+}
+
+bool Systems::JeepSteeringSystem::JeepSteeringInputController::OnCommand(const Events::InputCommand &event)
+{
+	if (event.PlayerID != this->PlayerID)
+		return false;
+
+	float val = event.Value;
+	
+	// Tank
+	if (event.Command == "horizontal")
+	{
+		m_Horizontal = val;
+	}
+	else if (event.Command == "jeep_vertical")
+	{
+		m_Vertical = -val;
+	}
+
+	else if (event.Command == "handbrake")
+	{
+		Handbrake = val > 0;
+	}
+	return true;
+}
+

src/Systems/JeepSteeringSystem.h

@@ -0,0 +1,93 @@
+#include <array>
+
+#include "System.h"
+#include "Components/Transform.h"
+#include "Components/Physics.h"
+#include "Components/Vehicle.h"
+#include "Components/Player.h"
+#include "Components/Model.h"
+#include "Systems/TransformSystem.h"
+#include "Systems/ParticleSystem.h"
+#include "InputController.h"
+
+#include "Components/Health.h"
+
+#include "Components/Trigger.h"
+
+#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 "Components/JeepSteering.h"
+#include "Events/JeepSteer.h"
+#include "Components/Team.h"
+
+#include "Events/SetViewportCamera.h"
+
+namespace Systems
+{
+
+	class JeepSteeringSystem : public System
+	{
+	public:
+		JeepSteeringSystem(World* world, std::shared_ptr<::EventBroker> eventBroker, std::shared_ptr<::ResourceManager> resourceManager)
+			: System(world, eventBroker, resourceManager)
+		{ }
+
+		void RegisterComponents(ComponentFactory* cf) override;
+		void Initialize() override;
+
+		void Update(double dt) override;
+		void UpdateEntity(double dt, EntityID entity, EntityID parent) override;
+
+	private:
+		std::map<EntityID, double> m_TimeSinceLastShot;
+		EventRelay<JeepSteeringSystem, Events::SpawnVehicle> m_ESpawnVehicle;
+		bool OnSpawnVehicle(const Events::SpawnVehicle &e);
+
+		class JeepSteeringInputController;
+		std::array<std::shared_ptr<JeepSteeringInputController>, 4> m_JeepInputControllers;
+
+		EntityID CreateJeep(int playerID);
+		void AddJeepWheels(EntityID jeepEntity);
+	};
+
+	class JeepSteeringSystem::JeepSteeringInputController : InputController<JeepSteeringSystem>
+	{
+	public:
+		JeepSteeringInputController(std::shared_ptr<::EventBroker> eventBroker, int playerID)
+			: InputController(eventBroker)
+		{
+			PlayerID = playerID;
+
+			m_Horizontal = 0.f;
+			m_Vertical = 0.f;
+			PositionX = 0;
+			PositionY = 0;
+			Handbrake = false;
+		}
+
+		int PlayerID;
+
+		float PositionY;
+		float PositionX;
+		bool Handbrake;
+
+		void Update(double dt);
+	protected:
+		virtual bool OnCommand(const Events::InputCommand &event);
+		//virtual bool OnMouseMove(const Events::MouseMove &event);
+
+	private:
+		float m_Horizontal;
+		float m_Vertical;
+	};
+}

src/Systems/PhysicsSystem.cpp

@@ -33,6 +33,7 @@ void Systems::PhysicsSystem::Initialize()
 
 	// Events
 	EVENT_SUBSCRIBE_MEMBER(m_ETankSteer, &Systems::PhysicsSystem::OnTankSteer);
+	EVENT_SUBSCRIBE_MEMBER(m_EJeepSteer, &Systems::PhysicsSystem::OnJeepSteer);
 	EVENT_SUBSCRIBE_MEMBER(m_ESetVelocity, &Systems::PhysicsSystem::OnSetVelocity);
 	EVENT_SUBSCRIBE_MEMBER(m_EApplyForce, &Systems::PhysicsSystem::OnApplyForce);
 	EVENT_SUBSCRIBE_MEMBER(m_EApplyPointImpulse, &Systems::PhysicsSystem::OnApplyPointImpulse);
@@ -274,27 +275,10 @@ void Systems::PhysicsSystem::UpdateEntity(double dt, EntityID entity, EntityID p
 	else if(m_RigidBodies.find(entity) != m_RigidBodies.end())
 	{
 		auto transformComponentParent = m_World->GetComponent<Components::Transform>(parent);
-		
-		/*	if(transformComponentParent)
-		{
-		auto absoluteTransformParent = m_World->GetSystem<Systems::TransformSystem>()->AbsoluteTransform(parent);
-		transformComponent->Position = HKVECTOR4_TO_GLMVEC3(m_RigidBodies[entity]->getPosition());
-		transformComponent->Orientation = glm::inverse(HKQUATERNION_TO_GLMQUAT(m_RigidBodies[entity]->getRotation())) * absoluteTransformParent.Orientation;
-		transformComponent->Velocity =  HKVECTOR4_TO_GLMVEC3(m_RigidBodies[entity]->getLinearVelocity());
-		}
-		else
-		{
-		auto transformComponentParent = m_World->GetComponent<Components::Transform>(parent);
-		transformComponent->Position = HKVECTOR4_TO_GLMVEC3(m_RigidBodies[entity]->getPosition());
-		transformComponent->Orientation = HKQUATERNION_TO_GLMQUAT(m_RigidBodies[entity]->getRotation());
-		transformComponent->Velocity = HKVECTOR4_TO_GLMVEC3(m_RigidBodies[entity]->getLinearVelocity());
-		}*/
-
 		transformComponent->Position = HKVECTOR4_TO_GLMVEC3(m_RigidBodies[entity]->getPosition());
 		transformComponent->Orientation = HKQUATERNION_TO_GLMQUAT(m_RigidBodies[entity]->getRotation());
 		transformComponent->Velocity = HKVECTOR4_TO_GLMVEC3(m_RigidBodies[entity]->getLinearVelocity());
 
-		// HACK: WTF IS THIS?
 		if (transformComponentParent)
 		{
 			auto absoluteTransformParent = m_World->GetSystem<Systems::TransformSystem>()->AbsoluteTransform(parent);
@@ -758,47 +742,6 @@ void HK_CALL Systems::PhysicsSystem::HavokErrorReport(const char* msg, void*)
 	LOG_INFO("%s", msg);
 }
 
-bool Systems::PhysicsSystem::OnTankSteer(const Events::TankSteer &event)
-{
-	auto vehicleComponent = m_World->GetComponent<Components::Vehicle>(event.Entity);
-	
-	if (vehicleComponent && m_Vehicles.find(event.Entity) != m_Vehicles.end() && m_RigidBodies.find(event.Entity) != m_RigidBodies.end())
-	{
-		hkpVehicleDriverInputAnalogStatus* deviceStatus = (hkpVehicleDriverInputAnalogStatus*)m_Vehicles[event.Entity]->m_deviceStatus;
-		auto transformComponent = m_World->GetComponent<Components::Transform>(event.Entity);
-		
-		float steeringX = event.PositionX;
-
-		glm::vec3 velocityNormalized = glm::normalize(HKVECTOR4_TO_GLMVEC3(m_RigidBodies[event.Entity]->getLinearVelocity()));
-		glm::vec3 forward = glm::normalize(transformComponent->Orientation * glm::vec3(0, 0, -1));
-		float dotProduct = glm::dot(forward, velocityNormalized);
-
-		if(dotProduct < 0)
-		{
-			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
-		{
-			deviceStatus->m_positionX = event.PositionX;
-			deviceStatus->m_positionY = event.PositionY;
-		}
-		
-		if(event.PositionY > 0)
-		{
-			deviceStatus->m_reverseButtonPressed = true;
-		}
-		deviceStatus->m_handbrakeButtonPressed = event.Handbrake;
-	}
-
-	return true;
-}
-
 bool Systems::PhysicsSystem::OnSetVelocity( const Events::SetVelocity &event )
 {
 	if(m_RigidBodies.find(event.Entity) != m_RigidBodies.end())
@@ -894,3 +837,66 @@ bool Systems::PhysicsSystem::OnDisableCollisions( const Events::DisableCollision
 	m_PhysicsWorld->unmarkForWrite();
 	return true;
 }
+
+
+bool Systems::PhysicsSystem::OnTankSteer(const Events::TankSteer &event)
+{
+	auto vehicleComponent = m_World->GetComponent<Components::Vehicle>(event.Entity);
+
+	if (vehicleComponent && m_Vehicles.find(event.Entity) != m_Vehicles.end() && m_RigidBodies.find(event.Entity) != m_RigidBodies.end())
+	{
+		hkpVehicleDriverInputAnalogStatus* deviceStatus = (hkpVehicleDriverInputAnalogStatus*)m_Vehicles[event.Entity]->m_deviceStatus;
+		auto transformComponent = m_World->GetComponent<Components::Transform>(event.Entity);
+
+		float steeringX = event.PositionX;
+
+		glm::vec3 velocityNormalized = glm::normalize(HKVECTOR4_TO_GLMVEC3(m_RigidBodies[event.Entity]->getLinearVelocity()));
+		glm::vec3 forward = glm::normalize(transformComponent->Orientation * glm::vec3(0, 0, -1));
+		float dotProduct = glm::dot(forward, velocityNormalized);
+
+		if(dotProduct < 0)
+		{
+			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
+		{
+			deviceStatus->m_positionX = event.PositionX;
+			deviceStatus->m_positionY = event.PositionY;
+		}
+
+		if(event.PositionY > 0)
+		{
+			deviceStatus->m_reverseButtonPressed = true;
+		}
+		deviceStatus->m_handbrakeButtonPressed = event.Handbrake;
+	}
+
+	return true;
+}
+
+
+bool Systems::PhysicsSystem::OnJeepSteer( const Events::JeepSteer &event )
+{
+	auto vehicleComponent = m_World->GetComponent<Components::Vehicle>(event.Entity);
+
+	if (vehicleComponent && m_Vehicles.find(event.Entity) != m_Vehicles.end() && m_RigidBodies.find(event.Entity) != m_RigidBodies.end())
+	{
+		hkpVehicleDriverInputAnalogStatus* deviceStatus = (hkpVehicleDriverInputAnalogStatus*)m_Vehicles[event.Entity]->m_deviceStatus;
+		deviceStatus->m_positionX = event.PositionX;
+		deviceStatus->m_positionY = event.PositionY;
+
+		if(event.PositionY > 0)
+		{
+			deviceStatus->m_reverseButtonPressed = true;
+		}
+		deviceStatus->m_handbrakeButtonPressed = event.Handbrake;
+	}
+
+	return true;
+}

src/Systems/PhysicsSystem.h

@@ -88,6 +88,7 @@
 #include "Components/Template.h"
 
 #include "Events/EnterTrigger.h"
+#include "Events/JeepSteer.h"
 
 namespace Systems
 {
@@ -178,6 +179,8 @@ private:
 	// Events
 	EventRelay<PhysicsSystem, Events::TankSteer> m_ETankSteer;
 	bool OnTankSteer(const Events::TankSteer &event);
+	EventRelay<PhysicsSystem, Events::JeepSteer> m_EJeepSteer;
+	bool OnJeepSteer(const Events::JeepSteer &event);
 	EventRelay<PhysicsSystem, Events::SetVelocity> m_ESetVelocity;
 	bool OnSetVelocity(const Events::SetVelocity &event);
 	EventRelay<PhysicsSystem, Events::ApplyForce> m_EApplyForce;

src/Systems/TankSteeringSystem.cpp

@@ -50,7 +50,6 @@ void Systems::TankSteeringSystem::UpdateEntity(double dt, EntityID entity, Entit
 	eSteering.Handbrake = inputController->Handbrake;
 	EventBroker->Publish(eSteering);
 
-
 	auto towerSteeringComponent = m_World->GetComponent<Components::TowerSteering>(tankSteeringComponent->Turret);
 	auto barrelSteeringComponent = m_World->GetComponent<Components::BarrelSteering>(tankSteeringComponent->Barrel);
 
@@ -65,7 +64,7 @@ void Systems::TankSteeringSystem::UpdateEntity(double dt, EntityID entity, Entit
 	{
 		auto tankTransform = m_World->GetComponent<Components::Transform>(entity);
 		auto transformComponent = m_World->GetComponent<Components::Transform>(tankSteeringComponent->Barrel);
-		auto absoluteTransform = m_World->GetSystem<Systems::TransformSystem>()->AbsoluteTransform(tankSteeringComponent->Barrel);
+		
 		glm::quat orientation =  glm::angleAxis(barrelSteeringComponent->TurnSpeed * inputController->BarrelDirection * (float)dt, barrelSteeringComponent->Axis);
 		transformComponent->Orientation *= orientation;
 
@@ -81,7 +80,7 @@ void Systems::TankSteeringSystem::UpdateEntity(double dt, EntityID entity, Entit
 			transformComponent->Orientation = glm::quat(angles);
 		}
 
-		
+		auto absoluteTransform = m_World->GetSystem<Systems::TransformSystem>()->AbsoluteTransform(tankSteeringComponent->Barrel);
 
 		if(inputController->Shoot && m_TimeSinceLastShot[tankSteeringComponent->Barrel] > 0.5)
 		{
@@ -138,7 +137,7 @@ void Systems::TankSteeringSystem::UpdateEntity(double dt, EntityID entity, Entit
 			auto clonePhysicsComponent = m_World->GetComponent<Components::Physics>(clone);
 			//1,670m/s
 			//25kg
-			Events::ApplyPointImpulse ePointImpulse ;
+			Events::ApplyPointImpulse ePointImpulse;
 			ePointImpulse.Entity = entity;
 			ePointImpulse.Position = absoluteTransform.Position;
 			ePointImpulse.Impulse = glm::normalize(absoluteTransform.Orientation * glm::vec3(0, 0, 1))  * clonePhysicsComponent->Mass * 6.f * 1670.f;
@@ -194,39 +193,39 @@ bool Systems::TankSteeringSystem::OnCollision(const Events::Collision &e)
 		//auto otherTransform = m_World->GetComponent<Components::Transform>(otherEntity);
 
 		{
-// 			Events::CreateExplosion e;
-// 			e.LifeTime = 3;
-// 			e.ParticleScale.push_back(8);
-// 			e.ParticlesToSpawn = 20;
-// 			e.Position = shellTransform->Position;
-// 			e.RelativeUpOrientation = glm::angleAxis(glm::pi<float>() / 2, glm::vec3(1,0,0));
-// 			e.Speed = 3;
-// 			e.SpreadAngle = glm::pi<float>();
-// 			e.spritePath = "Textures/Sprites/Smoke1.png";
-// 			e.Color = glm::vec4(0.6,0.6,0.6,1);
-// 			EventBroker->Publish(e);
-// 			e.LifeTime = 0.7;
-// 			e.ParticleScale.push_back(12);
-// 			e.ParticlesToSpawn = 10;
-// 			e.Position = shellTransform->Position;
-// 			e.RelativeUpOrientation = glm::angleAxis(glm::pi<float>() / 2, glm::vec3(1,0,0));
-// 			e.Speed = 17;
-// 			e.SpreadAngle = glm::pi<float>();
-// 			e.spritePath = "Textures/Sprites/Fire.png";
-// 			EventBroker->Publish(e);
-// 			e.LifeTime = 0.2;
-// 			e.ParticleScale.push_back(1);
-// 			e.ParticleScale.push_back(15);
-// 			e.ParticlesToSpawn = 5;
-// 			e.Position = shellTransform->Position;
-// 			e.RelativeUpOrientation = glm::angleAxis(glm::pi<float>() / 2, glm::vec3(1,0,0));
-// 			e.Speed = 6;
-// 			e.SpreadAngle = glm::pi<float>();
-// 			e.spritePath = "Textures/Sprites/Blast1.png";
-// 			e.Color = glm::vec4(2, 2, 2, 0.2);
-// 			EventBroker->Publish(e);
-			
 			Events::CreateExplosion e;
+			e.LifeTime = 3;
+			e.ParticleScale.push_back(8);
+			e.ParticlesToSpawn = 20;
+			e.Position = shellTransform->Position;
+			e.RelativeUpOrientation = glm::angleAxis(glm::pi<float>() / 2, glm::vec3(1, 0, 0));
+			e.Speed = 3;
+			e.SpreadAngle = glm::pi<float>();
+			e.spritePath = "Textures/Sprites/Smoke1.png";
+			e.Color = glm::vec4(0.6, 0.6, 0.6, 1);
+			EventBroker->Publish(e);
+			e.LifeTime = 0.7;
+			e.ParticleScale.push_back(12);
+			e.ParticlesToSpawn = 10;
+			e.Position = shellTransform->Position;
+			e.RelativeUpOrientation = glm::angleAxis(glm::pi<float>() / 2, glm::vec3(1, 0, 0));
+			e.Speed = 17;
+			e.SpreadAngle = glm::pi<float>();
+			e.spritePath = "Textures/Sprites/Fire.png";
+			EventBroker->Publish(e);
+			e.LifeTime = 0.2;
+			e.ParticleScale.push_back(1);
+			e.ParticleScale.push_back(15);
+			e.ParticlesToSpawn = 5;
+			e.Position = shellTransform->Position;
+			e.RelativeUpOrientation = glm::angleAxis(glm::pi<float>() / 2, glm::vec3(1, 0, 0));
+			e.Speed = 6;
+			e.SpreadAngle = glm::pi<float>();
+			e.spritePath = "Textures/Sprites/Blast1.png";
+			e.Color = glm::vec4(2, 2, 2, 0.2);
+			EventBroker->Publish(e);
+			
+			/*Events::CreateExplosion e;
 			e.LifeTime = 1.5;
 			e.ParticleScale.push_back(1);
 			e.ParticleScale.push_back(6);
@@ -253,7 +252,7 @@ bool Systems::TankSteeringSystem::OnCollision(const Events::Collision &e)
 			e.Speed = 12;
 			e.spritePath = "Textures/Sprites/Splash.png";
 			e.Color = glm::vec4(1.f,1.f,1.f,1);
-			EventBroker->Publish(e);
+			EventBroker->Publish(e);*/
 		}
 		{
 			Events::PlaySFX e;
@@ -263,27 +262,41 @@ bool Systems::TankSteeringSystem::OnCollision(const Events::Collision &e)
 			EventBroker->Publish(e);
 		}
 
+		// Direct damage
+		auto health = m_World->GetComponent<Components::Health>(otherEntity);
+		if (health)
+		{
+			Events::Damage d;
+			d.Entity = otherEntity;
+			d.Amount = shellComponent->Damage;
+			EventBroker->Publish(d);
+		}
+
+		// Splash damage
 		for (auto &physComponent : *physicsComponents)
 		{
-			EntityID physicsEntity = std::dynamic_pointer_cast<Components::Physics>(physComponent)->Entity;
+			EntityID physicsEntity = physComponent->Entity;
-			auto physEntityTransform = m_World->GetComponent<Components::Transform>(physicsEntity);
+			// No splash damage to the direct hit target
+			if (physicsEntity == otherEntity)
+				continue;
+			auto physEntityTransform = m_World->GetSystem<Systems::TransformSystem>()->AbsoluteTransform(physicsEntity);
 
-			float distance = glm::distance(physEntityTransform->Position, shellTransform->Position);
+			float distance = glm::distance(physEntityTransform.Position, shellTransform->Position);
 			if (distance <= shellComponent->ExplosionRadius)
 			{
 				// DO STUFF! :D
 				float radius = shellComponent->ExplosionRadius;
 				float strength = (1.f - pow(distance / radius, 2)) * shellComponent->ExplosionStrength;
-				glm::vec3 direction = glm::normalize(physEntityTransform->Position - shellTransform->Position);
+				glm::vec3 direction = glm::normalize(physEntityTransform.Position - shellTransform->Position);
 
 				Events::ApplyPointImpulse e;
 				e.Entity = physicsEntity;
 				e.Impulse = direction * strength;
-				e.Position = physEntityTransform->Position;
+				e.Position = physEntityTransform.Position;
 				EventBroker->Publish(e);
 
 				auto health = m_World->GetComponent<Components::Health>(physicsEntity);
-				if(health)
+				if (health && health->VulnerableToSplash)
 				{
 					Events::Damage d;
 					d.Entity = physicsEntity;
@@ -375,7 +388,7 @@ bool Systems::TankSteeringSystem::OnSpawnVehicle(const Events::SpawnVehicle &eve
 {
 	if (event.VehicleType != "Tank")
 		return false;
-
+	
 	auto spawnPointComponents = m_World->GetComponentsOfType<Components::SpawnPoint>();
 	if (!spawnPointComponents)
 	{
@@ -387,8 +400,15 @@ bool Systems::TankSteeringSystem::OnSpawnVehicle(const Events::SpawnVehicle &eve
 	{
 		auto spawnPoint = component->Entity;
 		auto spawnPointComponent = std::dynamic_pointer_cast<Components::SpawnPoint>(component);
-		auto playerComponent = m_World->GetComponent<Components::Player>(spawnPointComponent->Player);
+		auto teamComponent =  m_World->GetComponent<Components::Team>(spawnPoint);
-		if (!playerComponent || playerComponent->ID != event.PlayerID)
+
+		if(!teamComponent)
+		{
+			LOG_ERROR("SpawnPoint has no TeamComponent");
+			continue;
+		}
+
+		if (teamComponent->TeamID != event.PlayerID)
 			continue;
 		
 		Components::Transform absoluteTransform = m_World->GetSystem<Systems::TransformSystem>()->AbsoluteTransform(spawnPoint);
@@ -396,8 +416,8 @@ bool Systems::TankSteeringSystem::OnSpawnVehicle(const Events::SpawnVehicle &eve
 		// Create a tank
 		EntityID tank = CreateTank(event.PlayerID);
 		auto tankTransform = m_World->GetComponent<Components::Transform>(tank);
-		tankTransform->Position = absoluteTransform.Position;
+ 		tankTransform->Position = absoluteTransform.Position;
-		tankTransform->Orientation = absoluteTransform.Orientation;
+ 		tankTransform->Orientation = absoluteTransform.Orientation;
 		// Set the viewport correctly
 		Events::SetViewportCamera e;
 		e.CameraEntity = m_World->GetProperty<EntityID>(tank, "Camera");
@@ -424,6 +444,18 @@ EntityID Systems::TankSteeringSystem::CreateTank(int playerID)
 	vehicle->MaxTorque = 8000.f;
 	vehicle->MaxSteeringAngle = 90.f;
 	vehicle->MaxSpeedFullSteeringAngle = 4.f;
+	vehicle->MinRPM = 200.0f; 
+	vehicle->OptimalRPM = 2500.0f,
+	vehicle->MaxRPM = 4000.0f; 
+	vehicle->TopSpeed = 90.0f;
+	vehicle->SpringDamping = 1.f;
+	vehicle->UpshiftRPM = 3500.0f;
+	vehicle->DownshiftRPM = 1000.0f;
+	vehicle->gearsRatio0 = 3.0f;
+	vehicle->gearsRatio1 = 2.25f; 
+	vehicle->gearsRatio2 = 1.5f;
+	vehicle->gearsRatio3 = 1.0f;
+
 	auto player = m_World->AddComponent<Components::Player>(tank);
 	player->ID = playerID;
 	auto tankSteering = m_World->AddComponent<Components::TankSteering>(tank);
@@ -494,8 +526,8 @@ EntityID Systems::TankSteeringSystem::CreateTank(int playerID)
 				modelComponent->ModelFile = "Models/Placeholders/rocket/Rocket.obj";
 				auto tankShellComponent = m_World->AddComponent<Components::TankShell>(shot);
 				tankShellComponent->Damage = 20.f;
-				tankShellComponent->ExplosionRadius = 30.f;
+				tankShellComponent->ExplosionRadius = 20.f;
-				tankShellComponent->ExplosionStrength = 300000.f;
+				tankShellComponent->ExplosionStrength = 140.f;
 				{
 					auto shape = m_World->CreateEntity(shot);
 					auto transform = m_World->AddComponent<Components::Transform>(shape);

src/Systems/TankSteeringSystem.h

@@ -15,6 +15,7 @@
 #include "Components/Vehicle.h"
 #include "Components/Player.h"
 #include "Components/Model.h"
+#include "Components/Team.h"
 #include "Systems/TransformSystem.h"
 #include "Systems/ParticleSystem.h"
 #include "InputController.h"
@@ -48,6 +49,7 @@
 #include "Components/Input.h"
 
 #include "Events/SetViewportCamera.h"
+#include "Events/GameOver.h"
 
 namespace Systems
 {

src/Systems/TriggerSystem.cpp

@@ -44,10 +44,18 @@ void Systems::TriggerSystem::OnEntityRemoved( EntityID entity )
 
 bool Systems::TriggerSystem::OnEnterTrigger( const Events::EnterTrigger &event )
 {
-	
+
+	auto teamComponent = m_World->GetComponent<Components::Team>(event.Trigger);
+	auto playerComponent = m_World->GetComponent<Components::Player>(event.Entity);
+
+	if(!teamComponent || !playerComponent)
+		return false;
+	if (teamComponent->TeamID != playerComponent->ID)
+		return false;
 
 	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)
 	{
@@ -77,6 +85,17 @@ bool Systems::TriggerSystem::OnEnterTrigger( const Events::EnterTrigger &event )
 
 bool Systems::TriggerSystem::OnLeaveTrigger( const Events::LeaveTrigger &event )
 {
+	auto teamComponent = m_World->GetComponent<Components::Team>(event.Trigger);
+	auto playerComponent = m_World->GetComponent<Components::Player>(event.Entity);
+
+	if(!teamComponent || !playerComponent)
+		return false;
+	if (teamComponent->TeamID != playerComponent->ID)
+		return false;
+
+	auto flagComponent1 = m_World->GetComponent<Components::Flag>(event.Trigger);
+	auto flagComponent2 = m_World->GetComponent<Components::Flag>(event.Entity);
+
 	auto triggerMoveComponent = m_World->GetComponent<Components::TriggerMove>(event.Trigger);
 	if (triggerMoveComponent)
 	{

src/Systems/TriggerSystem.h

@@ -21,6 +21,7 @@
 #include "Components/Move.h"
 #include "Components/Rotate.h"
 #include "Components/Player.h"
+#include "Components/Team.h"
 #include "Events/Move.h"
 #include "Events/Rotate.h"
 #include <math.h>

src/Systems/WallSystem.cpp

@@ -20,6 +20,18 @@ bool Systems::WallSystem::Damage( const Events::Damage &event )
 		return false;
 	}
 	LOG_INFO("WallSystem::Damage");
+
+	// Change to damage model
+	auto modelComponent = m_World->GetComponent<Components::Model>(event.Entity);
+	auto damageModel = m_World->GetComponent<Components::DamageModel>(event.Entity);
+	if (modelComponent)
+	{
+		modelComponent->ModelFile = damageModel->ModelFile;
+		modelComponent->Color = damageModel->Color;
+		modelComponent->ShadowCaster = damageModel->ShadowCaster;
+		modelComponent->Transparent = damageModel->Transparent;
+	}
+
 	auto wallhealthcomponent = m_World->GetComponent<Components::Health>(event.Entity);
 	if(wallhealthcomponent->Amount > 0)
 	{
@@ -29,6 +41,7 @@ bool Systems::WallSystem::Damage( const Events::Damage &event )
 	//auto transformComponent = m_World->GetComponent<Components::Transform>(event.Entity);
 	Components::Transform transformComponent = m_World->GetSystem<Systems::TransformSystem>()->AbsoluteTransform(event.Entity);
 
+	// Spawn debris
 	for(auto d : wallComponent->Walldebris)
 	{
 		auto debris = m_World->CloneEntity(d);

src/Systems/WallSystem.h

@@ -8,6 +8,7 @@
 #include "Events/Damage.h"
 #include "Events/ApplyPointImpulse.h"
 #include "Components/Model.h"
+#include "Components/DamageModel.h"
 #include "Components/Wall.h"
 #include "Components/Transform.h"
 #include "Components/Physics.h"

vs11/Returngeance/Returngeance.vcxproj

@@ -109,10 +109,12 @@
     <ClCompile Include="..\..\src\ShaderProgram.cpp" />
     <ClCompile Include="..\..\src\Skybox.cpp" />
     <ClCompile Include="..\..\src\Sound.cpp" />
+    <ClCompile Include="..\..\src\Systems\JeepSteeringSystem.cpp" />
     <ClCompile Include="..\..\src\Systems\DamageSystem.cpp" />
     <ClCompile Include="..\..\src\Systems\DebugSystem.cpp" />
     <ClCompile Include="..\..\src\Systems\FollowSystem.cpp" />
     <ClCompile Include="..\..\src\Systems\FreeSteeringSystem.cpp" />
+    <ClCompile Include="..\..\src\Systems\GameStateSystem.cpp" />
     <ClCompile Include="..\..\src\Systems\GarageSystem.cpp" />
     <ClCompile Include="..\..\src\Systems\HelicopterSteeringSystem.cpp" />
     <ClCompile Include="..\..\src\Systems\InputSystem.cpp" />
@@ -138,14 +140,17 @@
     <ClInclude Include="..\..\src\Components\BlendMap.h" />
     <ClInclude Include="..\..\src\Components\BoxShape.h" />
     <ClInclude Include="..\..\src\Components\Camera.h" />
+    <ClInclude Include="..\..\src\Components\DamageModel.h" />
     <ClInclude Include="..\..\src\Components\DirectionalLight.h" />
     <ClInclude Include="..\..\src\Components\Flag.h" />
     <ClInclude Include="..\..\src\Components\Follow.h" />
     <ClInclude Include="..\..\src\Components\FrameTimer.h" />
     <ClInclude Include="..\..\src\Components\Garage.h" />
+    <ClInclude Include="..\..\src\Components\JeepSteering.h" />
     <ClInclude Include="..\..\src\Components\Move.h" />
     <ClInclude Include="..\..\src\Components\Rotate.h" />
     <ClInclude Include="..\..\src\Components\Tower.h" />
+    <ClInclude Include="..\..\src\Components\Team.h" />
     <ClInclude Include="..\..\src\Components\TriggerMove.h" />
     <ClInclude Include="..\..\src\Components\Timer.h" />
     <ClInclude Include="..\..\src\Components\TriggerExplosion.h" />
@@ -196,9 +201,16 @@
     <ClInclude Include="..\..\src\Events\Damage.h" />
     <ClInclude Include="..\..\src\Events\DisableCollisions.h" />
     <ClInclude Include="..\..\src\Events\EnableCollisions.h" />
+    <ClInclude Include="..\..\src\Events\FlagCaptured.h" />
+    <ClInclude Include="..\..\src\Events\FlagDropped.h" />
+    <ClInclude Include="..\..\src\Events\FlagPickup.h" />
+    <ClInclude Include="..\..\src\Events\FlagReturned.h" />
+    <ClInclude Include="..\..\src\Events\GameOver.h" />
     <ClInclude Include="..\..\src\Events\GamepadAxis.h" />
     <ClInclude Include="..\..\src\Events\GamepadButton.h" />
+    <ClInclude Include="..\..\src\Events\GameStart.h" />
     <ClInclude Include="..\..\src\Events\InputCommand.h" />
+    <ClInclude Include="..\..\src\Events\JeepSteer.h" />
     <ClInclude Include="..\..\src\Events\KeyDown.h" />
     <ClInclude Include="..\..\src\Events\KeyUp.h" />
     <ClInclude Include="..\..\src\Events\LeaveTrigger.h" />
@@ -222,7 +234,9 @@
     <ClInclude Include="..\..\src\GUI\Frame.h" />
     <ClInclude Include="..\..\src\EventBroker.h" />
     <ClInclude Include="..\..\src\GUI\GameFrame.h" />
+    <ClInclude Include="..\..\src\GUI\GameOverFrame.h" />
     <ClInclude Include="..\..\src\GUI\HealthOverlay.h" />
+    <ClInclude Include="..\..\src\GUI\MainMenuFrame.h" />
     <ClInclude Include="..\..\src\GUI\PlayerHUD.h" />
     <ClInclude Include="..\..\src\GUI\VehicleSelection.h" />
     <ClInclude Include="..\..\src\GUI\WorldFrame.h" />
@@ -241,10 +255,12 @@
     <ClInclude Include="..\..\src\Skybox.h" />
     <ClInclude Include="..\..\src\Sound.h" />
     <ClInclude Include="..\..\src\System.h" />
+    <ClInclude Include="..\..\src\Systems\JeepSteeringSystem.h" />
     <ClInclude Include="..\..\src\Systems\DamageSystem.h" />
     <ClInclude Include="..\..\src\Systems\DebugSystem.h" />
     <ClInclude Include="..\..\src\Systems\FollowSystem.h" />
     <ClInclude Include="..\..\src\Systems\FreeSteeringSystem.h" />
+    <ClInclude Include="..\..\src\Systems\GameStateSystem.h" />
     <ClInclude Include="..\..\src\Systems\GarageSystem.h" />
     <ClInclude Include="..\..\src\Systems\HelicopterSteeringSystem.h" />
     <ClInclude Include="..\..\src\Systems\InputSystem.h" />

vs11/Returngeance/Returngeance.vcxproj.filters

@@ -74,7 +74,6 @@
     <ClCompile Include="..\..\src\Systems\DamageSystem.cpp">
       <Filter>Game\Systems</Filter>
     </ClCompile>
-    <ClCompile Include="..\..\src\Systems\WheelPairSystem.cpp" />
     <ClCompile Include="..\..\src\Systems\FollowSystem.cpp">
       <Filter>Game\Systems</Filter>
     </ClCompile>
@@ -84,10 +83,22 @@
     <ClCompile Include="..\..\src\Sound.cpp">
       <Filter>Audio</Filter>
     </ClCompile>
+    <ClCompile Include="..\..\src\Systems\JeepSteeringSystem.cpp">
+      <Filter>Physics\Systems</Filter>
+    </ClCompile>
     <ClCompile Include="..\..\src\Systems\WallSystem.cpp">
       <Filter>Game\Systems</Filter>
     </ClCompile>
     <ClCompile Include="..\..\src\Systems\TowerSystem.cpp">
+     <Filter>Game\Systems</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\Systems\GameStateSystem.cpp">
+      <Filter>Game\Systems</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\Systems\WheelPairSystem.cpp">
+      <Filter>Physics\Systems</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\Systems\WallSystem.cpp">
       <Filter>Game\Systems</Filter>
     </ClCompile>
   </ItemGroup>
@@ -589,6 +600,55 @@
     </ClInclude>
     <ClInclude Include="..\..\src\Components\TurretShot.h">
       <Filter>Physics\Components</Filter>
+    <ClInclude Include="..\..\src\Components\Team.h">
+      <Filter>Game\Components</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\Systems\JeepSteeringSystem.h">
+      <Filter>Physics\Systems</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\Events\OnDead.h" />
+    <ClInclude Include="..\..\src\Systems\WallSystem.h" />
+    <ClInclude Include="..\..\src\GUI\GameOverFrame.h">
+      <Filter>GUI</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\Systems\GameStateSystem.h">
+      <Filter>Game\Systems</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\Events\FlagPickup.h">
+      <Filter>Game\Events</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\Events\FlagCaptured.h">
+      <Filter>Game\Events</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\Events\FlagDropped.h">
+      <Filter>Game\Events</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\Events\FlagReturned.h">
+      <Filter>Game\Events</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\Events\GameOver.h">
+      <Filter>Game\Events</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\GUI\MainMenuFrame.h">
+      <Filter>GUI</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\Events\GameStart.h">
+      <Filter>Game\Events</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\Events\OnDead.h">
+      <Filter>Game\Events</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\Events\JeepSteer.h">
+      <Filter>Physics\Events</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\Components\JeepSteering.h">
+      <Filter>Physics\Components</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\Systems\WallSystem.h">
+      <Filter>Game\Systems</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\Components\DamageModel.h">
+      <Filter>Rendering\Components</Filter>
     </ClInclude>
   </ItemGroup>
   <ItemGroup>