Broken helicopter

Conflicts:
	src/Components/Vehicle.h
	src/Systems/TankSteeringSystem.cpp
	vs11/Returngeance/Returngeance.vcxproj.filters

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/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/GUI/GameFrame.h

@@ -41,10 +41,10 @@ public:
 			m_FreeCamViewport = new Viewport(m_WorldFrame, "ViewportFreeCam", m_World);
 			m_FreeCamViewport->Hide();
 		}
-		//m_WorldFrame->Hide();
-		//m_MainMenuFrame = new MainMenuFrame(this, "MainMenu");
-
+		m_WorldFrame->Hide();
 		m_World->Initialize();
+
+		m_MainMenuFrame = new MainMenuFrame(this, "MainMenu");
 	}
 
 private:

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;
-				EventBroker->Publish(e);
+				Events::GameStart e1;
+				EventBroker->Publish(e1);
+				Events::PlayBGM e2;
+				e2.Resource = "Sounds/BGM/FlightOfTheBumblebee.mp3";
+				EventBroker->Publish(e2);
 			}
 			// Quit
 			else if (m_CurrentSelection == 1)

src/GameWorld.cpp

@@ -8,6 +8,13 @@ void GameWorld::Initialize()
 	ResourceManager->Preload("Model", "Models/Placeholders/PhysicsTest/Plane.obj");
 	ResourceManager->Preload("Model", "Models/Placeholders/PhysicsTest/ArrowCube.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);
@@ -44,7 +51,10 @@ 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::RightTrigger, "normal", 1.f);
 	BindGamepadAxis(Gamepad::Axis::LeftTrigger, "jeep_vertical", -1.f);
+	BindGamepadAxis(Gamepad::Axis::LeftTrigger, "normal", -1.f);
+
 
 	BindKey(GLFW_KEY_X, "use", 1.f);
 	BindGamepadButton(Gamepad::Button::X, "use", 1.f);
@@ -436,6 +446,7 @@ void GameWorld::RegisterSystems()
 	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::HelicopterSteeringSystem>([this]() { return new Systems::HelicopterSteeringSystem(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); });
@@ -461,6 +472,7 @@ void GameWorld::AddSystems()
 	AddSystem<Systems::FreeSteeringSystem>();
 	AddSystem<Systems::TankSteeringSystem>();
 	AddSystem<Systems::JeepSteeringSystem>();
+	AddSystem<Systems::HelicopterSteeringSystem>();
 	AddSystem<Systems::WheelPairSystem>();
 	AddSystem<Systems::SoundSystem>();
 	AddSystem<Systems::PhysicsSystem>();

src/InputManager.cpp

@@ -85,6 +85,28 @@ void InputManager::Update(double dt)
 		EventBroker->Publish(e);
 	}
 
+	
+	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/GameStateSystem.cpp

@@ -11,9 +11,12 @@ bool Systems::GameStateSystem::OnFlagCaptured(const Events::FlagCaptured &event)
 {
 	m_InGame = false;
 
-	Events::GameOver e;
-	e.Winner = event.Player;
-	EventBroker->Publish(e);
+	Events::GameOver e1;
+	e1.Winner = event.Player;
+	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/HelicopterSteeringSystem.cpp

@@ -9,6 +9,8 @@ void Systems::HelicopterSteeringSystem::RegisterComponents(ComponentFactory* cf)
 
 void Systems::HelicopterSteeringSystem::Initialize()
 {
+	EVENT_SUBSCRIBE_MEMBER(m_ESpawnVehicle, &Systems::HelicopterSteeringSystem::OnSpawnVehicle);
+
 	m_InputController = std::unique_ptr<HelicopterSteeringInputController>(new HelicopterSteeringInputController(EventBroker));
 }
 
@@ -37,6 +39,117 @@ void Systems::HelicopterSteeringSystem::UpdateEntity(double dt, EntityID entity,
 	}
 }
 
+bool Systems::HelicopterSteeringSystem::OnSpawnVehicle(const Events::SpawnVehicle &event)
+{
+	if (event.VehicleType != "Helicopter")
+		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 tank
+		EntityID tank = CreateHelicopter(event.PlayerID);
+		auto tankTransform = m_World->GetComponent<Components::Transform>(tank);
+		tankTransform->Position = absoluteTransform.Position + glm::vec3(0, 10, 0);
+		tankTransform->Orientation = absoluteTransform.Orientation * glm::angleAxis(glm::pi<float>() / 2.f, glm::vec3(0, 1, 0)); 
+		// Set the viewport correctly
+		Events::SetViewportCamera e;
+		e.CameraEntity = m_World->GetProperty<EntityID>(tank, "Camera");
+		if (event.PlayerID == 1)
+			e.ViewportFrame = "Viewport1";
+		else if (event.PlayerID == 2)
+			e.ViewportFrame = "Viewport2";
+		EventBroker->Publish(e);
+	}
+
+	return true;
+}
+
+EntityID Systems::HelicopterSteeringSystem::CreateHelicopter(int playerID)
+{
+	auto heli = m_World->CreateEntity();
+	{
+		{
+			auto transform = m_World->AddComponent<Components::Transform>(heli);
+			transform->Position = glm::vec3(0.f, 3.f, 10.f);
+			auto physics = m_World->AddComponent<Components::Physics>(heli);
+			physics->Mass = 3000;
+			physics->MotionType = Components::Physics::MotionTypeEnum::Dynamic;
+			auto heliComponent = m_World->AddComponent<Components::HelicopterSteering>(heli);
+
+			auto player = m_World->AddComponent<Components::Player>(heli);
+			player->ID = playerID;
+			m_World->AddComponent<Components::Input>(heli);
+			m_World->AddComponent<Components::Listener>(heli);
+			auto health = m_World->AddComponent<Components::Health>(heli);
+			health->Amount = 100.f;
+		}
+
+		auto model = m_World->CreateEntity(heli);
+		{
+			auto transform = m_World->AddComponent<Components::Transform>(model);
+			transform->Orientation = glm::quat(glm::vec3(0, -glm::pi<float>() / 2.f, 0.f));
+			auto modelComponent = m_World->AddComponent<Components::Model>(model);
+			modelComponent->ModelFile = "Models/Heli/Chassi/Chassi.obj";
+		}
+		m_World->CommitEntity(model);
+
+		auto shape = m_World->CreateEntity(heli);
+		{
+			auto transform = m_World->AddComponent<Components::Transform>(shape);
+			auto box = m_World->AddComponent<Components::BoxShape>(shape);
+			box->Width = 5.f;
+			box->Height = 1.8f;
+			box->Depth = 7.f;
+		}
+		m_World->CommitEntity(shape);
+
+
+		auto camera = m_World->CreateEntity(heli);
+		{
+			auto transform = m_World->AddComponent<Components::Transform>(camera);
+			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>(camera);
+			cameraComp->FarClip = 2000.f;
+
+
+			/*auto follow = m_World->AddComponent<Components::Follow>(cameraTower);
+			follow->Entity = barrel;
+			follow->Distance = 15.f;
+			follow->FollowAxis = glm::vec3(1, 1, 1);*/
+			m_World->SetProperty(heli, "Camera", camera);
+		}
+		m_World->CommitEntity(camera);
+
+	}
+	m_World->CommitEntity(heli);
+
+	return heli;
+}
+
 bool Systems::HelicopterSteeringSystem::HelicopterSteeringInputController::OnCommand(const Events::InputCommand &event)
 {
 	if (event.Command == "horizontal")

src/Systems/HelicopterSteeringSystem.h

@@ -3,7 +3,58 @@
 #include "Components/HelicopterSteering.h"
 #include "Events/SetVelocity.h"
 #include "Events/ApplyForce.h"
+#include "Events/SpawnVehicle.h"
 #include "InputController.h"
+#include "Events/TankSteer.h"
+#include "Events/SetVelocity.h"
+#include "Events/ApplyForce.h"
+#include "Events/ApplyPointImpulse.h"
+#include "Events/CreateExplosion.h"
+#include "Events/Collision.h"
+#include "Components/Transform.h"
+#include "Components/TankSteering.h"
+#include "Components/TowerSteering.h"
+#include "Components/BarrelSteering.h"
+#include "Components/Physics.h"
+#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"
+
+#include "Components/Health.h"
+#include "Components/TankShell.h"
+#include "Components/SphereShape.h"
+#include "Components/Listener.h"
+#include "Components/SoundEmitter.h"
+
+#include "Events/EnableCollisions.h"
+#include "Events/DisableCollisions.h"
+#include "Components/Trigger.h"
+#include "Components/TriggerExplosion.h"
+#include "Components/FrameTimer.h"
+
+#include "Events/PlaySFX.h"
+#include "Events/PlayBGM.h"
+
+#include "Events/Damage.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 "Events/SetViewportCamera.h"
+#include "Events/GameOver.h"
 
 namespace Systems
 {
@@ -22,6 +73,9 @@ public:
 	void UpdateEntity(double dt, EntityID entity, EntityID parent) override;
 
 private:
+	EventRelay<HelicopterSteeringSystem, Events::SpawnVehicle> m_ESpawnVehicle;
+	bool OnSpawnVehicle(const Events::SpawnVehicle &e);
+	EntityID CreateHelicopter(int PlayerID);
 	class HelicopterSteeringInputController;
 	std::unique_ptr<HelicopterSteeringInputController> m_InputController;
 

src/Systems/PhysicsSystem.cpp

@@ -254,7 +254,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();

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, &isPlaying);
-		if(isPlaying)
+		FMOD_Channel_IsPlaying(it->second, &m_isPlaying);
+		if(m_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, &isPlaying);
-		if(!isPlaying)
+		FMOD_Channel_IsPlaying(it->second, &m_isPlaying);
+		if(!m_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();
-	auto eTransform = m_World->AddComponent<Components::Transform>(emitter);
-	auto eComponent = m_World->AddComponent<Components::SoundEmitter>(emitter);
-	m_Channels[emitter] = m_BGMChannel;
-	eComponent->type = Components::SoundEmitter::SoundType::SOUND_3D;
+	FMOD_RESULT result;
+	result = FMOD_Channel_Stop(m_BGMChannel);
+	if(result != FMOD_OK)	
+		LOG_INFO("FMOD error! (%d) %s\n", result, FMOD_ErrorString(result));
 	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,32 @@ 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)
+	{
+		if(!m_World->GetComponent<Components::TankSteering>(parent))
+			return;
+		auto tankTransform = m_World->GetComponent<Components::Transform>(parent);
+		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 tankSteeringComponent = m_World->GetComponent<Components::TankSteering>(entity);
 	if(!tankSteeringComponent)
 		return;
@@ -146,15 +172,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)
@@ -226,33 +243,63 @@ bool Systems::TankSteeringSystem::OnCollision(const Events::Collision &e)
 			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);
-
+			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 = 1.5;
-			e.ParticleScale.push_back(1);
-			e.ParticleScale.push_back(6);
-			e.ParticlesToSpawn = 20;
+			e.LifeTime = 0.7;
+			e.ParticleScale.push_back(12);
+			e.ParticlesToSpawn = 10;
 			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);
+			e.RelativeUpOrientation = glm::angleAxis(glm::pi<float>() / 2, glm::vec3(1,0,0));
+			e.Speed = 17;
+			e.SpreadAngle = glm::pi<float>();
+			e.spritePath = "Textures/Sprites/Fire.png";
+			EventBroker->Publish(e);
+			e.LifeTime = 0.2;
+			e.ParticleScale.push_back(1);
+			e.ParticleScale.push_back(15);
+			e.ParticlesToSpawn = 5;
+			e.Position = shellTransform->Position;
+			e.RelativeUpOrientation = glm::angleAxis(glm::pi<float>() / 2, glm::vec3(1,0,0));
+			e.Speed = 6;
+			e.SpreadAngle = glm::pi<float>();
+			e.spritePath = "Textures/Sprites/Blast1.png";
+			e.Color = glm::vec4(2, 2, 2, 0.2);
 			EventBroker->Publish(e);*/
+			
+// 			Events::CreateExplosion e;
+// 			e.LifeTime = 1.5;
+// 			e.ParticleScale.push_back(1);
+// 			e.ParticleScale.push_back(6);
+// 			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,10 +507,14 @@ EntityID Systems::TankSteeringSystem::CreateTank(int playerID)
 	player->ID = playerID;
 	auto tankSteering = m_World->AddComponent<Components::TankSteering>(tank);
 	m_World->AddComponent<Components::Input>(tank);
+	m_World->AddComponent<Components::Listener>(tank);
 	auto health = m_World->AddComponent<Components::Health>(tank);
 	health->Amount = 100.f;
-	m_World->AddComponent<Components::Listener>(tank);
+	
+	
 
+	
+	
 	{
 		auto shape = m_World->CreateEntity(tank);
 		auto transform = m_World->AddComponent<Components::Transform>(shape);
@@ -549,6 +600,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 +650,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->SpawnFrequency = 0.005;
+		emitterComponent->SpawnCount = 1;
+		emitterComponent->SpawnFrequency = 0.1;
 		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);
-
+		emitterComponent->LifeTime = 0.3;
+		emitterComponent->Speed = 3;
+		emitterComponent->Emitting = true;
+		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);
-		TEMP->Scale = glm::vec3(0);
+		m_World->AddComponent<Components::Template>(particleEntity);
+		m_World->AddComponent<Components::Transform>(particleEntity);
 		auto spriteComponent = m_World->AddComponent<Components::Sprite>(particleEntity);
-		spriteComponent->SpriteFile = "Models/Textures/Sprites/Dust.png";
-		emitterComponent->ParticleTemplate = particleEntity;
-
+		spriteComponent->SpriteFile = "Textures/Sprites/Dirt.png"; 
 		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"

vs11/Returngeance/Returngeance.vcxproj.filters

@@ -650,6 +650,8 @@
     <ClInclude Include="..\..\src\Components\DamageModel.h">
       <Filter>Rendering\Components</Filter>
     </ClInclude>
+    <ClInclude Include="..\..\src\Events\OnDead.h" />
+    <ClInclude Include="..\..\src\Systems\WallSystem.h" />
   </ItemGroup>
   <ItemGroup>
     <None Include="..\..\src\Shaders\Fragment2.glsl">