Updated submodule remotes to something more manageable and accessible.

Conflicts:
	src/Systems/PhysicsSystem.cpp

.gitmodules

@@ -1,4 +1,4 @@
 [submodule "assets"]
 	path = assets
-	url = returngeance@shard.imon.nu:Assets
+	url = https://imon.nu/git/BTH/FishTanks-assets.git
 	branch = master

src/Components/ParticleEmitter.h

@@ -21,7 +21,7 @@ struct ParticleEmitter : Component
 		, LifeTime(0)
 		, TimeSinceLastSpawn(100)
 		, Emitting(false)
-		, Color(glm::vec4(0)) { } 
+		, Color(glm::vec4(1)) { } 
 
 	EntityID ParticleTemplate;
 	float SpawnFrequency;

src/Components/TowerDebris.h

@@ -0,0 +1,20 @@
+#ifndef Components_TowerDebris_h__
+#define Components_TowerDebris_h__
+
+#include "Component.h"
+#include <string>
+#include <vector>
+
+namespace Components
+{
+
+	struct TowerDebris : Component
+	{
+		std::vector<EntityID> TowerDebrisIDs;
+
+		virtual TowerDebris* Clone() const override { return new TowerDebris(*this); }
+	};
+
+}
+
+#endif // Components_TowerDebris_h__

src/Components/Vehicle.h

@@ -12,7 +12,7 @@ struct Vehicle : Component
 	Vehicle()
 		: 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){ }
+	gearsRatio0(3.0f), gearsRatio1(2.25f), gearsRatio2(1.5f), gearsRatio3(1.0f), currentRPM(0.0f){ }
 	float MaxTorque;
 	float MinRPM;
 	float OptimalRPM;
@@ -29,6 +29,7 @@ struct Vehicle : Component
 	float gearsRatio1;
 	float gearsRatio2;
 	float gearsRatio3;
+	float currentRPM;
 
 	Vehicle* Clone() const override { return new Vehicle(*this); }
 };

src/Events/CreateExplosion.h

@@ -11,6 +11,7 @@ namespace Events
 	{
 		CreateExplosion() : 
 			Color(glm::vec4(0)), 
+			usePointLight(false), 
 			UseGoalVector(false) {}
 
 		glm::vec3 Position;
@@ -21,6 +22,7 @@ namespace Events
 		glm::quat RelativeUpOrientation;
 		float Speed;
 		float SpreadAngle;
+		float usePointLight;
 		std::vector<float> ParticleScale;
 		bool UseGoalVector;
 		glm::vec3 GoalVelocity;

src/Events/Dead.h

@@ -0,0 +1,16 @@
+#ifndef Events_Dead_h__
+#define Events_Dead_h__
+#include "Entity.h"
+#include "EventBroker.h"
+
+namespace Events
+{
+	struct Dead : Event
+	{
+		EntityID Entity;
+	};
+}
+
+
+
+#endif // Events_Dead_h__

src/Events/FlagCaptured.h

@@ -8,7 +8,7 @@ namespace Events
 {
 	struct FlagCaptured : Event
 	{
-		EntityID Player;
+		unsigned int Player;
 	};
 }
 

src/Events/FlagDropped.h

@@ -8,7 +8,7 @@ namespace Events
 {
 	struct FlagDropped : Event
 	{
-		EntityID Player;
+		unsigned int Player;
 	};
 }
 

src/Events/FlagPickup.h

@@ -8,7 +8,7 @@ namespace Events
 {
 	struct FlagPickup : Event
 	{
-		EntityID Player;
+		unsigned int Player;
 	};
 }
 

src/Events/FlagReturned.h

@@ -8,7 +8,7 @@ namespace Events
 {
 	struct FlagReturned : Event
 	{
-		EntityID Player;
+		unsigned int Player;
 	};
 }
 

src/Events/GameOver.h

@@ -8,7 +8,7 @@ namespace Events
 {
 	struct GameOver : Event
 	{
-		EntityID Winner;
+		unsigned int Player;
 	};
 }
 

src/Events/OnDead.h

@@ -1,16 +0,0 @@
-#ifndef Events_OnDead_h__
-#define Events_OnDead_h__
-#include "Entity.h"
-#include "EventBroker.h"
-
-namespace Events
-{
-	struct OnDead : Event
-	{
-		EntityID Entity;
-	};
-}
-
-
-
-#endif // Events_OnDead_h__

src/GUI/GameFrame.h

@@ -11,6 +11,7 @@
 #include "GameWorld.h"
 #include "Events/GameStart.h"
 #include "Events/GameOver.h"
+#include "Events/Dead.h"
 
 namespace GUI
 {
@@ -41,10 +42,10 @@ public:
 			m_FreeCamViewport = new Viewport(m_WorldFrame, "ViewportFreeCam", m_World);
 			m_FreeCamViewport->Hide();
 		}
-		//m_WorldFrame->Hide();
+		m_WorldFrame->Hide();
-		//m_MainMenuFrame = new MainMenuFrame(this, "MainMenu");
-
 		m_World->Initialize();
+
+		m_MainMenuFrame = new MainMenuFrame(this, "MainMenu");
 	}
 
 private:

src/GUI/HealthOverlay.h

@@ -37,7 +37,7 @@ namespace GUI
 			if (!health)
 				return false;
 	
-			SetColor(glm::vec4(1.f, 1.f, 1.f, 1 - health->Amount / 100.f));
+			SetColor(glm::vec4(1.f, 1.f, 1.f, 1 - (health->Amount / 100.f / 2.f)));
 
 			return true;
 		}

src/GUI/MainMenuFrame.h

@@ -5,6 +5,7 @@
 #include "GUI/HealthOverlay.h"
 
 #include "Events/GameStart.h"
+#include "Events/PlayBGM.h"
 
 namespace GUI
 {
@@ -27,6 +28,10 @@ public:
 		m_TargetCoordinate = m_CurrentCoordinate;
 		m_Buttons->X = m_CurrentCoordinate.x;
 		m_Buttons->Y = m_CurrentCoordinate.y;
+
+		Events::PlayBGM e;
+		e.Resource = "Sounds/BGM/DiesIrae.mp3";
+		EventBroker->Publish(e);
 	}
 
 	void Update(double dt) override
@@ -74,8 +79,11 @@ protected:
 			if (m_CurrentSelection == 0)
 			{
 				Hide();
-				Events::GameStart e;
+				Events::GameStart e1;
-				EventBroker->Publish(e);
+				EventBroker->Publish(e1);
+				Events::PlayBGM e2;
+				e2.Resource = "Sounds/BGM/FlightOfTheBumblebee.mp3";
+				EventBroker->Publish(e2);
 			}
 			// Quit
 			else if (m_CurrentSelection == 1)

src/GUI/PlayerHUD.h

@@ -7,6 +7,7 @@
 #include "GUI/GameOverFrame.h"
 
 #include "Events/GameOver.h"
+#include "Events/Dead.h"
 #include "Components/Player.h"
 
 namespace GUI
@@ -20,7 +21,8 @@ namespace GUI
 			, m_World(world)
 			, m_PlayerID(playerID)
 		{
-			EVENT_SUBSCRIBE_MEMBER(m_EGameOver, &GUI::PlayerHUD::OnGameOver)
+			EVENT_SUBSCRIBE_MEMBER(m_EGameOver, &GUI::PlayerHUD::OnGameOver);
+			EVENT_SUBSCRIBE_MEMBER(m_EDead, &GUI::PlayerHUD::OnDead);
 
 			m_HealthOverlay = new HealthOverlay(this, "HealthOverlay", m_World, m_PlayerID);
 
@@ -35,6 +37,7 @@ namespace GUI
 			m_VehicleSelection = new VehicleSelection(this, "VehicleSelection", m_World, m_PlayerID);
 
 			m_GameOverFrame = new GameOverFrame(this, "GameOver");
+			m_GameOverFrame->Hide();
 		}
 
 	protected:
@@ -49,14 +52,7 @@ namespace GUI
 		EventRelay<Frame, Events::GameOver> m_EGameOver;
 		bool OnGameOver(const Events::GameOver &event)
 		{
-			auto playerComponent = m_World->GetComponent<Components::Player>(event.Winner);
+			if (m_PlayerID == event.Player)
-			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);
@@ -64,6 +60,18 @@ namespace GUI
 			return true;
 		}
 
+		EventRelay<Frame, Events::Dead> m_EDead;
+		bool OnDead(const Events::Dead &event)
+		{
+			auto playerCo = m_World->GetComponent<Components::Player>(event.Entity);
+			if (!playerCo || m_PlayerID != playerCo->ID)
+				return false;
+
+			m_VehicleSelection->Show();
+			m_HealthOverlay->SetColor(glm::vec4(1, 1, 1, 0));
+			return true;
+		}
+
 		bool OnCommand(const Events::InputCommand &event)
 		{
 			if (event.PlayerID != m_PlayerID)
@@ -71,10 +79,10 @@ namespace GUI
 
 			if (event.Command == "interface_confirm" && event.Value > 0)
 			{
-				if (m_GameOverFrame->Visible())
+				/*if (m_GameOverFrame->Visible())
 				{
 					m_GameOverFrame->Hide();
-				}
+				}*/
 			}
 
 			return true;

src/GameWorld.cpp

@@ -8,6 +8,21 @@ void GameWorld::Initialize()
 	ResourceManager->Preload("Model", "Models/Placeholders/PhysicsTest/Plane.obj");
 	ResourceManager->Preload("Model", "Models/Placeholders/PhysicsTest/ArrowCube.obj");
 
+	ResourceManager->Preload("Model", "Models/Tank/TankCollisionShape.obj");
+	ResourceManager->Preload("Model", "Models/Tank/tankBody.obj");
+	ResourceManager->Preload("Model", "Models/Tank/tankTop.obj");
+	ResourceManager->Preload("Model", "Models/Tank/tankBarrel.obj");
+	ResourceManager->Preload("Model", "Models/Jeep/Chassi/Chassi.OBJ");
+	ResourceManager->Preload("Model", "Models/Jeep/WheelFront/wheelFront.obj");
+	ResourceManager->Preload("Model", "Models/Jeep/WheelBack/wheelBack.obj");
+		
+		//Background Music
+	{
+		Events::PlayBGM e;
+		e.Resource = "Sounds/SFX/WUB.mp3";
+		EventBroker->Publish(e);
+	}
+
 	// Interface
 	BindKey(GLFW_KEY_A, "interface_horizontal", -1.f);
 	BindKey(GLFW_KEY_D, "interface_horizontal", 1.f);
@@ -16,6 +31,10 @@ void GameWorld::Initialize()
 	BindGamepadButton(Gamepad::Button::Right, "interface_horizontal", 1.f);
 	BindKey(GLFW_KEY_W, "interface_vertical", 1.f);
 	BindKey(GLFW_KEY_S, "interface_vertical", -1.f);
+
+	BindKey(GLFW_KEY_W, "jeep_vertical", 1.f);
+	BindKey(GLFW_KEY_S, "jeep_vertical", -1.f);
+
 	BindGamepadAxis(Gamepad::Axis::LeftY, "interface_vertical", 1.f);
 	BindGamepadButton(Gamepad::Button::Up, "interface_vertical", 1.f);
 	BindGamepadButton(Gamepad::Button::Down, "interface_vertical", -1.f);
@@ -93,6 +112,51 @@ void GameWorld::Initialize()
 		EventBroker->Publish(e);
 	}
 
+#pragma region Tower_Debris_Template
+	{
+		auto debri = CreateEntity();
+		AddComponent<Components::Template>(debri);
+		auto transform = AddComponent<Components::Transform>(debri);
+		transform->Position = glm::vec3(0.f, 4.12801f, 1.18125f);
+		auto model = AddComponent<Components::Model>(debri);
+		model->ModelFile = "Models/Turret/Gun/Gun.obj";
+		auto physics = AddComponent<Components::Physics>(debri);
+		physics->MotionType = Components::Physics::MotionTypeEnum::Dynamic;
+		physics->Mass = 200.f;
+		physics->Restitution = .04f;
+		physics->Friction = 0.9f;
+
+		auto shape = CreateEntity(debri);
+		auto shapetransform = AddComponent<Components::Transform>(shape);
+		auto shapemesh = AddComponent<Components::MeshShape>(shape);
+		shapemesh->ResourceName = "Models/Turret/Gun/Gun.obj";
+
+		m_TowerDebrisTemplates.push_back(debri);
+	}
+
+	{
+		auto debri = CreateEntity();
+		AddComponent<Components::Template>(debri);
+		auto transform = AddComponent<Components::Transform>(debri);
+		transform->Position = glm::vec3(0.f, 5.889f-0.92791f, 0.f);
+		auto model = AddComponent<Components::Model>(debri);
+		model->ModelFile = "Models/Turret/GunRotation/GunRotation.obj";
+		auto physics = AddComponent<Components::Physics>(debri);
+		physics->MotionType = Components::Physics::MotionTypeEnum::Dynamic;
+		physics->Mass = 200.f;
+		physics->Restitution = .04f;
+		physics->Friction = 0.9f;
+
+		auto shape = CreateEntity(debri);
+		auto shapetransform = AddComponent<Components::Transform>(shape);
+		auto shapemesh = AddComponent<Components::MeshShape>(shape);
+		shapemesh->ResourceName = "Models/Turret/GunRotation/GunRotation.obj";
+
+		m_TowerDebrisTemplates.push_back(debri);
+	}
+
+#pragma endregion
+
 #pragma region Wall_Debris_Template
 
 	{
@@ -294,37 +358,7 @@ void GameWorld::Initialize()
 		EventBroker->Publish(e);
 	}*/
 
-	{
-		auto flag = CreateEntity();
-		auto transform = AddComponent<Components::Transform>(flag);
-		transform->Position = glm::vec3(0, -50, 100);
-		auto model = AddComponent<Components::Model>(flag);
-		model->ModelFile = "Models/Flag/FishingRod/FishingRod.obj";
-		{
-			auto fish = CreateEntity(flag);
-			auto transform = AddComponent<Components::Transform>(fish);
-			transform->Position = glm::vec3(-1.3f, 1.0, 0);
-			auto model = AddComponent<Components::Model>(fish);
-			model->ModelFile = "Models/Flag/LeFish/Salmon.obj";
-			CommitEntity(fish);
-		}
 	
-		auto trigger = AddComponent<Components::Trigger>(flag);
-		{
-			auto shape = CreateEntity(flag);
-			auto transform = AddComponent<Components::Transform>(shape);
-			transform->Position = glm::vec3(-0.9f, 0.9f, 0);
-			auto box = AddComponent<Components::BoxShape>(shape);
-			box->Width = 1.1f;
-			box->Depth = 0.7f;
-			box->Height = 3.9f;
-			CommitEntity(shape);
-		}
-
-		auto flagComponent = AddComponent<Components::Flag>(flag);
-
-		CommitEntity(flag);
-	}
 
 	//for (int i = 0; i < 500; i++)
 	//{
@@ -416,7 +450,6 @@ void GameWorld::RegisterComponents()
 	m_ComponentFactory.Register<Components::Transform>([]() { return new Components::Transform(); }); 
 	m_ComponentFactory.Register<Components::Template>([]() { return new Components::Template(); });	
 	m_ComponentFactory.Register<Components::Player>([]() { return new Components::Player(); });	
-	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(); });
@@ -443,7 +476,9 @@ void GameWorld::RegisterSystems()
 	m_SystemFactory.Register<Systems::FollowSystem>([this]() { return new Systems::FollowSystem(this, EventBroker, ResourceManager); });
 	m_SystemFactory.Register<Systems::GarageSystem>([this]() { return new Systems::GarageSystem(this, EventBroker, ResourceManager); });
 	m_SystemFactory.Register<Systems::WallSystem>([this]() { return new Systems::WallSystem(this, EventBroker, ResourceManager); });
+	m_SystemFactory.Register<Systems::FlagSystem>([this]() { return new Systems::FlagSystem(this, EventBroker, ResourceManager); });
 	m_SystemFactory.Register<Systems::TowerSystem>([this]() { return new Systems::TowerSystem(this, EventBroker, ResourceManager); });
+	m_SystemFactory.Register<Systems::GameStateSystem>([this]() { return new Systems::GameStateSystem(this, EventBroker, ResourceManager); });
 	m_SystemFactory.Register<Systems::RenderSystem>([this]() { return new Systems::RenderSystem(this, EventBroker, ResourceManager); });
 }
 
@@ -468,7 +503,9 @@ void GameWorld::AddSystems()
 	AddSystem<Systems::FollowSystem>();
 	AddSystem<Systems::GarageSystem>();
 	AddSystem<Systems::WallSystem>();
+	AddSystem<Systems::FlagSystem>();
 	AddSystem<Systems::TowerSystem>();
+	AddSystem<Systems::GameStateSystem>();
 	AddSystem<Systems::RenderSystem>();
 }
 
@@ -636,9 +673,11 @@ void GameWorld::CreateGate(EntityID parent, glm::vec3 position, glm::quat orient
 
 EntityID GameWorld::CreateTower(EntityID parent, glm::vec3 pos, int teamID)
 {
-	auto towerBase = CreateEntity(parent);
+	auto parentTransform = GetComponent<Components::Transform>(parent);
+
+	auto towerBase = CreateEntity();
 	auto transform = AddComponent<Components::Transform>(towerBase);
-	transform->Position = pos;
+	transform->Position = parentTransform->Orientation * pos;
 
 	auto towerComponent = AddComponent<Components::Tower>(towerBase);
 
@@ -742,6 +781,9 @@ EntityID GameWorld::CreateTower(EntityID parent, glm::vec3 pos, int teamID)
 	turretComponent->ShotTemplate = m_ShotTemplate;
 	turretComponent->ShotSpeed = 40.f;
 
+	auto debrisComponent = AddComponent<Components::TowerDebris>(towerBase);
+	debrisComponent->TowerDebrisIDs = m_TowerDebrisTemplates;
+
 	CommitEntity(towerBase);
 
 	return towerBase;
@@ -889,6 +931,18 @@ void GameWorld::CreateTerrain()
 		auto transform = AddComponent<Components::Transform>(decoration_middle);
 		auto model = AddComponent<Components::Model>(decoration_middle);
 		model->ModelFile = "Models/TerrainFiveIstles/Decoration/Middle.obj";
+		auto physics = AddComponent<Components::Physics>(decoration_middle);
+		physics->Mass = 1.f;
+		physics->MotionType = Components::Physics::MotionTypeEnum::Fixed;
+
+		{
+			auto shape = CreateEntity(decoration_middle);
+			auto transform = AddComponent<Components::Transform>(shape);
+			auto mesh = AddComponent<Components::MeshShape>(shape);
+			mesh->ResourceName = "Models/TerrainFiveIstles/Decoration/Middle.obj";
+			CommitEntity(shape);
+		}
+
 		CommitEntity(decoration_middle);
 	}
 
@@ -1204,6 +1258,16 @@ void GameWorld::CreateBase(glm::quat orientation, int teamID)
 		auto transform = AddComponent<Components::Transform>(decoration_base);
 		auto model = AddComponent<Components::Model>(decoration_base);
 		model->ModelFile = "Models/TerrainFiveIstles/Decoration/Base.obj";
+		auto physics = AddComponent<Components::Physics>(decoration_base);
+		physics->MotionType = Components::Physics::MotionTypeEnum::Fixed;
+		physics->Mass = 1.f;
+		{
+			auto shape = CreateEntity(decoration_base);
+			auto transform = AddComponent<Components::Transform>(shape);
+			auto mesh = AddComponent<Components::MeshShape>(shape);
+			mesh->ResourceName = "Models/TerrainFiveIstles/Decoration/BaseCollision.obj";
+			CommitEntity(shape);
+		}
 		CommitEntity(decoration_base);
 	}
 
@@ -1316,7 +1380,7 @@ void GameWorld::CreateBase(glm::quat orientation, int teamID)
 	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)));
-	CreateTower(base, glm::vec3(290.f, 40.3f, 15.f), teamID);
+	//CreateTower(base, glm::vec3(290.f, 40.3f, 15.f), teamID);
 
 	// -Z
 	CreateWall(base, glm::vec3(280.f, 40.3f, -62.f), glm::quat(glm::vec3(0, 0, 0)));
@@ -1349,7 +1413,17 @@ void GameWorld::CreateBase(glm::quat orientation, int teamID)
 	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)));
 
+	CreateTower(base, glm::vec3(273.01227f, 40.43885f, 32.99123f), teamID);
+	CreateTower(base, glm::vec3(273.01227f, 40.30102f, -62.82098f), teamID);
+	CreateTower(base, glm::vec3(357.36978f, 40.43885f, -62.82098f), teamID);
+	CreateTower(base, glm::vec3(357.36978f, 40.43885f, 32.99123f), teamID);
+
+	CreateTower(base, glm::vec3(119.64996f, 28.90156f, -16.63123f), teamID);
+	CreateTower(base, glm::vec3(119.05541f, 29.54314f, 18.33529f), teamID);
+
 	CreateGarage(base, glm::vec3(323.2f, 41.4f, -10.2f), glm::quat(glm::vec3(0, glm::pi<float>() / 2.f, 0)), teamID);
+
+	CreateFlag(base, glm::vec3(291.f, 41.7412f, -36.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 teamID)
@@ -1457,10 +1531,10 @@ EntityID GameWorld::CreateGarage(EntityID parent, glm::vec3 Position, glm::quat
 		{
 			auto shape = CreateEntity(elevator);
 			auto transform = AddComponent<Components::Transform>(shape);
-			transform->Position = glm::vec3(0, 0, 0);
+			transform->Position = glm::vec3(0, -2, 0);
 			auto box = AddComponent<Components::BoxShape>(shape);
 			box->Width = 4.754f;
-			box->Height = 0.141f;
+			box->Height = 2.141f;
 			box->Depth = 6.86f;
 			CommitEntity(shape);
 		}
@@ -1529,3 +1603,47 @@ EntityID GameWorld::CreateGarage(EntityID parent, glm::vec3 Position, glm::quat
 	
 	return garage;
 }
+
+void GameWorld::CreateFlag(EntityID parent, glm::vec3 position, glm::quat orientation, int TeamID)
+{
+	
+	auto flag = CreateEntity(parent);
+	SetProperty(flag, "Name", "Flag");
+	auto transform = AddComponent<Components::Transform>(flag);
+	transform->Position = position;
+	transform->Orientation = orientation;
+	auto flagComponent = AddComponent<Components::Flag>(flag);
+	auto trigger = AddComponent<Components::Trigger>(flag);
+	auto team = AddComponent<Components::Team>(flag);
+	team->TeamID = TeamID;
+	{
+		auto fish = CreateEntity(flag);
+		auto transform = AddComponent<Components::Transform>(fish);
+		transform->Position = glm::vec3(-1.3f, 1.0, 0);
+		auto model = AddComponent<Components::Model>(fish);
+		model->ModelFile = "Models/Flag/LeFish/Salmon.obj";
+		CommitEntity(fish);
+	}
+
+	{
+		auto rod = CreateEntity(flag);
+		auto transform = AddComponent<Components::Transform>(rod);
+		transform->Position = glm::vec3(-1.3f, 1.0, 0);
+		auto model = AddComponent<Components::Model>(rod);
+		model->ModelFile = "Models/Flag/FishingRod/FishingRod.obj";
+		CommitEntity(rod);
+	}
+	
+	{
+		auto shape = CreateEntity(flag);
+		auto transform = AddComponent<Components::Transform>(shape);
+		transform->Position = glm::vec3(-0.9f, 0.9f, 0);
+		auto box = AddComponent<Components::BoxShape>(shape);
+		box->Width = 1.1f;
+		box->Depth = 0.7f;
+		box->Height = 3.9f;
+		CommitEntity(shape);
+	}
+	CommitEntity(flag);
+	
+}

src/GameWorld.h

@@ -26,6 +26,8 @@
 #include "Systems/TowerSystem.h"
 #include "Systems/GarageSystem.h"
 #include "Systems/JeepSteeringSystem.h"
+#include "Systems/FlagSystem.h"
+#include "Systems/GameStateSystem.h"
 
 #include "Components/Camera.h"
 #include "Components/DirectionalLight.h"
@@ -90,7 +92,9 @@ private:
 	EntityID CreateGarage(EntityID parent, glm::vec3 Position, glm::quat orientation, int teamID);
 	void CreateTerrain();
 	void CreateBase(glm::quat orientation, int playerID);
+	void CreateFlag(EntityID parent, glm::vec3 position, glm::quat orientation, int TeamID);
 	std::vector<EntityID> m_WallDebrisTemplates;
+	std::vector<EntityID> m_TowerDebrisTemplates;
 	EntityID m_ShotTemplate;
 };
 

src/InputManager.cpp

@@ -86,6 +86,28 @@ void InputManager::Update(double dt)
 	}
 
 	
+	if(m_CurrentKeyState[GLFW_KEY_P])
+	{
+		Events::StopSound e;
+		e.Emitter = 1;
+		EventBroker->Publish(e);
+	}
+	if(m_CurrentKeyState[GLFW_KEY_L])
+	{
+		Events::PlayBGM e;
+		e.Resource = "Sounds/BGM/WilliamTellOverture.mp3";
+		e.Loop = true;
+		EventBroker->Publish(e);
+	}
+	if(m_CurrentKeyState[GLFW_KEY_O])
+	{
+		Events::PlayBGM e;
+		e.Resource = "Sounds/BGM/DiesIrae.mp3";
+		e.Loop = true;
+		EventBroker->Publish(e);
+	}
+
+
 	// // Lock mouse while holding LMB
 	// if (m_CurrentMouseState[GLFW_MOUSE_BUTTON_LEFT])
 	// {

src/InputManager.h

@@ -13,6 +13,9 @@
 #include "Events/GamepadAxis.h"
 #include "Events/GamepadButton.h"
 
+#include "Events/StopSound.h"
+#include "Events/PlayBGM.h"
+
 class InputManager
 {
 public:

src/Systems/DamageSystem.cpp

@@ -19,12 +19,11 @@ bool Systems::DamageSystem::OnDamage( const Events::Damage &event )
 		return false;
 	auto health = m_World->GetComponent<Components::Health>(event.Entity);
 	health->Amount -= event.Amount;
-	//if(health->Amount <= 0)
+	if(health->Amount <= 0)
-	//{
+	{
-	//	Events::OnDead e;
+		Events::Dead e;
-	//	e.Entity = event.Entity;
+		e.Entity = event.Entity;
-	//	EventBroker->Publish(e);
+		EventBroker->Publish(e);
-	//}
+	}
-	LOG_INFO("Damaged entity %i, Health left: %f", event.Entity, health->Amount);
 	return true;
 }

src/Systems/DamageSystem.h

@@ -6,7 +6,7 @@
 #include "Components/Health.h"
 #include "Components/DamageModel.h"
 #include "Events/Damage.h"
-#include "Events/OnDead.h"
+#include "Events/Dead.h"
 
 namespace Systems
 {

src/Systems/FlagSystem.cpp

@@ -0,0 +1,63 @@
+#include "PrecompiledHeader.h"
+#include "FlagSystem.h"
+#include "World.h"
+void Systems::FlagSystem::RegisterComponents( ComponentFactory* cf )
+{
+	cf->Register<Components::Flag>([]() { return new Components::Flag(); });
+}
+
+void Systems::FlagSystem::Initialize()
+{
+	EVENT_SUBSCRIBE_MEMBER(m_EEnterTrigger, &Systems::FlagSystem::OnEnterTrigger);
+}
+
+void Systems::FlagSystem::Update( double dt )
+{
+
+}
+
+void Systems::FlagSystem::UpdateEntity( double dt, EntityID entity, EntityID parent )
+{
+
+}
+
+bool Systems::FlagSystem::OnEnterTrigger( const Events::EnterTrigger &event )
+{
+	auto JeepSteeringComponent = m_World->GetComponent<Components::JeepSteering>(event.Entity);
+	if(!JeepSteeringComponent)
+		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;
+
+
+
+	auto flagComponent = m_World->GetComponent<Components::Flag>(event.Trigger);
+	if(!flagComponent)
+		return false;
+
+	PickUpFlag(event.Entity, event.Trigger);
+	
+	return true;
+}
+void Systems::FlagSystem::PickUpFlag( EntityID entity, EntityID trigger )
+{
+	m_World->RemoveComponent<Components::Trigger>(trigger);
+	m_World->SetEntityParent(trigger, entity);
+
+	auto triggerTransform = m_World->GetComponent<Components::Transform>(trigger);
+	triggerTransform->Position = glm::vec3(-1.5f, 0.1f, 2.f);
+
+	auto teamComponent = m_World->GetComponent<Components::Team>(trigger);
+	auto playerComponent = m_World->GetComponent<Components::Player>(entity);
+
+	Events::FlagPickup ePickup;
+	ePickup.Player = playerComponent->ID;
+	EventBroker->Publish(ePickup);
+}
+

src/Systems/FlagSystem.h

@@ -0,0 +1,44 @@
+#ifndef FlagSystem_h__
+#define FlagSystem_h__
+
+
+#include "System.h"
+#include "Components/Flag.h"
+#include "Components/Player.h"
+#include "Components/Team.h"
+#include "Components/Trigger.h"
+#include "Components/Transform.h"
+#include "Components/JeepSteering.h"
+
+#include "Events/FlagCaptured.h"
+#include "Events/FlagDropped.h"
+#include "Events/FlagPickup.h"
+#include "Events/FlagReturned.h"
+
+
+#include "Events/EnterTrigger.h"
+
+namespace Systems
+{
+	class FlagSystem : public System
+	{
+	public:
+
+		FlagSystem(World* world, std::shared_ptr<::EventBroker> eventBroker, std::shared_ptr<::ResourceManager> resourceManager)
+			: System(world, eventBroker, resourceManager) { }
+
+
+		void Initialize() override;
+		void RegisterComponents(ComponentFactory* cf) override;
+		void Update(double dt) override;
+		void UpdateEntity(double dt, EntityID entity, EntityID parent) override;
+
+	private:
+		EventRelay<FlagSystem, Events::EnterTrigger> m_EEnterTrigger;
+		bool OnEnterTrigger(const Events::EnterTrigger &event);
+
+		void PickUpFlag(EntityID entity, EntityID trigger);
+	};
+
+}
+#endif // DamageSystem_h__

src/Systems/GameStateSystem.cpp

@@ -11,9 +11,12 @@ bool Systems::GameStateSystem::OnFlagCaptured(const Events::FlagCaptured &event)
 {
 	m_InGame = false;
 
-	Events::GameOver e;
+	Events::GameOver e1;
-	e.Winner = event.Player;
+	e1.Player = event.Player;
-	EventBroker->Publish(e);
+	EventBroker->Publish(e1);
+	Events::PlayBGM e2;
+	e2.Resource = "Sounds/BGM/WilliamTellOverture.mp3";
+	EventBroker->Publish(e2);
 
 	return true;
 }

src/Systems/GameStateSystem.h

@@ -8,6 +8,7 @@
 #include "Components/Player.h"
 #include "Events/FlagCaptured.h"
 #include "Events/GameOver.h"
+#include "Events/PlayBGM.h"
 
 namespace Systems
 {

src/Systems/GarageSystem.cpp

@@ -112,6 +112,27 @@ bool Systems::GarageSystem::OnCommand(const Events::InputCommand &event)
 
 				if (triggerTeamComponent->TeamID == entityPlayerComponent->ID)
 				{
+
+					auto components = m_World->GetComponentsOfType<Components::Flag>();
+
+					for (auto &component : *components)
+					{
+						auto teamComponent = m_World->GetComponent<Components::Team>(component->Entity);
+						if(!teamComponent)
+							continue;
+
+						auto parent = m_World->GetEntityParent(component->Entity);
+						if(parent != entity)
+							continue;
+
+						if(teamComponent->TeamID != entityPlayerComponent->ID)
+						{
+							Events::FlagCaptured e;
+							e.Player = entityPlayerComponent->ID;
+							EventBroker->Publish(e);
+						}
+					}
+
 					EntityID garage = m_World->GetEntityParent(trigger);
 					auto garageComponent = m_World->GetComponent<Components::Garage>(garage);
 					ToggleGarage(garageComponent);

src/Systems/GarageSystem.h

@@ -19,6 +19,8 @@
 #include "Components/Move.h"
 #include "Components/Rotate.h"
 #include "Components/Team.h"
+#include "Components/Flag.h"
+#include "Events/FlagCaptured.h"
 
 namespace Systems
 {

src/Systems/JeepSteeringSystem.cpp

@@ -102,7 +102,6 @@ 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;

src/Systems/ParticleSystem.cpp

@@ -239,7 +239,6 @@ void Systems::ParticleSystem::ScalarInterpolation(double timeProgress, std::vect
 
 bool Systems::ParticleSystem::CreateExplosion(const Events::CreateExplosion &e)
 {
-	LOG_INFO("Spawning an explosion");
 	auto explosion = m_World->CreateEntity();
 	auto emitter = m_World->AddComponent<Components::ParticleEmitter>(explosion);
 	emitter->LifeTime = e.LifeTime;
@@ -269,6 +268,13 @@ bool Systems::ParticleSystem::CreateExplosion(const Events::CreateExplosion &e)
 	auto templateComponent = m_World->AddComponent<Components::Template>(particleEnt);
 	auto TEMP = m_World->AddComponent<Components::Transform>(particleEnt);
 	auto spriteComponent = m_World->AddComponent<Components::Sprite>(particleEnt);
+	if(e.usePointLight)
+	{
+		auto light = m_World->AddComponent<Components::PointLight>(particleEnt);
+		light->Diffuse = glm::vec3(231.f/255.f, 181.f/255.f, 48.f/255.f);
+		light->Specular = glm::vec3(0.5f, 0.5f, 0.5f);
+		light->Radius = 20.f;
+	}
 	spriteComponent->SpriteFile = e.spritePath;
 	m_World->CommitEntity(particleEnt);
 	emitter->ParticleTemplate = particleEnt;

src/Systems/ParticleSystem.h

@@ -5,6 +5,7 @@
 #include "Systems/TransformSystem.h"
 #include "Components/Transform.h"
 #include "Components/ParticleEmitter.h"
+#include "Components/PointLight.h"
 #include "Components/Particle.h"
 #include "Components/Sprite.h"
 #include "EventBroker.h"

src/Systems/PhysicsSystem.cpp

@@ -39,6 +39,7 @@ void Systems::PhysicsSystem::Initialize()
 	EVENT_SUBSCRIBE_MEMBER(m_EApplyPointImpulse, &Systems::PhysicsSystem::OnApplyPointImpulse);
 	EVENT_SUBSCRIBE_MEMBER(m_EEnableCollisions, &Systems::PhysicsSystem::OnEnableCollisions);
 	EVENT_SUBSCRIBE_MEMBER(m_EDisableCollisions, &Systems::PhysicsSystem::OnDisableCollisions);
+	EVENT_SUBSCRIBE_MEMBER(m_EDead, &Systems::PhysicsSystem::OnDead);
 
 	hkMemorySystem::FrameInfo finfo(10000 * 1024);	// Allocate 10MB of Physics solver buffer
 	hkMemoryRouter* memoryRouter = hkMemoryInitUtil::initDefault(hkMallocAllocator::m_defaultMallocAllocator, finfo);
@@ -254,7 +255,8 @@ void Systems::PhysicsSystem::UpdateEntity(double dt, EntityID entity, EntityID p
 					
 				}
 			}*/
-			
+			auto vehicleComponent = m_World->GetComponent<Components::Vehicle>(car);
+			vehicleComponent->currentRPM = m_Vehicles[car]->calcRPM();
 			
 			
 			m_Vehicles[car]->getChassis()->activate();
@@ -783,41 +785,42 @@ bool Systems::PhysicsSystem::OnApplyPointImpulse( const Events::ApplyPointImpuls
 void Systems::PhysicsSystem::OnComponentRemoved(EntityID entity, std::string type, Component* component)
 {
 	
-	if(m_RigidBodies.find(entity) != m_RigidBodies.end())
+	
-	{
-		LOG_INFO("Removed Trigger of entity %i", entity);
-		m_PhysicsWorld->markForWrite();
-		m_RigidBodyEntities.erase(m_RigidBodies[entity]);
-		m_PhysicsWorld->removeEntity(m_RigidBodies[entity]);
-		m_RigidBodies.erase(entity);
-		m_PhysicsWorld->unmarkForWrite();
-	}
 }
 
 
 void Systems::PhysicsSystem::OnEntityRemoved( EntityID entity )
 {
-   	if(m_RigidBodies.find(entity) != m_RigidBodies.end())
+	if (m_Vehicles.find(entity) != m_Vehicles.end())
-	{
-		LOG_INFO("Removed rigid body of entity %i", entity);
-		m_PhysicsWorld->markForWrite();
-		m_RigidBodyEntities.erase(m_RigidBodies[entity]);
-		if(m_ListShapes.find(entity) != m_ListShapes.end())
-		{
-			m_ListShapes[entity]->removeReference();
-			m_ListShapes.erase(entity);
-		}
-		
-		m_PhysicsWorld->removeEntity(m_RigidBodies[entity]);
-		m_RigidBodies.erase(entity);
-		m_PhysicsWorld->unmarkForWrite();
-	}
-	if(m_Vehicles.find(entity) != m_Vehicles.end())
 	{
 		m_PhysicsWorld->markForWrite();
 		m_Vehicles[entity]->removeFromWorld();
 		m_PhysicsWorld->unmarkForWrite();
+		m_Vehicles.erase(entity);
+		m_RigidBodyEntities.erase(m_RigidBodies[entity]);
+		m_RigidBodies.erase(entity);
 	}
+	else if (m_RigidBodies.find(entity) != m_RigidBodies.end())
+	{
+		m_PhysicsWorld->markForWrite();
+		m_RigidBodyEntities.erase(m_RigidBodies[entity]);
+		m_PhysicsWorld->removeEntity(m_RigidBodies[entity]);
+		m_RigidBodies.erase(entity);
+		m_PhysicsWorld->unmarkForWrite();
+	}
+	/*
+   	else if(m_RigidBodies.find(entity) != m_RigidBodies.end())
+	{
+		LOG_INFO("Removed rigid body of entity %i abogfusdkifbhdzfsgiudfhghdfhgdhfögödhfgödhfödhfödfjhödgfdgföuhudgf", entity);
+
+		m_PhysicsWorld->markForWrite();
+		m_PhysicsWorld->removeEntity(m_RigidBodies[entity]);
+		m_PhysicsWorld->unmarkForWrite();
+
+		m_RigidBodies.erase(entity);
+		m_RigidBodyEntities.erase(m_RigidBodies[entity]);
+		
+	}*/
 }
 
 bool Systems::PhysicsSystem::OnEnableCollisions( const Events::EnableCollisions &e )
@@ -900,3 +903,40 @@ bool Systems::PhysicsSystem::OnJeepSteer( const Events::JeepSteer &event )
 
 	return true;
 }
+
+bool Systems::PhysicsSystem::OnDead( const Events::Dead &e )
+{
+	if(m_Vehicles.find(e.Entity) != m_Vehicles.end())
+	{
+		m_World->RemoveEntity(e.Entity);
+		//EntityID camera = m_World->GetProperty<EntityID>(e.Entity, "Camera");
+		//m_World->RemoveComponent<Components::Camera>(camera);
+		//auto transform = m_World->GetComponent<Components::Transform>(e.Entity);
+		//transform->Position = glm::vec3(0, -10000.f, 0);
+		////m_RigidBodies[e.Entity]->setPosition(hkVector4(0, -10000, 0));
+
+		///*m_Vehicles.erase(e.Entity);
+		//m_RigidBodyEntities.erase(m_RigidBodies[e.Entity]);
+		//m_RigidBodies.erase(e.Entity);*/
+
+		//auto jeep = m_World->GetComponent<Components::JeepSteering>(e.Entity);
+		//if(jeep)
+		//{
+		//	m_World->RemoveComponent<Components::JeepSteering>(e.Entity);
+		//}
+
+		//auto tank = m_World->GetComponent<Components::TankSteering>(e.Entity);
+		//if(tank)
+		//{
+		//	m_World->RemoveComponent<Components::TankSteering>(e.Entity);
+		//}
+
+		auto listener = m_World->GetComponent<Components::Listener>(e.Entity);
+		if (listener)
+		{
+			m_World->RemoveComponent<Components::Listener>(e.Entity);
+		}
+		
+	}
+	return true;
+}

src/Systems/PhysicsSystem.h

@@ -86,9 +86,12 @@
 #include "Events/DisableCollisions.h"
 #include "Components/Trigger.h"
 #include "Components/Template.h"
-
+#include "Components/Camera.h"
+#include "Components/Listener.h"
 #include "Events/EnterTrigger.h"
 #include "Events/JeepSteer.h"
+#include "Events/Dead.h"
+#include "Components/JeepSteering.h"
 
 namespace Systems
 {
@@ -111,7 +114,6 @@ public:
 			e.Entity1 = entity1;
 			e.Entity2 = entity2;
 			m_PhysicsSystem->EventBroker->Publish(e);
-			LOG_INFO("CollisionEvent!");
 		}
 		
 	private:
@@ -192,6 +194,9 @@ private:
 	bool OnEnableCollisions(const Events::EnableCollisions &e);
 	EventRelay<PhysicsSystem, Events::DisableCollisions> m_EDisableCollisions;
 	bool OnDisableCollisions(const Events::DisableCollisions &e);
+	EventRelay<PhysicsSystem, Events::Dead> m_EDead;
+	bool OnDead(const Events::Dead &e);
+
 
 	void SetUpPhysicsState(EntityID entity, EntityID parent);
 	void TearDownPhysicsState(EntityID entity, EntityID parent);

src/Systems/SoundSystem.cpp

@@ -2,13 +2,18 @@
 #include "SoundSystem.h"
 #include "World.h"
 
+Systems::SoundSystem::~SoundSystem()
+{
+	FMOD_System_Release(m_System);
+}
+
 void Systems::SoundSystem::Initialize()
 {
 	EVENT_SUBSCRIBE_MEMBER(m_EComponentCreated, &SoundSystem::OnComponentCreated);
 	EVENT_SUBSCRIBE_MEMBER(m_EPlaySFX, &SoundSystem::PlaySFX);
 	EVENT_SUBSCRIBE_MEMBER(m_EPlayBGM, &SoundSystem::PlayBGM);
 	EVENT_SUBSCRIBE_MEMBER(m_EStopSound, &SoundSystem::StopSound);
-	
+	m_isPlaying = false;
 	m_TransformSystem = m_World->GetSystem<Systems::TransformSystem>();
 	FMOD_System_Create(&m_System);
 	FMOD_RESULT result = FMOD_System_Init(m_System, 32, FMOD_INIT_3D_RIGHTHANDED | FMOD_INIT_ENABLE_PROFILE, 0);
@@ -44,16 +49,15 @@ void Systems::SoundSystem::Update(double dt)
 	std::map<EntityID, FMOD_CHANNEL*>::iterator it;
 	for(it = m_DeleteChannels.begin(); it != m_DeleteChannels.end();)
 	{
-		FMOD_BOOL isPlaying = false;
+		FMOD_Channel_IsPlaying(it->second, &m_isPlaying);
-		FMOD_Channel_IsPlaying(it->second, &isPlaying);
+		if(m_isPlaying)
-		if(isPlaying)
 		{
 			it++;
 		}
 		else
 		{
 // 			FMOD_Sound_Release(m_DeleteSounds[it->first]);
-// 			m_DeleteSounds.erase(it->first);
+ 			m_DeleteSounds.erase(it->first);
 			it = m_DeleteChannels.erase(it);
 		}
 
@@ -62,9 +66,8 @@ void Systems::SoundSystem::Update(double dt)
 
 	for(it = m_Channels.begin(); it != m_Channels.end();)
 	{
-		FMOD_BOOL isPlaying = false;
+		FMOD_Channel_IsPlaying(it->second, &m_isPlaying);
-		FMOD_Channel_IsPlaying(it->second, &isPlaying);
+		if(!m_isPlaying)
-		if(!isPlaying)
 		{
 			it = m_Channels.erase(it);			
 		}
@@ -101,7 +104,7 @@ void Systems::SoundSystem::UpdateEntity(double dt, EntityID entity, EntityID par
 	if(emitter)
 	{
 		FMOD_CHANNEL* channel = m_Channels[entity];
-		//FMOD_SOUND* sound = m_Sounds[entity];
+		FMOD_SOUND* sound = m_Sounds[entity];
 		auto eTransform = m_World->GetComponent<Components::Transform>(entity);
 		
 		glm::vec3 tPos = m_TransformSystem->AbsolutePosition(entity);
@@ -134,9 +137,9 @@ bool Systems::SoundSystem::OnComponentCreated(const Events::ComponentCreated &ev
 		float maxDist = emitter->MaxDistance;
 		float minDist = emitter->MinDistance;
 		float pitch = emitter->Pitch;
-		//LoadSound(sound, path, maxDist, minDist);
+		LoadSound(sound, path, maxDist, minDist);
 		m_Channels.insert(std::make_pair(emitter->Entity, channel));
-//		m_Sounds.insert(std::make_pair(emitter->Entity, sound));
+		m_Sounds.insert(std::make_pair(emitter->Entity, sound));
 	}
 	return true;
 }
@@ -154,7 +157,7 @@ bool Systems::SoundSystem::PlaySFX(const Events::PlaySFX &event)
 	
 	eComponent->type = Components::SoundEmitter::SoundType::SOUND_3D;
 	Sound* sound = ResourceManager->Load<Sound>("Sound3D", event.Resource);
-	//m_Sounds[eEntity] = *sound;
+	m_Sounds[eEntity] = *sound;
 	FMOD_Sound_Set3DMinMaxDistance(*sound, eComponent->MinDistance, eComponent->MaxDistance);
 
 	PlaySound(&m_Channels[eEntity], *sound, 1.0, eComponent->Loop);
@@ -163,21 +166,34 @@ bool Systems::SoundSystem::PlaySFX(const Events::PlaySFX &event)
 
 bool Systems::SoundSystem::PlayBGM(const Events::PlayBGM &event)
 {
-	auto emitter = m_World->CreateEntity();
+	FMOD_RESULT result;
-	auto eTransform = m_World->AddComponent<Components::Transform>(emitter);
+	result = FMOD_Channel_Stop(m_BGMChannel);
-	auto eComponent = m_World->AddComponent<Components::SoundEmitter>(emitter);
+	if(result != FMOD_OK)	
-	m_Channels[emitter] = m_BGMChannel;
+		LOG_INFO("FMOD error! (%d) %s\n", result, FMOD_ErrorString(result));
-	eComponent->type = Components::SoundEmitter::SoundType::SOUND_3D;
 	Sound* sound = ResourceManager->Load<Sound>("Sound2D", event.Resource);
-	//m_Sounds[emitter] = *sound;
 
-	FMOD_System_PlaySound(m_System, FMOD_CHANNEL_FREE, *sound, false, &m_Channels[emitter]);
+	result = FMOD_System_PlaySound(m_System, FMOD_CHANNEL_FREE, *sound, false, &m_BGMChannel);
+	if(result != FMOD_OK)	
+		LOG_INFO("FMOD error! (%d) %s\n", result, FMOD_ErrorString(result));
+	FMOD_Channel_SetMode(m_BGMChannel, FMOD_LOOP_NORMAL);
+	FMOD_Sound_SetLoopCount(*sound, -1);
+
 	return true;
 }
 
+
+
 bool Systems::SoundSystem::StopSound(const Events::StopSound &event)
 {
-	FMOD_Channel_Stop(m_Channels[event.Emitter]);
+	auto eComp = m_World->GetComponent<Components::SoundEmitter>(event.Emitter);
+	if(eComp)
+	{
+		FMOD_Channel_Stop(m_Channels[event.Emitter]);
+	}
+	else
+	{
+		FMOD_Channel_Stop(m_BGMChannel);
+	}
 	return true;
 }
 
@@ -208,8 +224,8 @@ void Systems::SoundSystem::OnComponentRemoved(EntityID entity, std::string type,
 	if(emitter)
 	{
 		m_DeleteChannels.insert(std::make_pair(entity, m_Channels[entity]));
-		//m_DeleteSounds.insert(std::make_pair(entity, m_Sounds[entity]));
+		m_DeleteSounds.insert(std::make_pair(entity, m_Sounds[entity]));
 		m_Channels.erase(entity);
-		//m_Sounds.erase(entity);
+		m_Sounds.erase(entity);
 	}
 }

src/Systems/SoundSystem.h

@@ -24,13 +24,12 @@ public:
 	SoundSystem(World* world, std::shared_ptr<::EventBroker> eventBroker, std::shared_ptr<::ResourceManager> resourceManager)
 		: System(world, eventBroker, resourceManager)
 	{ }
-
+	~SoundSystem();
 	void RegisterComponents(ComponentFactory* cf) override;
 	void RegisterResourceTypes(std::shared_ptr<::ResourceManager> rm) override;
 	void Initialize() override;
 	void Update(double dt) override;
 	void UpdateEntity(double dt, EntityID entity, EntityID parent) override;
-	//void OnComponentRemoved(std::string type, Component* component);
 	void OnComponentRemoved(EntityID entity, std::string type, Component* component) override;
 	FMOD_SYSTEM* GetFMODSystem() const { return m_System; }
 private:
@@ -48,12 +47,13 @@ private:
 	void PlaySound(FMOD_CHANNEL**, FMOD_SOUND*, float volume, bool loop);
 	
 	FMOD_SYSTEM* m_System;
+	FMOD_BOOL m_isPlaying;
 	FMOD_CHANNEL* m_BGMChannel;
 	std::vector<EntityID> m_Listeners;
 	std::map<EntityID, FMOD_CHANNEL*> m_Channels;
 	std::map<EntityID, FMOD_CHANNEL*> m_DeleteChannels;
-	//std::map<EntityID, FMOD_SOUND*> m_Sounds;	
 	std::map<EntityID, FMOD_SOUND*> m_DeleteSounds;	
+	std::map<EntityID, FMOD_SOUND*> m_Sounds;	
 	std::shared_ptr<Systems::TransformSystem> m_TransformSystem;
 	
 };

src/Systems/TankSteeringSystem.cpp

@@ -30,6 +30,45 @@ void Systems::TankSteeringSystem::Update(double dt)
 
 void Systems::TankSteeringSystem::UpdateEntity(double dt, EntityID entity, EntityID parent)
 {
+	
+	auto pEmitter = m_World->GetComponent<Components::ParticleEmitter>(entity);
+	if(pEmitter)
+	{auto tankTransform = m_World->GetComponent<Components::Transform>(parent);
+		if(!m_World->GetComponent<Components::TankSteering>(parent))
+			return;
+		
+		glm::vec2 velXZ = glm::vec2(tankTransform->Velocity.x, tankTransform->Velocity.z);
+		float speedMPDT = glm::length(velXZ);
+		if(speedMPDT < 1)
+		{
+			pEmitter->Emitting = false;
+			return;
+		}
+		else
+		{
+			pEmitter->Emitting = true;
+			pEmitter->ScaleSpectrum.erase(pEmitter->ScaleSpectrum.begin());
+			float scale = speedMPDT / 20;
+			scale = glm::clamp(scale, 0.3f, 20.f);
+			pEmitter->ScaleSpectrum.push_back(glm::vec3(speedMPDT / 20));
+			float spawnFrequency = 1 / speedMPDT;
+			spawnFrequency = glm::clamp(spawnFrequency, 0.1f, 2.f);
+			pEmitter->SpawnFrequency = 1 / speedMPDT;
+		}
+	}
+	
+	auto vehicleComp = m_World->GetComponent<Components::Vehicle>(entity);
+	if(vehicleComp)
+	{
+		auto transform = m_World->GetComponent<Components::Transform>(entity);
+		if (transform->Position.y < -15 && transform->Position.y > -100)
+		{
+			Events::Dead e;
+			e.Entity = entity;
+			EventBroker->Publish(e);
+		}
+	}
+
 	auto tankSteeringComponent = m_World->GetComponent<Components::TankSteering>(entity);
 	if(!tankSteeringComponent)
 		return;
@@ -146,15 +185,6 @@ void Systems::TankSteeringSystem::UpdateEntity(double dt, EntityID entity, Entit
 
 		m_TimeSinceLastShot[tankSteeringComponent->Barrel] += dt;
 	}
-
-// 	auto shot = m_World->GetComponent<Components::TankShell>(entity); 
-// 	if(shot)
-// 	{
-// 		if(inputController->Shoot && m_TimeSinceLastShot[tankSteeringComponent->Barrel] > 0.5)
-// 		{
-// 			
-// 		}
-// 	}
 }
 
 bool Systems::TankSteeringSystem::OnCollision(const Events::Collision &e)
@@ -222,37 +252,68 @@ bool Systems::TankSteeringSystem::OnCollision(const Events::Collision &e)
 			e.Speed = 6;
 			e.SpreadAngle = glm::pi<float>();
 			e.spritePath = "Textures/Sprites/Blast1.png";
+			e.usePointLight = true;
 			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);
 			e.ParticlesToSpawn = 20;
 			e.Position = shellTransform->Position;
-			e.SpreadAngle = glm::radians<float>(180) / 4;
+			e.RelativeUpOrientation = glm::angleAxis(glm::pi<float>() / 2, glm::vec3(1,0,0));
-			e.RelativeUpOrientation = glm::angleAxis(glm::radians<float>(90), glm::vec3(1,0,0));
+			e.Speed = 3;
-			e.UseGoalVector = true;
+			e.SpreadAngle = glm::pi<float>();
-			e.GoalVelocity = glm::vec3(0,-12,0);
+			e.spritePath = "Textures/Sprites/Smoke1.png";
-			e.Speed = 12;
+			e.Color = glm::vec4(0.6,0.6,0.6,1);
-			e.spritePath = "Textures/Sprites/Splash.png";
-			e.Color = glm::vec4(5.f,5.f,5.f,1);
-
 			EventBroker->Publish(e);
-			e.LifeTime = 1.5;
+			e.LifeTime = 0.7;
-			e.ParticleScale.push_back(1);
+			e.ParticleScale.push_back(12);
-			e.ParticleScale.push_back(6);
+			e.ParticlesToSpawn = 10;
-			e.ParticlesToSpawn = 20;
 			e.Position = shellTransform->Position;
-			e.SpreadAngle = glm::radians<float>(180)/ 4;
+			e.RelativeUpOrientation = glm::angleAxis(glm::pi<float>() / 2, glm::vec3(1,0,0));
-			e.RelativeUpOrientation = glm::angleAxis(glm::radians<float>(90), glm::vec3(1,0,0));
+			e.Speed = 17;
-			e.UseGoalVector = true;
+			e.SpreadAngle = glm::pi<float>();
-			e.GoalVelocity = glm::vec3(0,-12,0);
+			e.spritePath = "Textures/Sprites/Fire.png";
-			e.Speed = 12;
+			EventBroker->Publish(e);
-			e.spritePath = "Textures/Sprites/Splash.png";
+			e.LifeTime = 0.2;
-			e.Color = glm::vec4(1.f,1.f,1.f,1);
+			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);
+// 			e.ParticlesToSpawn = 20;
+// 			e.Position = shellTransform->Position;
+// 			e.SpreadAngle = glm::radians<float>(180) / 4;
+// 			e.RelativeUpOrientation = glm::angleAxis(glm::radians<float>(90), glm::vec3(1,0,0));
+// 			e.UseGoalVector = true;
+// 			e.GoalVelocity = glm::vec3(0,-12,0);
+// 			e.Speed = 12;
+// 			e.spritePath = "Textures/Sprites/Splash.png";
+// 			e.Color = glm::vec4(5.f,5.f,5.f,1);
+// 
+// 			EventBroker->Publish(e);
+// 			e.LifeTime = 1.5;
+// 			e.ParticleScale.push_back(1);
+// 			e.ParticleScale.push_back(6);
+// 			e.ParticlesToSpawn = 20;
+// 			e.Position = shellTransform->Position;
+// 			e.SpreadAngle = glm::radians<float>(180)/ 4;
+// 			e.RelativeUpOrientation = glm::angleAxis(glm::radians<float>(90), glm::vec3(1,0,0));
+// 			e.UseGoalVector = true;
+// 			e.GoalVelocity = glm::vec3(0,-12,0);
+// 			e.Speed = 12;
+// 			e.spritePath = "Textures/Sprites/Splash.png";
+// 			e.Color = glm::vec4(1.f,1.f,1.f,1);
+// 			EventBroker->Publish(e);
 		}
 		{
 			Events::PlaySFX e;
@@ -460,9 +521,13 @@ EntityID Systems::TankSteeringSystem::CreateTank(int playerID)
 	player->ID = playerID;
 	auto tankSteering = m_World->AddComponent<Components::TankSteering>(tank);
 	m_World->AddComponent<Components::Input>(tank);
-	auto health = m_World->AddComponent<Components::Health>(tank);
-	health->Amount = 100.f;
 	m_World->AddComponent<Components::Listener>(tank);
+	auto health = m_World->AddComponent<Components::Health>(tank);
+	health->Amount = 200.f;
+	
+	
+
+	
 	
 	{
 		auto shape = m_World->CreateEntity(tank);
@@ -532,8 +597,8 @@ EntityID Systems::TankSteeringSystem::CreateTank(int playerID)
 					auto shape = m_World->CreateEntity(shot);
 					auto transform = m_World->AddComponent<Components::Transform>(shape);
 					auto boxShape = m_World->AddComponent<Components::BoxShape>(shape);
-					boxShape->Width = 0.5f;
+					boxShape->Width = 0.1f;
-					boxShape->Height = 0.5f;
+					boxShape->Height = 0.1f;
 					boxShape->Depth = 0.5f;
 					m_World->CommitEntity(shape);
 				}
@@ -549,6 +614,8 @@ EntityID Systems::TankSteeringSystem::CreateTank(int playerID)
 					transform->Orientation = glm::quat(glm::vec3(-glm::radians(5.f), 0.f, 0.f));
 					auto cameraComp = m_World->AddComponent<Components::Camera>(cameraTower);
 					cameraComp->FarClip = 2000.f;
+
+
 					/*auto follow = m_World->AddComponent<Components::Follow>(cameraTower);
 					follow->Entity = barrel;
 					follow->Distance = 15.f;
@@ -597,31 +664,43 @@ EntityID Systems::TankSteeringSystem::CreateTank(int playerID)
 	AddTankWheelPair(tank, glm::vec3(-1.68f, wheelOffset, 2.375), 1, false);
 #pragma endregion
 
+#pragma region DustParticles
+
+	std::vector<glm::vec3> ePos;
+	ePos.push_back(glm::vec3(-2, -1.7, 2.0));
+	ePos.push_back(glm::vec3(2, -1.7, 2.0));
+	ePos.push_back(glm::vec3(2, -1.7, -2.0));
+	ePos.push_back(glm::vec3(-2, -1.7, -2.0));
+
+	for (int i = 0; i < 4; i++)
 	{
 		auto entity = m_World->CreateEntity(tank);
 		auto transformComponent = m_World->AddComponent<Components::Transform>(entity);
-		transformComponent->Position = glm::vec3(-2, -1.7, 2.0);
+		transformComponent->Position = ePos[i];
 		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->SpawnCount = 1;
-		emitterComponent->SpawnFrequency = 0.005;
+		emitterComponent->SpawnFrequency = 0.1;
 		emitterComponent->SpreadAngle = glm::pi<float>();
 		emitterComponent->UseGoalVelocity = false;
-		emitterComponent->LifeTime = 0.5;
+		emitterComponent->LifeTime = 0.3;
-		//emitterComponent->AngularVelocitySpectrum.push_back(glm::pi<float>() / 100);
+		emitterComponent->Speed = 3;
-		emitterComponent->ScaleSpectrum.push_back(glm::vec3(0.05));
+		emitterComponent->Emitting = true;
-		m_World->CommitEntity(entity);
+		emitterComponent->Fade = true;
-
+		emitterComponent->ScaleSpectrum.push_back(glm::vec3(1));
+		//emitterComponent->Color = glm::vec4(1);
 		auto particleEntity = m_World->CreateEntity(entity);
-		auto TEMP = m_World->AddComponent<Components::Transform>(particleEntity);
+		m_World->AddComponent<Components::Template>(particleEntity);
-		TEMP->Scale = glm::vec3(0);
+		m_World->AddComponent<Components::Transform>(particleEntity);
 		auto spriteComponent = m_World->AddComponent<Components::Sprite>(particleEntity);
-		spriteComponent->SpriteFile = "Models/Textures/Sprites/Dust.png";
+		spriteComponent->SpriteFile = "Textures/Sprites/Dirt.png"; 
-		emitterComponent->ParticleTemplate = particleEntity;
-
 		m_World->CommitEntity(particleEntity);
+		emitterComponent->ParticleTemplate = particleEntity;
+		m_World->CommitEntity(entity);
 	}
+#pragma endregion
+		
 
 	m_World->CommitEntity(tank);
 

src/Systems/TankSteeringSystem.h

@@ -1,5 +1,4 @@
 #include <array>
-
 #include "System.h"
 #include "Events/TankSteer.h"
 #include "Events/SetVelocity.h"
@@ -24,6 +23,7 @@
 #include "Components/TankShell.h"
 #include "Components/SphereShape.h"
 #include "Components/Listener.h"
+#include "Components/SoundEmitter.h"
 
 #include "Events/EnableCollisions.h"
 #include "Events/DisableCollisions.h"
@@ -33,6 +33,7 @@
 
 #include "Events/PlaySFX.h"
 #include "Events/PlayBGM.h"
+#include "Events/Dead.h"
 
 #include "Events/Damage.h"
 #include "Components/Vehicle.h"

src/Systems/TowerSystem.cpp

@@ -7,12 +7,15 @@ void Systems::TowerSystem::RegisterComponents( ComponentFactory* cf )
 	cf->Register<Components::Tower>([]() { return new Components::Tower(); });
 	cf->Register<Components::Turret>([]() { return new Components::Turret(); });
 	cf->Register<Components::TurretShot>([]() {return new Components::TurretShot(); });
+	cf->Register<Components::TowerDebris>([]() {return new Components::TowerDebris(); });
 }
 
 void Systems::TowerSystem::Initialize()
 {
 	//EVENT_SUBSCRIBE_MEMBER(m_eDamage, &Systems::TowerSystem::Damage);
 	EVENT_SUBSCRIBE_MEMBER(m_ECollision, &Systems::TowerSystem::OnCollision);
+	EVENT_SUBSCRIBE_MEMBER(m_eDamage, &Systems::TowerSystem::Damage);
+
 	Temp_m_TimeSinceLastShot = 0;
 }
 
@@ -21,6 +24,58 @@ void Systems::TowerSystem::Update( double dt )
 
 }
 
+bool Systems::TowerSystem::Damage( const Events::Damage &event )
+{
+	auto debrisComponent = m_World->GetComponent<Components::TowerDebris>(event.Entity);
+	if(!debrisComponent)
+	{
+		return false;
+	}
+	LOG_INFO("TowerSystem::Damage");
+
+	// Change to damage model
+
+	auto wallhealthcomponent = m_World->GetComponent<Components::Health>(event.Entity);
+	if(wallhealthcomponent->Amount > 0)
+	{
+		return false;
+	}
+	LOG_INFO("Entity %i is dead", event.Entity);
+	auto entitytransform = m_World->GetComponent<Components::Transform>(event.Entity);
+	if(!entitytransform)
+		return false;
+	//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 : debrisComponent->TowerDebrisIDs)
+	{
+		auto debris = m_World->CloneEntity(d);
+
+		auto transform = m_World->GetComponent<Components::Transform>(debris);
+		Components::Transform absolutetransformComponent = m_World->GetSystem<Systems::TransformSystem>()->AbsoluteTransform(debris);
+		transform->Orientation = transform->Orientation * transformComponent.Orientation;
+		transform->Position = transform->Orientation * transform->Position + transformComponent.Position;
+
+		//DO STUFF! :D
+		float distance = glm::distance(transform->Position, transformComponent.Position);
+		float radius = 15.f;
+		float strength = (1.f - pow(distance / radius, 2)) * 2000.f;
+		glm::vec3 direction = glm::normalize(transformComponent.Position - transform->Position);
+
+		Events::ApplyPointImpulse e;
+		e.Entity = debris;
+		e.Impulse = direction * strength;
+		e.Position = transformComponent.Position;
+		EventBroker->Publish(e);
+
+	}
+
+	entitytransform->Position = glm::vec3(0.f, -50000000.f, 0.f);
+
+	return true;
+}
+
 void Systems::TowerSystem::UpdateEntity( double dt, EntityID entity, EntityID parent )
 {
 	auto towerComponent = m_World->GetComponent<Components::Tower>(entity);
@@ -48,7 +103,7 @@ void Systems::TowerSystem::UpdateEntity( double dt, EntityID entity, EntityID pa
 	for(auto player : *players)
 	{
 		auto playerComponent = std::dynamic_pointer_cast<Components::Player>(player);
-		if(towerComponent->ID != playerComponent->ID) //!= betyder att den bara targetar sitt eget lag, == fienden.
+		if(towerComponent->ID == playerComponent->ID) //!= betyder att den bara targetar sitt eget lag, == fienden.
 			continue;
 
 		auto playerTransform = m_World->GetComponent<Components::Transform>(player->Entity);

src/Systems/TowerSystem.h

@@ -9,10 +9,14 @@
 #include "Components/Turret.h"
 #include "Components/TurretShot.h"
 #include "Components/Health.h"
+#include "Components/TowerDebris.h"
+#include "Components/Model.h"
 #include "Events/SetVelocity.h"
 #include "Events/CreateExplosion.h"
 #include "Events/Collision.h"
 #include "Events/Damage.h"
+#include "Events/ApplyPointImpulse.h"
+
 
 
 
@@ -37,6 +41,8 @@ namespace Systems
 
 		EventRelay<TowerSystem, Events::Collision> m_ECollision;
 		bool OnCollision(const Events::Collision &e);
+		EventRelay<TowerSystem, Events::Damage> m_eDamage;
+		bool Damage(const Events::Damage &event);
 
 
 	private:

src/Systems/TriggerSystem.cpp

@@ -53,18 +53,6 @@ bool Systems::TriggerSystem::OnEnterTrigger( const Events::EnterTrigger &event )
 	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)
-	{
-		Flag(event.Entity, event.Trigger);
-	}
-	else if (flagComponent2)
-	{
-		Flag(event.Trigger, event.Entity);
-	}
 	
 
 	auto triggerMoveComponent = m_World->GetComponent<Components::TriggerMove>(event.Trigger);
@@ -148,20 +136,6 @@ void Systems::TriggerSystem::Move(EntityID entity, bool queue, bool swap)
 	}
 }
 
-
-void Systems::TriggerSystem::Flag( EntityID entity, EntityID phantomEntity )
-{
-	auto tankSteering = m_World->GetComponent<Components::TankSteering>(entity);
-	if (!tankSteering)
-		return;
-
-	m_World->RemoveComponent<Components::Trigger>(phantomEntity);
-	m_World->SetEntityParent(phantomEntity, entity);
-	auto phantomTransform = m_World->GetComponent<Components::Transform>(phantomEntity);
-	phantomTransform->Position = glm::vec3(-1.5f, 0.1f, 2.f);
-}
-
-
 void Systems::TriggerSystem::Explosion( EntityID entity, EntityID phantomEntity )
 {
 	/*auto transformComponent = m_World->GetComponent<Components::Transform>(entity);

src/Systems/TriggerSystem.h

@@ -48,7 +48,6 @@ namespace Systems
 		EventRelay<TriggerSystem, Events::LeaveTrigger> m_ELeaveTrigger;
 		bool OnLeaveTrigger(const Events::LeaveTrigger &event);
 	private:
-		void Flag(EntityID entity, EntityID phantomEntity);
 		void Explosion(EntityID entity, EntityID phantomEntity);
 		void Move(EntityID entity, bool queue, bool swap);
 		void Rotate(EntityID entity, bool queue, bool swap);

src/Systems/WallSystem.h

@@ -4,7 +4,7 @@
 
 #include "System.h"
 #include "Systems/TransformSystem.h"
-#include "Events/OnDead.h"
+#include "Events/Dead.h"
 #include "Events/Damage.h"
 #include "Events/ApplyPointImpulse.h"
 #include "Components/Model.h"

src/World.cpp

@@ -79,11 +79,13 @@ bool World::ValidEntity(EntityID entity)
 void World::RemoveEntity(EntityID entity)
 {
 	m_EntitiesToRemove.insert(entity);
-	for (auto pair : m_EntityParents)
+
+	auto it = m_EntityChildren.find(entity);
+	if (it != m_EntityChildren.end())
 	{
-		if (pair.second == entity)
+		for (auto entity : it->second)
 		{
-			m_EntitiesToRemove.insert(pair.first);
+			RemoveEntity(entity);
 		}
 	}
 }

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\FlagSystem.cpp" />
     <ClCompile Include="..\..\src\Systems\JeepSteeringSystem.cpp" />
     <ClCompile Include="..\..\src\Systems\DamageSystem.cpp" />
     <ClCompile Include="..\..\src\Systems\DebugSystem.cpp" />
@@ -151,6 +152,7 @@
     <ClInclude Include="..\..\src\Components\Rotate.h" />
     <ClInclude Include="..\..\src\Components\Tower.h" />
     <ClInclude Include="..\..\src\Components\Team.h" />
+    <ClInclude Include="..\..\src\Components\TowerDebris.h" />
     <ClInclude Include="..\..\src\Components\TriggerMove.h" />
     <ClInclude Include="..\..\src\Components\Timer.h" />
     <ClInclude Include="..\..\src\Components\TriggerExplosion.h" />
@@ -218,7 +220,7 @@
     <ClInclude Include="..\..\src\Events\MouseMove.h" />
     <ClInclude Include="..\..\src\Events\MousePress.h" />
     <ClInclude Include="..\..\src\Events\MouseRelease.h" />
-    <ClInclude Include="..\..\src\Events\OnDead.h" />
+    <ClInclude Include="..\..\src\Events\Dead.h" />
     <ClInclude Include="..\..\src\Events\Move.h" />
     <ClInclude Include="..\..\src\Events\PlayBGM.h" />
     <ClInclude Include="..\..\src\Events\PlaySFX.h" />
@@ -255,6 +257,7 @@
     <ClInclude Include="..\..\src\Skybox.h" />
     <ClInclude Include="..\..\src\Sound.h" />
     <ClInclude Include="..\..\src\System.h" />
+    <ClInclude Include="..\..\src\Systems\FlagSystem.h" />
     <ClInclude Include="..\..\src\Systems\JeepSteeringSystem.h" />
     <ClInclude Include="..\..\src\Systems\DamageSystem.h" />
     <ClInclude Include="..\..\src\Systems\DebugSystem.h" />

vs11/Returngeance/Returngeance.vcxproj.filters

@@ -101,6 +101,9 @@
     <ClCompile Include="..\..\src\Systems\WallSystem.cpp">
       <Filter>Game\Systems</Filter>
     </ClCompile>
+    <ClCompile Include="..\..\src\Systems\FlagSystem.cpp">
+      <Filter>Game\Systems</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <Filter Include="Util">
@@ -600,13 +603,13 @@
     </ClInclude>
     <ClInclude Include="..\..\src\Components\TurretShot.h">
       <Filter>Physics\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">
       <Filter>GUI</Filter>
@@ -650,6 +653,12 @@
     <ClInclude Include="..\..\src\Components\DamageModel.h">
       <Filter>Rendering\Components</Filter>
     </ClInclude>
+    <ClInclude Include="..\..\src\Systems\FlagSystem.h">
+      <Filter>Game\Systems</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\Events\OnDead.h" />
+    <ClInclude Include="..\..\src\Systems\WallSystem.h" />
+    <ClInclude Include="..\..\src\Events\Dead.h" />
   </ItemGroup>
   <ItemGroup>
     <None Include="..\..\src\Shaders\Fragment2.glsl">