Skybox working, flag for averaging normals working.

src/Components/Model.h

@@ -10,12 +10,13 @@ namespace Components
 
 struct Model : Component
 {
-	Model() : Color(glm::vec4(1.0f, 1.0f, 1.0f, 1.0f)), Visible(true), ShadowCaster(true), Transparent(false) { }
+	Model() : Color(glm::vec4(1.0f, 1.0f, 1.0f, 1.0f)), Visible(true), ShadowCaster(true), Transparent(false), AverageNormals(false) { }
 	std::string ModelFile;
 	glm::vec4 Color;
 	bool Visible;
 	bool ShadowCaster;
 	bool Transparent;
+	bool AverageNormals;
 
 	virtual Model* Clone() const override { return new Model(*this); }
 };

src/Engine.h

@@ -22,7 +22,8 @@ public:
 		m_ResourceManager = std::make_shared<ResourceManager>();
 		m_ResourceManager->RegisterType("OBJ", [](std::string resourceName) { return new OBJ(resourceName); });
 		auto rm = m_ResourceManager;
-		m_ResourceManager->RegisterType("Model", [rm](std::string resourceName) { return new Model(rm, *rm->Load<OBJ>("OBJ", resourceName)); });
+		m_ResourceManager->RegisterType("Model", [rm](std::string resourceName) { return new Model(rm, *rm->Load<OBJ>("OBJ", resourceName), false); });
+		m_ResourceManager->RegisterType("AveragedModel", [rm](std::string resourceName) { return new Model(rm, *rm->Load<OBJ>("OBJ", resourceName), true); });
 		m_ResourceManager->RegisterType("Texture", [](std::string resourceName) { return new Texture(resourceName); });
 
 		m_FrameStack = new GUI::Frame(m_EventBroker, m_ResourceManager); 

src/GUI/WorldFrame.h

@@ -55,7 +55,17 @@ public:
 			auto modelComponent = m_World->GetComponent<Components::Model>(entity);
 			if (modelComponent)
 			{
-				auto modelAsset = ResourceManager->Load<Model>("Model", modelComponent->ModelFile);
+				Model* modelAsset = nullptr;
+				if (modelComponent->AverageNormals)
+				{
+					modelAsset = ResourceManager->Load<Model>("AveragedModel", modelComponent->ModelFile);
+				}
+				else
+				{
+					modelAsset = ResourceManager->Load<Model>("Model", modelComponent->ModelFile);
+				}
+
+				
 				if (modelAsset)
 				{
 					Components::Transform absoluteTransform = m_TransformSystem->AbsoluteTransform(entity);

src/GameWorld.cpp

@@ -634,7 +634,7 @@ void GameWorld::CreateGate(EntityID parent, glm::vec3 position, glm::quat orient
 	}
 }
 
-EntityID GameWorld::CreateTower(EntityID parent, glm::vec3 pos, int playerID)
+EntityID GameWorld::CreateTower(EntityID parent, glm::vec3 pos, int teamID)
 {
 	auto towerBase = CreateEntity(parent);
 	auto transform = AddComponent<Components::Transform>(towerBase);
@@ -642,9 +642,9 @@ EntityID GameWorld::CreateTower(EntityID parent, glm::vec3 pos, int playerID)
 
 	auto towerComponent = AddComponent<Components::Tower>(towerBase);
 
-// 	auto physics = AddComponent<Components::Physics>(towerBase);
+ 	auto physics = AddComponent<Components::Physics>(towerBase);
-// 	physics->Mass = 100.f;
+ 	physics->Mass = 100.f;
-// 	physics->MotionType = Components::Physics::MotionTypeEnum::Fixed;
+ 	physics->MotionType = Components::Physics::MotionTypeEnum::Fixed;
 
 	auto model = AddComponent<Components::Model>(towerBase);
 	model->ModelFile = "Models/Turret/Base/Base.obj";
@@ -652,12 +652,12 @@ EntityID GameWorld::CreateTower(EntityID parent, glm::vec3 pos, int playerID)
 	auto health = AddComponent<Components::Health>(towerBase);
 	health->Amount = 50.f;
 
-// 	auto shape = CreateEntity(towerBase);
+ 	auto shape = CreateEntity(towerBase);
-// 	auto shapetransform = AddComponent<Components::Transform>(shape);
+ 	auto shapetransform = AddComponent<Components::Transform>(shape);
-// 	auto shapemesh = AddComponent<Components::MeshShape>(shape);
+ 	auto shapemesh = AddComponent<Components::MeshShape>(shape);
-// 	shapemesh->ResourceName = "Models/Turret/Base/Base.obj";
+ 	shapemesh->ResourceName = "Models/Turret/Base/Base.obj";
 
-	//CommitEntity(shape);
+	CommitEntity(shape);
 	{
 		auto towerGunRotation = CreateEntity(towerBase);
 		auto transform = AddComponent<Components::Transform>(towerGunRotation);
@@ -687,7 +687,7 @@ EntityID GameWorld::CreateTower(EntityID parent, glm::vec3 pos, int playerID)
 	{
 		auto shot = CreateEntity(towerGun);
 		auto transform = AddComponent<Components::Transform>(shot);
-		transform->Position = glm::vec3(0.f, 0.f, -4.f);
+		transform->Position = glm::vec3(0.f, 0.f, -4.37612f);
 		transform->Orientation = glm::angleAxis(-glm::pi<float>() / 2.f, glm::vec3(1, 0, 0));
 		transform->Scale = glm::vec3(2.f);
 		AddComponent<Components::Template>(shot);
@@ -736,7 +736,7 @@ EntityID GameWorld::CreateTower(EntityID parent, glm::vec3 pos, int playerID)
 		towerComponent->GunBase = towerGunRotation;
 	}
 
-	towerComponent->ID = playerID;
+	towerComponent->ID = teamID;
 
 	auto turretComponent = AddComponent<Components::Turret>(towerBase);
 	turretComponent->ShotTemplate = m_ShotTemplate;
@@ -844,6 +844,7 @@ void GameWorld::CreateTerrain()
 		auto transform = AddComponent<Components::Transform>(ground_middle);
 		auto model = AddComponent<Components::Model>(ground_middle);
 		model->ModelFile = "Models/TerrainFiveIstles/Middle.obj";
+		model->AverageNormals = true;
 		auto blendmap = AddComponent<Components::BlendMap>(ground_middle);
 		blendmap->TextureRed = "Textures/Ground/SoilBeach0087_11_S.jpg";
 		blendmap->TextureRedNormal = "Textures/Ground/SoilBeach0087_11_SNM.png";
@@ -949,6 +950,7 @@ void GameWorld::CreateBase(glm::quat orientation, int teamID)
 		auto transform = AddComponent<Components::Transform>(ground_small);
 		auto model = AddComponent<Components::Model>(ground_small);
 		model->ModelFile = "Models/TerrainFiveIstles/Small.obj";
+		model->AverageNormals = true;
 		auto blendmap = AddComponent<Components::BlendMap>(ground_small);
 		blendmap->TextureRed = "Textures/Ground/SoilBeach0087_11_S.jpg";
 		blendmap->TextureRedNormal = "Textures/Ground/SoilBeach0087_11_SNM.png";
@@ -997,6 +999,7 @@ void GameWorld::CreateBase(glm::quat orientation, int teamID)
 		auto transform = AddComponent<Components::Transform>(bridge_middle);
 		auto model = AddComponent<Components::Model>(bridge_middle);
 		model->ModelFile = "Models/TerrainFiveIstles/Bridges/MiddleBridge.obj";
+		model->AverageNormals = false;
 		auto physics = AddComponent<Components::Physics>(bridge_middle);
 		physics->Mass = 10;
 		physics->MotionType = Components::Physics::MotionTypeEnum::Fixed;
@@ -1072,6 +1075,7 @@ void GameWorld::CreateBase(glm::quat orientation, int teamID)
 		auto transform = AddComponent<Components::Transform>(terrain_base);
 		auto model = AddComponent<Components::Model>(terrain_base);
 		model->ModelFile = "Models/TerrainFiveIstles/Base.obj";
+		model->AverageNormals = true;
 		auto blendmap = AddComponent<Components::BlendMap>(terrain_base);
 		blendmap->TextureRed = "Textures/Ground/SoilBeach0087_11_S.jpg";
 		blendmap->TextureRedNormal = "Textures/Ground/SoilBeach0087_11_SNM.png";
@@ -1140,6 +1144,7 @@ void GameWorld::CreateBase(glm::quat orientation, int teamID)
 		auto transform = AddComponent<Components::Transform>(bridge_base);
 		auto model = AddComponent<Components::Model>(bridge_base);
 		model->ModelFile = "Models/TerrainFiveIstles/Bridges/BaseBridge.obj";
+		model->AverageNormals = false;
 		auto physics = AddComponent<Components::Physics>(bridge_base);
 		physics->Mass = 10;
 		physics->MotionType = Components::Physics::MotionTypeEnum::Fixed;
@@ -1208,7 +1213,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), playerID);
+	CreateTower(base, glm::vec3(290.f, 40.3f, 15.f), teamID);
 
 	CreateGarage(base, glm::vec3(323.2f, 41.4f, -10.2f), glm::quat(glm::vec3(0, glm::pi<float>() / 2.f, 0)), teamID);
 }

src/Model.cpp

@@ -1,7 +1,7 @@
 #include "PrecompiledHeader.h"
 #include "Model.h"
 
-Model::Model(std::shared_ptr<ResourceManager> rm, OBJ &obj)
+Model::Model(std::shared_ptr<ResourceManager> rm, OBJ &obj, bool average)
 {
 	OBJ::MaterialInfo* currentMaterial = nullptr;
 	TextureGroup* currentTexGroup = nullptr;
@@ -93,7 +93,10 @@ Model::Model(std::shared_ptr<ResourceManager> rm, OBJ &obj)
 	if (Vertices.size() > 0)
 	{
 		CreateTangents();
-		//getSimilarVertexIndex();
+		if (average)
+		{
+			getSimilarVertexIndex();
+		}
 		CreateBuffers(Vertices, Normals, TangentNormals, BiTangentNormals, TextureCoords);
 	}
 	else

src/Model.h

@@ -17,7 +17,7 @@
 class Model : public Resource
 {
 public:
-	Model(std::shared_ptr<ResourceManager> resourceManager, OBJ &obj);
+	Model(std::shared_ptr<ResourceManager> resourceManager, OBJ &obj, bool average);
 
 	struct TextureGroup
 	{

src/Renderer.cpp

@@ -169,7 +169,7 @@ void Renderer::LoadContent()
 	FrameBufferTextures();
 
 	m_sphereModel = ResourceManager->Load<Model>("Model", "Models/Placeholders/PhysicsTest/Sphere.obj");
-	m_Skybox = std::make_shared<Skybox>("Textures/Skybox/sunset", "jpg");
+	m_Skybox = std::make_shared<Skybox>("Textures/Skybox/sky36", "jpg");
 }
 
 void Renderer::Draw(double dt)
@@ -376,6 +376,7 @@ void Renderer::DrawWorld(RenderQueuePair &rq)
 	glEnable(GL_DEPTH_TEST);
 	glDepthMask(GL_TRUE);
 	glEnable(GL_SCISSOR_TEST);
+	glDepthRange(0.0, 0.999);
 
 	//Sort forward rendering items by z value.
 	for(auto job : rq.Forward)
@@ -406,8 +407,7 @@ void Renderer::DrawWorld(RenderQueuePair &rq)
 
 	glCullFace(GL_BACK);
 	glEnable(GL_DEPTH_TEST);
-	//DrawSkybox();
+	
-
 	DrawFBOScene(rq.Deferred);
 
 	/*
@@ -552,6 +552,9 @@ void Renderer::ForwardRendering(RenderQueue &rq)
 	//glDepthMask (GL_TRUE);
 	//glDisable (GL_BLEND);
 
+	glDepthRange(0.999, 1.0);
+	DrawSkybox();
+	
 	/*
 	Final pass
 	*/
@@ -613,6 +616,8 @@ void Renderer::Swap()
 
 void Renderer::DrawSkybox()
 {
+// 	glEnable(GL_CULL_FACE);
+// 	glCullFace(GL_BACK);
 	//glBindFramebuffer(GL_FRAMEBUFFER, 0);
 	glViewport(m_Viewport.X, m_Height - m_Viewport.Y - m_Viewport.Height, m_Viewport.Width, m_Viewport.Height);
 	glScissor(m_Viewport.X, m_Height - m_Viewport.Y - m_Viewport.Height, m_Viewport.Width, m_Viewport.Height);
@@ -623,8 +628,10 @@ void Renderer::DrawSkybox()
 	//glm::mat4 cameraProjection = m_Camera->ProjectionMatrix((float)m_Viewport.Width / m_Viewport.Height);
 	//glm::mat4 cameraMatrix = cameraProjection * m_Camera->ViewMatrix();
 
-	glm::mat4 cameraMatrix = m_Camera->ProjectionMatrix((float)m_Viewport.Width / m_Viewport.Height) * glm::inverse(glm::toMat4(m_Camera->Orientation()));
+	glm::mat4 cameraMatrix = m_Camera->ProjectionMatrix((float)m_Viewport.Width / m_Viewport.Height);
-	glUniformMatrix4fv(glGetUniformLocation(m_ShaderProgramSkybox.GetHandle(), "MVP"), 1, GL_FALSE, glm::value_ptr(cameraMatrix));
+	glm::mat4 cameraView = glm::inverse(glm::toMat4(m_Camera->Orientation()));
+	glUniformMatrix4fv(glGetUniformLocation(m_ShaderProgramSkybox.GetHandle(), "V"), 1, GL_FALSE, glm::value_ptr(cameraView));
+	glUniformMatrix4fv(glGetUniformLocation(m_ShaderProgramSkybox.GetHandle(), "P"), 1, GL_FALSE, glm::value_ptr(cameraMatrix));
 	glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
 	m_Skybox->Draw();
 }

src/Shaders/Skybox.vert.glsl

@@ -1,6 +1,7 @@
 #version 430
 
-uniform mat4 MVP;
+uniform mat4 V;
+uniform mat4 P;
 
 layout(location = 0) in vec3 Position;
 
@@ -11,6 +12,7 @@ out VertexData
 
 void main()
 {
-	gl_Position = MVP * vec4(Position, 1.0);
+	vec4 pos = V * vec4(Position, 1.0);
+	gl_Position = P * pos;
 	Output.TextureCoord = Position;
 }

src/Systems/TowerSystem.cpp

@@ -12,6 +12,7 @@ void Systems::TowerSystem::RegisterComponents( ComponentFactory* cf )
 void Systems::TowerSystem::Initialize()
 {
 	//EVENT_SUBSCRIBE_MEMBER(m_eDamage, &Systems::TowerSystem::Damage);
+	EVENT_SUBSCRIBE_MEMBER(m_ECollision, &Systems::TowerSystem::OnCollision);
 	Temp_m_TimeSinceLastShot = 0;
 }
 
@@ -41,6 +42,8 @@ void Systems::TowerSystem::UpdateEntity( double dt, EntityID entity, EntityID pa
 		return;
 
 	auto players = m_World->GetComponentsOfType<Components::Player>();
+	if (!players)
+		return;
 
 	for(auto player : *players)
 	{
@@ -53,7 +56,9 @@ void Systems::TowerSystem::UpdateEntity( double dt, EntityID entity, EntityID pa
 			continue;
 
 		Components::Transform absolutePlayerTransform = m_World->GetSystem<Systems::TransformSystem>()->AbsoluteTransform(player->Entity);
-		
+
+		if(glm::distance(absolutePlayerTransform.Position, absoluteTowerGunTransform.Position) > 45.f)
+			continue;
 		//Rotate the turret towards the enemy player
 		glm::quat baseLookAt = glm::inverse(glm::quat_cast(glm::lookAt(absoluteTowerGunTransform.Position, glm::vec3(absolutePlayerTransform.Position.x, absoluteTowerGunTransform.Position.y, absolutePlayerTransform.Position.z), glm::vec3(0, 1, 0))));
 		glm::quat gunLookAt = glm::inverse(glm::quat_cast(glm::lookAt(absoluteTowerGunTransform.Position, glm::vec3(absolutePlayerTransform.Position.x, absolutePlayerTransform.Position.y, absolutePlayerTransform.Position.z ), glm::vec3(0, 1, 0))));
@@ -70,8 +75,9 @@ void Systems::TowerSystem::UpdateEntity( double dt, EntityID entity, EntityID pa
 				EntityID clone = m_World->CloneEntity(turretComponent->ShotTemplate);
 				auto templateAbsoluteTransform = m_World->GetSystem<Systems::TransformSystem>()->AbsoluteTransform(turretComponent->ShotTemplate);
 				auto cloneTransform = m_World->GetComponent<Components::Transform>(clone);
-				cloneTransform->Position = templateAbsoluteTransform.Position - glm::vec3(0.97163f, 0.f, 0.f);
 				cloneTransform->Orientation = templateAbsoluteTransform.Orientation;
+				cloneTransform->Position = templateAbsoluteTransform.Position - (cloneTransform->Orientation* glm::vec3(0.97163f, 0.f, 0.f));
+
 
 				Events::SetVelocity eSetVelocity;
 				eSetVelocity.Entity = clone;
@@ -113,8 +119,9 @@ void Systems::TowerSystem::UpdateEntity( double dt, EntityID entity, EntityID pa
 				EntityID clone = m_World->CloneEntity(turretComponent->ShotTemplate);
 				auto templateAbsoluteTransform = m_World->GetSystem<Systems::TransformSystem>()->AbsoluteTransform(turretComponent->ShotTemplate);
 				auto cloneTransform = m_World->GetComponent<Components::Transform>(clone);
-				cloneTransform->Position = templateAbsoluteTransform.Position + glm::vec3(0.97163f, 0.f, 0.f);
 				cloneTransform->Orientation = templateAbsoluteTransform.Orientation;
+				cloneTransform->Position = templateAbsoluteTransform.Position + (cloneTransform->Orientation * glm::vec3(0.97163f, 0.f, 0.f));
+
 
 				Events::SetVelocity eSetVelocity;
 				eSetVelocity.Entity = clone;
@@ -153,11 +160,169 @@ void Systems::TowerSystem::UpdateEntity( double dt, EntityID entity, EntityID pa
 			}
 
 			Temp_m_TimeSinceLastShot = 0;
-		
 #pragma endregion
-
 		}
 	}
-
+}
+
+bool Systems::TowerSystem::OnCollision(const Events::Collision &e)
+{
+	if(m_World->ValidEntity(e.Entity1) && m_World->ValidEntity(e.Entity2))
+	{
+		auto tankShell1 = m_World->GetComponent<Components::TurretShot>(e.Entity1);
+		auto tankShell2 = m_World->GetComponent<Components::TurretShot>(e.Entity2);
+
+		EntityID shellEntity = 0;
+		Components::TurretShot* shellComponent;
+		EntityID otherEntity = 0;
+
+		if (tankShell1)
+		{
+			shellEntity = e.Entity1;
+			otherEntity = e.Entity2;
+			shellComponent = tankShell1;
+		}
+		else if (tankShell2)
+		{
+			shellEntity = e.Entity2;
+			otherEntity = e.Entity1;
+			shellComponent = tankShell2;
+		}
+		else
+		{
+			return false;
+		}
+
+		if(m_World->GetComponent<Components::Template>(shellEntity))
+			return false;
+
+		//auto physicsComponents = m_World->GetComponentsOfType<Components::Physics>();
+		auto shellTransform = m_World->GetComponent<Components::Transform>(shellEntity);
+		//auto otherTransform = m_World->GetComponent<Components::Transform>(otherEntity);
+
+		
+		{
+			Events::CreateExplosion e;
+			e.LifeTime = 2;
+			e.ParticleScale.push_back(3);
+			e.ParticlesToSpawn = 10;
+			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, 0.1);
+			EventBroker->Publish(e);
+			e.LifeTime = 0.7;
+			e.ParticleScale.push_back(5);
+			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(5);
+			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;
+		//	e.MinDistance = 150.f;
+		//	e.Position = shellTransform->Position;
+		//	e.Resource = "Sounds/SFX/Explosion.wav";
+		//	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 = 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);
+		//	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);
+
+		//		Events::ApplyPointImpulse e;
+		//		e.Entity = physicsEntity;
+		//		e.Impulse = direction * strength;
+		//		e.Position = physEntityTransform.Position;
+		//		EventBroker->Publish(e);
+
+		//		auto health = m_World->GetComponent<Components::Health>(physicsEntity);
+		//		if (health && health->VulnerableToSplash)
+		//		{
+		//			Events::Damage d;
+		//			d.Entity = physicsEntity;
+		//			d.Amount =  (1.f - pow(distance / radius, 2)) * shellComponent->Damage;
+		//			EventBroker->Publish(d);
+		//		}
+		//		
+		//		
+		//	}
+		//}
+		m_World->RemoveEntity(shellEntity);
+
+	}
+	return true;
 }
 

src/Systems/TowerSystem.h

@@ -8,8 +8,13 @@
 #include "Components/Tower.h"
 #include "Components/Turret.h"
 #include "Components/TurretShot.h"
+#include "Components/Health.h"
 #include "Events/SetVelocity.h"
 #include "Events/CreateExplosion.h"
+#include "Events/Collision.h"
+#include "Events/Damage.h"
+
+
 
 
 
@@ -29,8 +34,10 @@ namespace Systems
 		virtual void Update(double dt);
 		virtual void UpdateEntity(double dt, EntityID entity, EntityID parent);
 
-		//EventRelay<TowerSystem, Events::Damage> m_eDamage;
+
-		//bool Damage(const Events::Damage &event);
+		EventRelay<TowerSystem, Events::Collision> m_ECollision;
+		bool OnCollision(const Events::Collision &e);
+
 
 	private:
 		std::map<EntityID, double> m_TimeSinceLastShot;