diff --git a/assets b/assets
index 5357a0c..5d9a060 160000
--- a/assets
+++ b/assets
@@ -1 +1 @@
-Subproject commit 5357a0c4e1020317bb8745a057d6da62ab6c6504
+Subproject commit 5d9a060c492d62593435891c817de98ad6abdef7
diff --git a/src/Components/DamageModel.h b/src/Components/DamageModel.h
new file mode 100644
index 0000000..6e34cf9
--- /dev/null
+++ b/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__
\ No newline at end of file
diff --git a/src/Components/Health.h b/src/Components/Health.h
index ca8daee..c52fae2 100644
--- a/src/Components/Health.h
+++ b/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); }
 	};
diff --git a/src/Components/JeepSteering.h b/src/Components/JeepSteering.h
new file mode 100644
index 0000000..763745f
--- /dev/null
+++ b/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__
\ No newline at end of file
diff --git a/src/Components/SpawnPoint.h b/src/Components/SpawnPoint.h
index 74aaaf9..c29230d 100644
--- a/src/Components/SpawnPoint.h
+++ b/src/Components/SpawnPoint.h
@@ -8,8 +8,6 @@ namespace Components
 
 struct SpawnPoint : Component
 {
-	EntityID Player;
-
 	virtual SpawnPoint* Clone() const override { return new SpawnPoint(*this); }
 };
 
diff --git a/src/Components/Team.h b/src/Components/Team.h
new file mode 100644
index 0000000..6bbf105
--- /dev/null
+++ b/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__
\ No newline at end of file
diff --git a/src/Components/Trigger.h b/src/Components/Trigger.h
index ec7cfc4..6373259 100644
--- a/src/Components/Trigger.h
+++ b/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); }
 	};
 
diff --git a/src/Components/Vehicle.h b/src/Components/Vehicle.h
index 431d7b4..b8705e8 100644
--- a/src/Components/Vehicle.h
+++ b/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),
-	MaxSpeedFullSteeringAngle(40.0f), SpringDamping(1.f), UpshiftRPM(5500.0f), DownshiftRPM(1000.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(3500.0f), DownshiftRPM(1000.0f),
 	gearsRatio0(3.0f), gearsRatio1(2.25f), gearsRatio2(1.5f), gearsRatio3(1.0f), currentRPM(0.0f){ }
 	float MaxTorque;
 	float MinRPM;
diff --git a/src/Events/JeepSteer.h b/src/Events/JeepSteer.h
new file mode 100644
index 0000000..03189ec
--- /dev/null
+++ b/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__
\ No newline at end of file
diff --git a/src/GameWorld.cpp b/src/GameWorld.cpp
index 55bb69c..067bada 100755
--- a/src/GameWorld.cpp
+++ b/src/GameWorld.cpp
@@ -50,6 +50,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);
@@ -411,7 +413,6 @@ void GameWorld::Initialize()
 		}
 		CommitEntity(gateBase);
 	}
-
 }
 
 void GameWorld::Update(double dt)
@@ -427,6 +428,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()
@@ -442,6 +444,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); });
@@ -465,6 +468,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>();
@@ -511,7 +515,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);
@@ -618,9 +622,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);
@@ -651,9 +657,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);
@@ -667,126 +676,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()
 {
 	{
@@ -841,6 +730,21 @@ void GameWorld::CreateTerrain()
 		CommitEntity(groundshape);
 		}
 		CommitEntity(water);*/
+
+		{
+			auto water = CreateEntity();
+			auto transform = AddComponent<Components::Transform>(water);
+
+			{
+				auto waves = CreateEntity(water);
+				auto transform = AddComponent<Components::Transform>(water);
+				auto model = AddComponent<Components::Model>(water);
+				model->ModelFile = "Models/Water/Waves.obj";
+				CommitEntity(waves);
+			}
+
+			CommitEntity(water);
+		}
 	}
 
 	{
@@ -872,8 +776,16 @@ void GameWorld::CreateTerrain()
 		CommitEntity(ground_middle);
 	}
 
+	{
+		auto decoration_middle = CreateEntity();
+		auto transform = AddComponent<Components::Transform>(decoration_middle);
+		auto model = AddComponent<Components::Model>(decoration_middle);
+		model->ModelFile = "Models/TerrainFiveIstles/Decoration/Middle.obj";
+		CommitEntity(decoration_middle);
+	}
+
 	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();
@@ -942,12 +854,13 @@ 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);
 	transform->Orientation = orientation;
 #pragma region Terrain
+
 	{
 		auto ground_small = CreateEntity(base);
 		auto transform = AddComponent<Components::Transform>(ground_small);
@@ -976,6 +889,14 @@ void GameWorld::CreateBase(glm::quat orientation, int playerID)
 		CommitEntity(ground_small);
 	}
 
+	{
+		auto decoration_small = CreateEntity(base);
+		auto transform = AddComponent<Components::Transform>(decoration_small);
+		auto model = AddComponent<Components::Model>(decoration_small);
+		model->ModelFile = "Models/TerrainFiveIstles/Decoration/Small.obj";
+		CommitEntity(decoration_small);
+	}
+
 	{
 		auto road_small = CreateEntity(base);
 		auto transform = AddComponent<Components::Transform>(road_small);
@@ -1008,14 +929,117 @@ void GameWorld::CreateBase(glm::quat orientation, int playerID)
 
 		{
 			auto shape = CreateEntity(bridge_middle);
-			auto transformshape = AddComponent<Components::Transform>(shape);
-			auto meshShape = AddComponent<Components::MeshShape>(shape);
-			meshShape->ResourceName = "Models/TerrainFiveIstles/Bridges/MiddleBridgeCollision.obj";
+			auto transform = AddComponent<Components::Transform>(shape);
+			transform->Position = glm::vec3(70.31883f, 26.42735f, 0.50379f);
+			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);
 	}
 
+	// Banners
+	std::string bannerModel = "Models/Banner/Blue/Blue.obj";
+	if (teamID == 2)
+	{
+		bannerModel = "Models/Banner/Red/Red.obj";
+	}
+
+	{
+		auto banner = CreateEntity(base);
+		auto transform = AddComponent<Components::Transform>(banner);
+		transform->Position = glm::vec3(70.2f, 50.36f, -8.68f);
+		transform->Orientation = glm::quat(glm::vec3(0, glm::pi<float>(), 0));
+		auto model = AddComponent<Components::Model>(banner);
+		model->ModelFile = bannerModel;
+		model->Transparent = true;
+		CommitEntity(banner);
+	}
+	{
+		auto banner = CreateEntity(base);
+		auto transform = AddComponent<Components::Transform>(banner);
+		transform->Position = glm::vec3(70.2f, 50.36f, 9.86f);
+		transform->Orientation = glm::quat(glm::vec3(0, glm::pi<float>(), 0));
+		auto model = AddComponent<Components::Model>(banner);
+		model->ModelFile = bannerModel;
+		model->Transparent = true;
+		CommitEntity(banner);
+	}
+	{
+		auto banner = CreateEntity(base);
+		auto transform = AddComponent<Components::Transform>(banner);
+		transform->Position = glm::vec3(166.17f, 49.711f, -8.68f);
+		transform->Orientation = glm::quat(glm::vec3(0, glm::pi<float>(), 0));
+		auto model = AddComponent<Components::Model>(banner);
+		model->ModelFile = bannerModel;
+		model->Transparent = true;
+		CommitEntity(banner);
+	}
+	{
+		auto banner = CreateEntity(base);
+		auto transform = AddComponent<Components::Transform>(banner);
+		auto model = AddComponent<Components::Model>(banner);
+		transform->Position = glm::vec3(166.17f, 49.711f, 9.86f);
+		transform->Orientation = glm::quat(glm::vec3(0, glm::pi<float>(), 0));
+		model->ModelFile = bannerModel;
+		model->Transparent = true;
+		CommitEntity(banner);
+	}
+
+
 	{
 		auto terrain_base = CreateEntity(base);
 		auto transform = AddComponent<Components::Transform>(terrain_base);
@@ -1064,6 +1088,14 @@ void GameWorld::CreateBase(glm::quat orientation, int playerID)
 		CommitEntity(ground_base);
 	}
 
+	{
+		auto decoration_base = CreateEntity(base);
+		auto transform = AddComponent<Components::Transform>(decoration_base);
+		auto model = AddComponent<Components::Model>(decoration_base);
+		model->ModelFile = "Models/TerrainFiveIstles/Decoration/Base.obj";
+		CommitEntity(decoration_base);
+	}
+
 	{
 		auto road_base = CreateEntity(base);
 		auto transform = AddComponent<Components::Transform>(road_base);
@@ -1096,37 +1128,124 @@ void GameWorld::CreateBase(glm::quat orientation, int playerID)
 
 		{
 			auto shape = CreateEntity(bridge_base);
-			auto transformshape = AddComponent<Components::Transform>(shape);
-			auto meshShape = AddComponent<Components::MeshShape>(shape);
-			meshShape->ResourceName = "Models/TerrainFiveIstles/Bridges/BaseBridge.obj";
+			auto transform = AddComponent<Components::Transform>(shape);
+			transform->Position = glm::vec3(166.19089f, 25.99645f, -0.50379f);
+			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)));
-	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)));
-	//CreateWall(base, glm::vec3(273.f, 40.3f, -25.f), glm::quat(glm::vec3(0, glm::pi<float>() / 2.f, 0)));
-	//CreateWall(base, glm::vec3(273.f, 40.3f, -15.f), glm::quat(glm::vec3(0, glm::pi<float>() / 2.f, 0)));
-	//CreateWall(base, glm::vec3(273.f, 40.3f, 15.f), glm::quat(glm::vec3(0, glm::pi<float>() / 2.f, 0)));
-	//CreateWall(base, glm::vec3(273.f, 40.3f, 25.f), glm::quat(glm::vec3(0, glm::pi<float>() / 2.f, 0)));
+	// Small island
+	CreateGate(base, glm::vec3(113.59f, 29.02f, 0.32f), glm::quat(glm::vec3(0, glm::pi<float>() / 2.f, 0)), teamID);
+	// Z
+	glm::quat yawRot = glm::angleAxis(glm::pi<float>() / 2.f, glm::vec3(0, 1, 0));
+	CreateWall(base, glm::vec3(113.59f, 28.79635f, 15.26201f), yawRot); // glm::quat(glm::vec3(glm::radians<float>(-9.21f), 0, 0)));
+	CreateWall(base, glm::vec3(113.60f, 28.05425f, 24.41458f), glm::angleAxis(glm::radians<float>(9.21f), glm::vec3(1, 0, 0)) * yawRot);
+	CreateWall(base, glm::vec3(113.61f, 25.42271f, 32.34383f), glm::angleAxis(glm::radians<float>(27.f), glm::vec3(1, 0, 0)) * yawRot);
+	CreateWall(base, glm::vec3(113.62f, 20.54767f, 38.68277f), glm::angleAxis(glm::radians<float>(47.9f), glm::vec3(1, 0, 0)) * yawRot);
+	// -Z
+	CreateWall(base, glm::vec3(113.59f, 28.734f, -13.85581f), glm::angleAxis(glm::radians<float>(-3.634f), glm::vec3(1, 0, 0)) * yawRot);
+	CreateWall(base, glm::vec3(113.60f, 27.166f, -22.438f), glm::angleAxis(glm::radians<float>(-17.202f), glm::vec3(1, 0, 0)) * yawRot);
+	CreateWall(base, glm::vec3(113.61f, 23.5952f, -30.50557f), glm::angleAxis(glm::radians<float>(-30.638f), glm::vec3(1, 0, 0)) * yawRot);
+	CreateWall(base, glm::vec3(113.62f, 18.30851f, -36.56623f), glm::angleAxis(glm::radians<float>(-51.542f), glm::vec3(1, 0, 0)) * yawRot);
 
-	CreateGarage(base, glm::vec3(323.2f, 41.4f, -10.2f), glm::quat(glm::vec3(0, glm::pi<float>() / 2.f, 0)), playerID);
+	// -X
+	CreateGate(base, glm::vec3(273.f, 40.185f, 0.f), 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)));
+	CreateWall(base, glm::vec3(273.f, 40.3f, -25.f), glm::quat(glm::vec3(0, glm::pi<float>() / 2.f, 0)));
+	CreateWall(base, glm::vec3(273.f, 40.3f, -15.f), glm::quat(glm::vec3(0, glm::pi<float>() / 2.f, 0)));
+	CreateWall(base, glm::vec3(273.f, 40.3f, 15.f), glm::quat(glm::vec3(0, glm::pi<float>() / 2.f, 0)));
+	CreateWall(base, glm::vec3(273.f, 40.3f, 25.f), glm::quat(glm::vec3(0, glm::pi<float>() / 2.f, 0)));
+
+	// -Z
+	CreateWall(base, glm::vec3(280.f, 40.3f, -62.f), glm::quat(glm::vec3(0, 0, 0)));
+	CreateWall(base, glm::vec3(290.f, 40.3f, -62.f), glm::quat(glm::vec3(0, 0, 0)));
+	CreateWall(base, glm::vec3(300.f, 40.3f, -62.f), glm::quat(glm::vec3(0, 0, 0)));
+	CreateWall(base, glm::vec3(310.f, 40.3f, -62.f), glm::quat(glm::vec3(0, 0, 0)));
+	CreateWall(base, glm::vec3(320.f, 40.3f, -62.f), glm::quat(glm::vec3(0, 0, 0)));
+	CreateWall(base, glm::vec3(330.f, 40.3f, -62.f), glm::quat(glm::vec3(0, 0, 0)));
+	CreateWall(base, glm::vec3(340.f, 40.3f, -62.f), glm::quat(glm::vec3(0, 0, 0)));
+	CreateWall(base, glm::vec3(350.f, 40.3f, -62.f), glm::quat(glm::vec3(0, 0, 0)));
+
+	// X
+	CreateWall(base, glm::vec3(357.f, 40.3f, -55.f), glm::quat(glm::vec3(0, glm::pi<float>() / 2.f, 0)));
+	CreateWall(base, glm::vec3(357.f, 40.3f, -45.f), glm::quat(glm::vec3(0, glm::pi<float>() / 2.f, 0)));
+	CreateWall(base, glm::vec3(357.f, 40.3f, -35.f), glm::quat(glm::vec3(0, glm::pi<float>() / 2.f, 0)));
+	CreateWall(base, glm::vec3(357.f, 40.3f, -25.f), glm::quat(glm::vec3(0, glm::pi<float>() / 2.f, 0)));
+	CreateWall(base, glm::vec3(357.f, 40.3f, -15.f), glm::quat(glm::vec3(0, glm::pi<float>() / 2.f, 0)));
+	CreateWall(base, glm::vec3(357.f, 40.3f, -5.f), glm::quat(glm::vec3(0, glm::pi<float>() / 2.f, 0)));
+	CreateWall(base, glm::vec3(357.f, 40.3f, 5.f), glm::quat(glm::vec3(0, glm::pi<float>() / 2.f, 0)));
+	CreateWall(base, glm::vec3(357.f, 40.3f, 15.f), glm::quat(glm::vec3(0, glm::pi<float>() / 2.f, 0)));
+	CreateWall(base, glm::vec3(357.f, 40.3f, 25.f), glm::quat(glm::vec3(0, glm::pi<float>() / 2.f, 0)));
+
+	// Z
+	CreateWall(base, glm::vec3(280.f, 40.3f, 32.f), glm::quat(glm::vec3(0, 0, 0)));
+	CreateWall(base, glm::vec3(290.f, 40.3f, 32.f), glm::quat(glm::vec3(0, 0, 0)));
+	CreateWall(base, glm::vec3(300.f, 40.3f, 32.f), glm::quat(glm::vec3(0, 0, 0)));
+	CreateWall(base, glm::vec3(310.f, 40.3f, 32.f), glm::quat(glm::vec3(0, 0, 0)));
+	CreateWall(base, glm::vec3(320.f, 40.3f, 32.f), glm::quat(glm::vec3(0, 0, 0)));
+	CreateWall(base, glm::vec3(330.f, 40.3f, 32.f), glm::quat(glm::vec3(0, 0, 0)));
+	CreateWall(base, glm::vec3(340.f, 40.3f, 32.f), glm::quat(glm::vec3(0, 0, 0)));
+	CreateWall(base, glm::vec3(350.f, 40.3f, 32.f), glm::quat(glm::vec3(0, 0, 0)));
+
+	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);
@@ -1238,7 +1357,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);
 	}
@@ -1256,6 +1376,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);
@@ -1275,6 +1398,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);
diff --git a/src/GameWorld.h b/src/GameWorld.h
index ef91887..85539ca 100755
--- a/src/GameWorld.h
+++ b/src/GameWorld.h
@@ -24,11 +24,13 @@
 #include "Systems/FollowSystem.h"
 #include "Systems/WallSystem.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"
@@ -56,6 +58,7 @@
 #include "Components/TriggerRotate.h"
 #include "Components/Move.h"
 #include "Components/Rotate.h"
+#include "Components/Team.h"
 
 class GameWorld : public World
 {
@@ -78,11 +81,11 @@ 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 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;
diff --git a/src/Physics/VehicleSetup.cpp b/src/Physics/VehicleSetup.cpp
index 893ced8..d06f4ba 100644
--- a/src/Physics/VehicleSetup.cpp
+++ b/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 
diff --git a/src/Systems/DamageSystem.cpp b/src/Systems/DamageSystem.cpp
index 53be57c..ffbce89 100644
--- a/src/Systems/DamageSystem.cpp
+++ b/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()
diff --git a/src/Systems/DamageSystem.h b/src/Systems/DamageSystem.h
index a77a600..2b1a43a 100644
--- a/src/Systems/DamageSystem.h
+++ b/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"
 
diff --git a/src/Systems/GarageSystem.cpp b/src/Systems/GarageSystem.cpp
index d019b27..9d805c5 100644
--- a/src/Systems/GarageSystem.cpp
+++ b/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 triggerPlayerComponent = m_World->GetComponent<Components::Player>(triggerBaseParent);
+			auto triggerTeamComponent = m_World->GetComponent<Components::Team>(trigger);
+			if (!triggerTeamComponent)
+				continue;
 
 			for (EntityID entity : entities)
 			{
-				auto entityPlayerComponent = m_World->GetComponent<Components::Player>(triggerBaseParent);
-				if (triggerPlayerComponent == entityPlayerComponent)
+				auto entityPlayerComponent = m_World->GetComponent<Components::Player>(entity);
+				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);
diff --git a/src/Systems/GarageSystem.h b/src/Systems/GarageSystem.h
index aca5673..af0f4cf 100644
--- a/src/Systems/GarageSystem.h
+++ b/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
 {
diff --git a/src/Systems/JeepSteeringSystem.cpp b/src/Systems/JeepSteeringSystem.cpp
new file mode 100644
index 0000000..0121a43
--- /dev/null
+++ b/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;
+}
+
diff --git a/src/Systems/JeepSteeringSystem.h b/src/Systems/JeepSteeringSystem.h
new file mode 100644
index 0000000..9ece58b
--- /dev/null
+++ b/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;
+	};
+}
\ No newline at end of file
diff --git a/src/Systems/PhysicsSystem.cpp b/src/Systems/PhysicsSystem.cpp
index 4633ace..df38881 100644
--- a/src/Systems/PhysicsSystem.cpp
+++ b/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);
@@ -275,27 +276,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);
@@ -759,47 +743,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())
@@ -895,3 +838,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;
+}
diff --git a/src/Systems/PhysicsSystem.h b/src/Systems/PhysicsSystem.h
index a1df46a..cdfac8a 100644
--- a/src/Systems/PhysicsSystem.h
+++ b/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;
diff --git a/src/Systems/TankSteeringSystem.cpp b/src/Systems/TankSteeringSystem.cpp
index dec2d67..b384840 100644
--- a/src/Systems/TankSteeringSystem.cpp
+++ b/src/Systems/TankSteeringSystem.cpp
@@ -76,7 +76,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);
 
@@ -91,7 +90,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;
 
@@ -107,7 +106,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)
 		{
@@ -164,7 +163,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;
@@ -216,6 +215,36 @@ bool Systems::TankSteeringSystem::OnCollision(const Events::Collision &e)
 			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.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>();
@@ -241,7 +270,7 @@ bool Systems::TankSteeringSystem::OnCollision(const Events::Collision &e)
 			e.SpreadAngle = glm::pi<float>();
 			e.spritePath = "Textures/Sprites/Blast1.png";
 			e.Color = glm::vec4(2, 2, 2, 0.2);
-			EventBroker->Publish(e);
+			EventBroker->Publish(e);*/
 			
 // 			Events::CreateExplosion e;
 // 			e.LifeTime = 1.5;
@@ -280,27 +309,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;
-			auto physEntityTransform = m_World->GetComponent<Components::Transform>(physicsEntity);
+			EntityID physicsEntity = physComponent->Entity;
+			// 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;
@@ -392,7 +435,7 @@ bool Systems::TankSteeringSystem::OnSpawnVehicle(const Events::SpawnVehicle &eve
 {
 	if (event.VehicleType != "Tank")
 		return false;
-
+	
 	auto spawnPointComponents = m_World->GetComponentsOfType<Components::SpawnPoint>();
 	if (!spawnPointComponents)
 	{
@@ -404,8 +447,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);
-		if (!playerComponent || playerComponent->ID != event.PlayerID)
+		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);
@@ -413,8 +463,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->Orientation = absoluteTransform.Orientation;
+ 		tankTransform->Position = absoluteTransform.Position;
+ 		tankTransform->Orientation = absoluteTransform.Orientation;
 		// Set the viewport correctly
 		Events::SetViewportCamera e;
 		e.CameraEntity = m_World->GetProperty<EntityID>(tank, "Camera");
@@ -441,6 +491,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);
@@ -515,8 +577,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->ExplosionStrength = 300000.f;
+				tankShellComponent->ExplosionRadius = 20.f;
+				tankShellComponent->ExplosionStrength = 140.f;
 				{
 					auto shape = m_World->CreateEntity(shot);
 					auto transform = m_World->AddComponent<Components::Transform>(shape);
diff --git a/src/Systems/TankSteeringSystem.h b/src/Systems/TankSteeringSystem.h
index c4f24c4..61fb19a 100644
--- a/src/Systems/TankSteeringSystem.h
+++ b/src/Systems/TankSteeringSystem.h
@@ -14,6 +14,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"
diff --git a/src/Systems/TriggerSystem.cpp b/src/Systems/TriggerSystem.cpp
index b6fbe65..b087354 100644
--- a/src/Systems/TriggerSystem.cpp
+++ b/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)
 	{
diff --git a/src/Systems/TriggerSystem.h b/src/Systems/TriggerSystem.h
index d158557..8891c9e 100644
--- a/src/Systems/TriggerSystem.h
+++ b/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>
diff --git a/src/Systems/WallSystem.cpp b/src/Systems/WallSystem.cpp
index 73f1eaa..c9d794b 100644
--- a/src/Systems/WallSystem.cpp
+++ b/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);
diff --git a/src/Systems/WallSystem.h b/src/Systems/WallSystem.h
index 84e5972..6dbdea6 100644
--- a/src/Systems/WallSystem.h
+++ b/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"
diff --git a/vs11/Returngeance/Returngeance.vcxproj b/vs11/Returngeance/Returngeance.vcxproj
index 8329afb..eddc0a6 100755
--- a/vs11/Returngeance/Returngeance.vcxproj
+++ b/vs11/Returngeance/Returngeance.vcxproj
@@ -109,6 +109,7 @@
     <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" />
@@ -138,13 +139,16 @@
     <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\Team.h" />
     <ClInclude Include="..\..\src\Components\TriggerMove.h" />
     <ClInclude Include="..\..\src\Components\Timer.h" />
     <ClInclude Include="..\..\src\Components\TriggerExplosion.h" />
@@ -202,6 +206,7 @@
     <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" />
@@ -246,6 +251,7 @@
     <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" />
diff --git a/vs11/Returngeance/Returngeance.vcxproj.filters b/vs11/Returngeance/Returngeance.vcxproj.filters
index 622a11b..fdba40d 100755
--- a/vs11/Returngeance/Returngeance.vcxproj.filters
+++ b/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,8 +83,18 @@
     <ClCompile Include="..\..\src\Sound.cpp">
       <Filter>Audio</Filter>
     </ClCompile>
-    <ClCompile Include="..\..\src\Systems\WallSystem.cpp" />
-    <ClCompile Include="..\..\src\Systems\GameStateSystem.cpp" />
+    <ClCompile Include="..\..\src\Systems\JeepSteeringSystem.cpp">
+      <Filter>Physics\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>
   <ItemGroup>
     <Filter Include="Util">
@@ -570,6 +579,12 @@
     <ClInclude Include="..\..\src\Components\SpawnPoint.h">
       <Filter>Game\Components</Filter>
     </ClInclude>
+    <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">
@@ -599,6 +614,21 @@
     <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>
     <ClInclude Include="..\..\src\Events\OnDead.h" />
     <ClInclude Include="..\..\src\Systems\WallSystem.h" />
   </ItemGroup>