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

# Conflicts:
#	resources/Schema/Entities/Player.xml

src/Game/CMakeLists.txt

@@ -16,6 +16,12 @@ file(GLOB SOURCE_FILES_Systems
 )
 source_group(Systems FILES ${SOURCE_FILES_Systems})
 
+file(GLOB SOURCE_FILES_Systems_Weapon
+    "${INCLUDE_PATH}/Systems/Weapon/*.h"
+    "Systems/Weapon/*.cpp"
+)
+source_group(Systems\\Weapon FILES ${SOURCE_FILES_Systems_Weapon})
+
 file(GLOB SOURCE_FILES_Events
 	"${INCLUDE_PATH}/Events/*.h"
 	"Events/*.cpp"
@@ -31,6 +37,7 @@ set(SOURCE_FILES
     ${SOURCE_FILES}
     "Game.cpp"
     ${SOURCE_FILES_Systems}
+    ${SOURCE_FILES_Systems_Weapon}
     ${SOURCE_FILES_Events}
 	${SOURCE_FILES_Network}
 )

src/Game/Game.cpp

@@ -15,7 +15,7 @@
 #include "Game/Systems/CapturePointHUDSystem.h"
 #include "Game/Systems/PickupSpawnSystem.h"
 #include "Game/Systems/DamageIndicatorSystem.h"
-#include "Game/Systems/WeaponSystem.h"
+#include "Game/Systems/Weapon/WeaponSystem.h"
 #include "Rendering/AnimationSystem.h"
 #include "Game/Systems/HealthHUDSystem.h"
 #include "Rendering/BoneAttachmentSystem.h"

src/Game/Systems/DamageIndicatorSystem.cpp

@@ -3,7 +3,7 @@
 DamageIndicatorSystem::DamageIndicatorSystem(SystemParams params)
     : System(params)
 {
-    EVENT_SUBSCRIBE_MEMBER(m_DamageTakenFromPlayer, &DamageIndicatorSystem::OnPlayerDamageTaken);
+    EVENT_SUBSCRIBE_MEMBER(m_EPlayerDamage, &DamageIndicatorSystem::OnPlayerDamage);
     //current camera
     EVENT_SUBSCRIBE_MEMBER(m_ESetCamera, &DamageIndicatorSystem::OnSetCamera);
 
@@ -12,23 +12,27 @@ DamageIndicatorSystem::DamageIndicatorSystem(SystemParams params)
     auto entityFile = ResourceManager::Load<EntityFile>("Schema/Entities/DamageIndicator.xml");
 }
 
-bool DamageIndicatorSystem::OnPlayerDamageTaken(Events::PlayerDamage& e)
+bool DamageIndicatorSystem::OnPlayerDamage(Events::PlayerDamage& e)
 {
-    if (m_CurrentCamera == -1) {
+    if (m_CurrentCamera == EntityID_Invalid) {
+        return false;
+    }
+
+    if (e.Victim != LocalPlayer) {
         return false;
     }
 
     //grab players direction
-    auto playerOrientation = glm::quat((glm::vec3)e.Player["Transform"]["Orientation"]);
+    auto playerOrientation = glm::quat((glm::vec3)e.Victim["Transform"]["Orientation"]);
 
     //get the position vectors, but ignore the y-height
-    auto enemyPosition = (glm::vec3) e.PlayerShooter["Transform"]["Position"];
-    auto playerPosition = (glm::vec3) e.Player["Transform"]["Position"];
+    auto enemyPosition = (glm::vec3)e.Inflictor["Transform"]["Position"];
+    auto playerPosition = (glm::vec3)e.Victim["Transform"]["Position"];
     enemyPosition.y = 0.0f;
     playerPosition.y = 0.0f;
 
     //calculate the enemy to player vector
-    auto enemyPlayerVector = glm::normalize((glm::vec3) playerPosition - enemyPosition);
+    auto enemyPlayerVector = glm::normalize(playerPosition - enemyPosition);
 
     //get angle from players current rotation, this angle is how much you rotate around the y-axis
     auto playerAngle = glm::angle(playerOrientation);

src/Game/Systems/HealthSystem.cpp

@@ -15,13 +15,13 @@ void HealthSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& comp
 
 bool HealthSystem::OnPlayerDamaged(Events::PlayerDamage& e)
 {
-    ComponentWrapper cHealth = e.Player["Health"];
+    ComponentWrapper cHealth = e.Victim["Health"];
     double& health = cHealth["Health"];
     health -= e.Damage;
 
     if (health <= 0.0) {
         Events::PlayerDeath ePlayerDeath;
-        ePlayerDeath.Player = e.Player;
+        ePlayerDeath.Player = e.Victim;
         m_EventBroker->Publish(ePlayerDeath);
         //Note: we will delete the entity in PlayerDeathSystem
     }

src/Game/Systems/PlayerDeathSystem.cpp

@@ -41,7 +41,9 @@ void PlayerDeathSystem::createDeathEffect(EntityWrapper player)
     playerEntityModel.Copy(deathEffectEW["Model"]);
     playerEntityAnimation.Copy(deathEffectEW["Animation"]);
     //freeze the animation
-    deathEffectEW["Animation"]["Speed"] = 0.0;
+    deathEffectEW["Animation"]["Speed1"] = 0.0;
+    deathEffectEW["Animation"]["Speed2"] = 0.0;
+    deathEffectEW["Animation"]["Speed3"] = 0.0;
 
     //copy the models position,orientation
     deathEffectEW["Transform"]["Position"] = (glm::vec3)player["Transform"]["Position"];
@@ -50,8 +52,10 @@ void PlayerDeathSystem::createDeathEffect(EntityWrapper player)
     //deathEffectEW["ExplosionEffect"]["ExplosionOrigin"] = glm::vec3(0, 0, 0);
 
     //camera (with lifetime) behind the player
-    auto cam = deathEffectEW.FirstChildByName("Camera");
-    Events::SetCamera eSetCamera;
-    eSetCamera.CameraEntity = cam;
-    m_EventBroker->Publish(eSetCamera);
+    if (player == LocalPlayer) {
+        auto cam = deathEffectEW.FirstChildByName("Camera");
+        Events::SetCamera eSetCamera;
+        eSetCamera.CameraEntity = cam;
+        m_EventBroker->Publish(eSetCamera);
+    }
 }

src/Game/Systems/PlayerMovementSystem.cpp

@@ -51,6 +51,7 @@ void PlayerMovementSystem::updateMovementControllers(double dt)
 
         float playerMovementSpeed = player["Player"]["MovementSpeed"];
         float playerCrouchSpeed = player["Player"]["CrouchSpeed"];
+        glm::vec3& wishDirection = player["Player"]["CurrentWishDirection"];
 
         if (player.HasComponent("Physics")) {
             ComponentWrapper cPhysics = player["Physics"];
@@ -58,7 +59,7 @@ void PlayerMovementSystem::updateMovementControllers(double dt)
             if (player.HasComponent("DashAbility")) {
                 controller->AssaultDashCheck(dt, ((glm::vec3)cPhysics["Velocity"]).y != 0.0f, player["DashAbility"]["CoolDownMaxTimer"]);
             }
-            glm::vec3 wishDirection = controller->Movement() * glm::inverse(glm::quat(ori));
+            wishDirection = controller->Movement() * glm::inverse(glm::quat(ori));
             //this makes sure you can only dash in the 4 directions: forw,backw,left,right
             if (controller->AssaultDashDoubleTapped() && controller->Movement().z != 0 && controller->Movement().x != 0) {
                 wishDirection = glm::vec3(controller->Movement().x, 0, 0)* glm::inverse(glm::quat(ori));
@@ -233,7 +234,8 @@ void PlayerMovementSystem::updateVelocity(double dt)
     float speed = glm::length(velocity);
     static float groundFriction = 7.f;
     ImGui::InputFloat("groundFriction", &groundFriction);
-    static float airFriction = 0.f;
+    static float airFriction = 2.f;
+
     ImGui::InputFloat("airFriction", &airFriction);
     float friction = isOnGround ? groundFriction : airFriction;
     if (speed > 0) {

src/Game/Systems/PlayerSpawnSystem.cpp

@@ -88,7 +88,8 @@ bool PlayerSpawnSystem::OnPlayerSpawned(Events::PlayerSpawned& e)
 
     // Set the camera to the correct entity
     EntityWrapper cameraEntity = e.Player.FirstChildByName("Camera");
-    if (cameraEntity.Valid()) {
+    bool outOfBodyExperience = ResourceManager::Load<ConfigFile>("Config.ini")->Get<bool>("Debug.OutOfBodyExperience", false);
+    if (cameraEntity.Valid() && !outOfBodyExperience) {
         Events::SetCamera e;
         e.CameraEntity = cameraEntity;
         m_EventBroker->Publish(e);

src/Game/Systems/SoundSystem.cpp

@@ -54,7 +54,7 @@ bool SoundSystem::OnInputCommand(const Events::InputCommand & e)
     }
     if (e.Command == "TakeDamage" && e.Value > 0) {
         Events::PlayerDamage ev;
-        ev.Player = LocalPlayer;
+        ev.Victim = LocalPlayer;
         ev.Damage = 1.0;
         m_EventBroker->Publish(ev);
     }

src/Game/Systems/SpawnerSystem.cpp

@@ -48,10 +48,12 @@ EntityWrapper SpawnerSystem::Spawn(EntityWrapper spawner, EntityWrapper parent /
     EntityFileParser parser(entityFile);
     EntityWrapper spawnedEntity(world, parser.MergeEntities(world, parent.ID));
 
-    // Set its position and orientation to that of the SpawnPoint
-    spawnedEntity["Transform"]["Position"] = Transform::AbsolutePosition(spawnPoint.World, spawnPoint.ID);
-    // TODO: Quaternions, bitch
-    spawnedEntity["Transform"]["Orientation"] = glm::eulerAngles(Transform::AbsoluteOrientation(spawnPoint));
+    if (spawnPoint != parent) {
+        // Set its position and orientation to that of the SpawnPoint
+        spawnedEntity["Transform"]["Position"] = Transform::AbsolutePosition(spawnPoint.World, spawnPoint.ID);
+        // TODO: Quaternions, bitch
+        spawnedEntity["Transform"]["Orientation"] = glm::eulerAngles(Transform::AbsoluteOrientation(spawnPoint));
+    }
 
     return spawnedEntity;
 }

src/Game/Systems/Weapon/AssaultWeaponBehaviour.cpp

@@ -0,0 +1,341 @@
+#include "Systems/Weapon/AssaultWeaponBehaviour.h"
+
+AssaultWeaponBehaviour::AssaultWeaponBehaviour(SystemParams systemParams, IRenderer* renderer, Octree<EntityAABB>* collisionOctree, EntityWrapper player) 
+    : WeaponBehaviour(systemParams, renderer, collisionOctree, player)
+{
+    m_FirstPersonModel = m_Player.FirstChildByName("Hands");
+    EVENT_SUBSCRIBE_MEMBER(m_EAnimationComplete, &AssaultWeaponBehaviour::OnAnimationComplete);
+}
+
+void AssaultWeaponBehaviour::Fire()
+{
+    m_TimeSinceLastFire = 0.0;
+    m_Firing = true;
+    fireRound();
+}
+
+void AssaultWeaponBehaviour::CeaseFire()
+{
+    m_Firing = false;
+}
+
+void AssaultWeaponBehaviour::Reload()
+{
+    if (m_Reloading) {
+        return;
+    }
+
+    ComponentWrapper& cAssaultWeapon = m_Player["AssaultWeapon"];
+    int magAmmo = cAssaultWeapon["MagazineAmmo"];
+    int magSize = cAssaultWeapon["MagazineSize"];
+    int ammo = cAssaultWeapon["Ammo"];
+
+    // Don't reload if we're already fully loaded
+    if (magAmmo == magSize) {
+        return;
+    }
+
+    // Don't reload if we're completly out of ammo
+    if (ammo == 0) {
+        return;
+    }
+
+    m_Reloading = true;
+    m_ReloadTimer = cAssaultWeapon["ReloadTime"];
+    playReloadAnimation();
+}
+
+void AssaultWeaponBehaviour::Update(double dt)
+{
+    if (m_Reloading) {
+        m_ReloadTimer -= dt;
+        // Re-enable glow on reload impersonator half-way through the animation
+        if (m_ReloadTimer <= (double)m_Player["AssaultWeapon"]["ReloadTime"] / 2.0) {
+            if (m_ReloadImpersonator.Valid()) {
+                m_ReloadImpersonator["Model"]["GlowMap"] = true;
+            }
+        }
+        if (m_ReloadTimer <= 0) {
+            finishReload();
+        }
+    }
+
+    if (m_Firing && !m_Reloading) {
+        m_TimeSinceLastFire += dt;
+        ComponentWrapper& cAssaultWeapon = m_Player["AssaultWeapon"];
+        if (m_TimeSinceLastFire >= 1.0 / ((double)cAssaultWeapon["RPM"] / 60.0)) {
+            fireRound();
+        }
+    }
+
+    if (!m_Firing && !m_Reloading) {
+        playIdleAnimation();
+    }
+
+    // Disable glow map on weapon if it's out of ammo
+    // Make real first person weapon model visible again
+    EntityWrapper firstPersonWeaponModel = m_Player.FirstChildByName("WeaponModel");
+    if (firstPersonWeaponModel.Valid()) {
+        firstPersonWeaponModel["Model"]["GlowMap"] = hasAmmo();
+    }
+}
+
+bool AssaultWeaponBehaviour::OnAnimationComplete(Events::AnimationComplete& e)
+{
+    if (e.Entity != m_FirstPersonModel) {
+        return false;
+    }
+
+    //if (e.Name == "ShootRifle") {
+    //    if (!m_Firing) {
+    //        playIdleAnimation();
+    //    }
+    //}
+
+    return true;
+}
+
+bool AssaultWeaponBehaviour::hasAmmo()
+{
+    ComponentWrapper& cAssaultWeapon = m_Player["AssaultWeapon"];
+    int& magAmmo = cAssaultWeapon["MagazineAmmo"];
+    return magAmmo > 0;
+}
+
+void AssaultWeaponBehaviour::fireRound()
+{
+    if (m_Reloading) {
+        return;
+    }
+
+    ComponentWrapper& cAssaultWeapon = m_Player["AssaultWeapon"];
+
+    int& magAmmo = cAssaultWeapon["MagazineAmmo"];
+    int ammo = cAssaultWeapon["Ammo"];
+
+    // Reload if our magazine is empty
+    if (magAmmo <= 0) {
+        Reload();
+        return;
+    }
+
+    // Fire
+    magAmmo -= 1;
+    spawnTracer();
+    playSound();
+    viewPunch();
+    playShootAnimation();
+    bool hit = shoot(cAssaultWeapon["BaseDamage"]);
+    if (hit) {
+        showHitMarker();
+    }
+
+    m_TimeSinceLastFire = 0.0;
+}
+
+void AssaultWeaponBehaviour::spawnTracer()
+{
+    if (!IsClient) {
+        return;
+    }
+
+    EntityWrapper spawner;
+    if (m_Player == LocalPlayer) {
+        spawner = m_Player.FirstChildByName("WeaponMuzzle");
+    } else {
+        spawner = m_Player.FirstChildByName("ThirdPersonWeaponMuzzle");
+    }
+
+    if (!spawner.Valid()) {
+        return;
+    }
+
+    float distance = traceRayDistance(Transform::AbsolutePosition(spawner), Transform::AbsoluteOrientation(spawner) * glm::vec3(0, 0, -1));
+    EntityWrapper ray = SpawnerSystem::Spawn(spawner);
+    ((glm::vec3&)ray["Transform"]["Scale"]).z = (distance / 100.f);
+}
+
+float AssaultWeaponBehaviour::traceRayDistance(glm::vec3 origin, glm::vec3 direction)
+{
+    // TODO: Cast a ray and size tracer appropriately
+    float distance;
+    glm::vec3 pos;
+    auto entity = Collision::EntityFirstHitByRay(Ray(origin, direction), m_CollisionOctree, distance, pos);
+    if (entity) {
+        return distance;
+    } else {
+        return 100.f;
+    }
+}
+
+void AssaultWeaponBehaviour::playSound()
+{
+    if (!IsClient) {
+        return;
+    }
+
+    Events::PlaySoundOnEntity e;
+    e.EmitterID = m_Player.ID;
+    e.FilePath = "Audio/laser/laser1.wav";
+    m_EventBroker->Publish(e);
+}
+
+void AssaultWeaponBehaviour::viewPunch()
+{
+    EntityWrapper playerCamera = m_Player.FirstChildByName("Camera");
+    if (!playerCamera.Valid()) {
+        return;
+    }
+    float viewPunch = m_Player["AssaultWeapon"]["ViewPunch"];
+    ComponentWrapper cTransform = playerCamera["Transform"];
+    glm::vec3& orientation = cTransform["Orientation"];
+    orientation.x += viewPunch;
+}
+
+void AssaultWeaponBehaviour::finishReload()
+{
+    ComponentWrapper& cAssaultWeapon = m_Player["AssaultWeapon"];
+    int& magAmmo = cAssaultWeapon["MagazineAmmo"];
+    int magSize = cAssaultWeapon["MagazineSize"];
+    int& ammo = cAssaultWeapon["Ammo"];
+
+    // Throw away rounds in magazine to incentivise ammo sharing
+    int toLoad = glm::min(magSize, ammo);
+    magAmmo = toLoad;
+    ammo -= toLoad;
+
+    // Make real first person weapon model visible again
+    EntityWrapper firstPersonWeaponModel = m_Player.FirstChildByName("WeaponModel");
+    firstPersonWeaponModel["Model"]["Visible"] = true;
+
+    m_Reloading = false;
+}
+
+void AssaultWeaponBehaviour::playShootAnimation()
+{
+    ComponentWrapper cAnimation = m_FirstPersonModel["Animation"];
+    if (cAnimation["AnimationName1"] != "ShootRifle") {
+        cAnimation["AnimationName1"] = "ShootRifle";
+        cAnimation["Weight1"] = 1.0;
+        cAnimation["Time1"] = 0.0;
+        cAnimation["Speed1"] = 1.0;
+        cAnimation["Loop1"] = true;
+    }
+}
+
+void AssaultWeaponBehaviour::playIdleAnimation()
+{
+    if (!m_FirstPersonModel.Valid()) {
+        return;
+    }
+
+    ComponentWrapper cAnimation = m_FirstPersonModel["Animation"];
+    std::string& animationName1 = cAnimation["AnimationName1"];
+    double& animationSpeed1 = cAnimation["Speed1"];
+
+    std::string animationToPlay = "Idle";
+    double speedToSet = 1.0;
+
+    ComponentWrapper cPlayer = m_Player["Player"];
+    glm::vec3 movementDirection = cPlayer["CurrentWishDirection"];
+    if (glm::length2(movementDirection) > 0) {
+        animationToPlay = "Run";
+        ComponentWrapper cPhysics = m_Player["Physics"];
+        speedToSet = glm::length((glm::vec3)cPhysics["Velocity"]) / (float)cPlayer["MovementSpeed"];
+    }
+
+    if (animationName1 != animationToPlay) {
+        cAnimation["AnimationName1"] = animationToPlay;
+        cAnimation["Weight1"] = 1.0;
+        cAnimation["Time1"] = 0.0;
+        cAnimation["Loop1"] = true;
+    }
+
+    if (animationSpeed1 != speedToSet) {
+        cAnimation["Speed1"] = speedToSet;
+    }
+}
+
+void AssaultWeaponBehaviour::playReloadAnimation()
+{
+    // Play animation
+    ComponentWrapper cAnimation = m_FirstPersonModel["Animation"];
+    cAnimation["AnimationName1"] = "ReloadSwitch";
+    cAnimation["Weight1"] = 1.0;
+    cAnimation["Time1"] = 0.0;
+    cAnimation["Speed1"] = 0.5;
+    cAnimation["Loop1"] = true;
+
+    // Hide weapon model and spawn the exploding version
+    EntityWrapper firstPersonWeaponModel = m_Player.FirstChildByName("WeaponModel");
+    EntityWrapper reloadSpawner = m_Player.FirstChildByName("FirstPersonReloadSpawner");
+    m_ReloadImpersonator = SpawnerSystem::Spawn(reloadSpawner, reloadSpawner);
+    firstPersonWeaponModel["Model"].Copy(m_ReloadImpersonator["Model"]);
+    firstPersonWeaponModel["Model"]["Visible"] = false;
+}
+
+bool AssaultWeaponBehaviour::shoot(double damage)
+{
+    // Only do shooting clientside
+    if (!IsClient) {
+        return false;
+    }
+
+    // Only handle shooting for the local player
+    if (m_Player != LocalPlayer) {
+        return false;
+    }
+
+    // Make sure the player isn't shooting from the grave
+    if (!m_Player.Valid()) {
+        return false;
+    }
+
+    // Screen center, based on current resolution!
+    Rectangle screenResolution = m_Renderer->GetViewportSize();
+    glm::vec2 centerScreen = glm::vec2(screenResolution.Width / 2, screenResolution.Height / 2);
+
+    // Pick middle of screen
+    PickData pickData = m_Renderer->Pick(centerScreen);
+    if (pickData.Entity == EntityID_Invalid) {
+        return false;
+    }
+
+    EntityWrapper victim(m_World, pickData.Entity);
+
+    // Don't let us shoot ourselves in the foot
+    if (victim == LocalPlayer) {
+        return false;
+    }
+
+    // Only care about players being hit
+    if (!victim.HasComponent("Player")) {
+        victim = victim.FirstParentWithComponent("Player");
+    }
+    if (!victim.Valid()) {
+        return false;
+    }
+
+    // Check for friendly fire
+    if ((ComponentInfo::EnumType)victim["Team"]["Team"] == (ComponentInfo::EnumType)m_Player["Team"]["Team"]) {
+        return false;
+    }
+
+    // Deal damage! 
+    Events::PlayerDamage ePlayerDamage;
+    ePlayerDamage.Inflictor = m_Player;
+    ePlayerDamage.Victim = victim;
+    ePlayerDamage.Damage = damage;
+    m_EventBroker->Publish(ePlayerDamage);
+
+    return true;
+}
+
+void AssaultWeaponBehaviour::showHitMarker()
+{
+    // Show hit marker
+    EntityWrapper hitMarkerSpawner = m_Player.FirstChildByName("HitMarkerSpawner");
+    if (hitMarkerSpawner.Valid()) {
+        SpawnerSystem::Spawn(hitMarkerSpawner, hitMarkerSpawner);
+    }
+}

src/Game/Systems/Weapon/WeaponSystem.cpp

@@ -1,4 +1,4 @@
-#include "Systems/WeaponSystem.h"
+#include "Systems/Weapon/WeaponSystem.h"
 
 WeaponSystem::WeaponSystem(SystemParams params, IRenderer* renderer, Octree<EntityAABB>* collisionOctree)
     : System(params)
@@ -8,7 +8,6 @@ WeaponSystem::WeaponSystem(SystemParams params, IRenderer* renderer, Octree<Enti
     , m_CollisionOctree(collisionOctree)
 {
     EVENT_SUBSCRIBE_MEMBER(m_EInputCommand, &WeaponSystem::OnInputCommand);
-    EVENT_SUBSCRIBE_MEMBER(m_EShoot, &WeaponSystem::OnShoot);
     EVENT_SUBSCRIBE_MEMBER(m_EPlayerSpawned, &WeaponSystem::OnPlayerSpawned);
 }
 
@@ -24,7 +23,8 @@ void WeaponSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& cPla
     if (it == m_ActiveWeapons.end()) {
         selectWeapon(entity, 1);
     }
-
+    
+    m_EventBroker->Process<WeaponBehaviour>();
     m_ActiveWeapons.at(entity)->Update(dt);
 }
 
@@ -59,6 +59,14 @@ bool WeaponSystem::OnInputCommand(Events::InputCommand& e)
         }
     }
 
+    // Reload
+    if (e.Command == "Reload" && e.Value != 0) {
+        if (m_ActiveWeapons.find(player) != m_ActiveWeapons.end()) {
+            auto weapon = m_ActiveWeapons.at(player);
+            weapon->Reload();
+        }
+    }
+
     return true;
 }
 
@@ -68,7 +76,7 @@ void WeaponSystem::selectWeapon(EntityWrapper player, ComponentInfo::EnumType sl
     if (slot == 1) {
         // TODO: if class...
         if (m_ActiveWeapons.count(player) == 0) {
-            m_ActiveWeapons.insert(std::make_pair(player, std::make_shared<AssaultWeaponBehaviour>(m_SystemParams, m_CollisionOctree, player)));
+            m_ActiveWeapons.insert(std::make_pair(player, std::make_shared<AssaultWeaponBehaviour>(m_SystemParams, m_Renderer, m_CollisionOctree, player)));
         } else {
             //m_ActiveWeapons.erase(player);
         }
@@ -84,55 +92,5 @@ bool WeaponSystem::OnPlayerSpawned(Events::PlayerSpawned& e)
 {
     // Select primary weapon on player spawn
     // TODO: Select the active one specified by player component
-    return true;
-}
-
-bool WeaponSystem::OnShoot(Events::Shoot& eShoot)
-{
-    if (!eShoot.Player.Valid()) {
-        return false;
-    }
-
-    // Only run further picking code for the local player!
-    if (eShoot.Player != LocalPlayer) {
-        return false;
-    }
-
-    // Screen center, based on current resolution!
-    // TODO: check if player has enough ammo and if weapon has a cooldown or not
-    Rectangle screenResolution = m_Renderer->GetViewportSize();
-    glm::vec2 centerScreen = glm::vec2(screenResolution.Width / 2, screenResolution.Height / 2);
-
-    // TODO: check if player has enough ammo and if weapon has a cooldown or not
-
-    // Pick middle of screen
-    PickData pickData = m_Renderer->Pick(centerScreen);
-    if (pickData.Entity == EntityID_Invalid) {
-        return false;
-    }
-
-    EntityWrapper player(m_World, pickData.Entity);
-
-    // Only care about players being hit
-    if (!player.HasComponent("Player")) {
-        player = player.FirstParentWithComponent("Player");
-    }
-    if (!player.Valid()) {
-        return false;
-    }
-
-    // Check for friendly fire
-    EntityWrapper shooter = eShoot.Player;
-    if ((ComponentInfo::EnumType)player["Team"]["Team"] == (ComponentInfo::EnumType)shooter["Team"]["Team"]) {
-        return false;
-    }
-
-    // TODO: Weapon damage calculations etc
-    Events::PlayerDamage ePlayerDamage;
-    ePlayerDamage.Player = player;
-    ePlayerDamage.PlayerShooter = eShoot.Player;
-    ePlayerDamage.Damage = 100;
-    m_EventBroker->Publish(ePlayerDamage);
-
     return true;
 }