WIP shoot

src/Engine/Core/EntityWrapper.cpp

@@ -36,6 +36,18 @@ EntityWrapper EntityWrapper::FirstChildByName(const std::string& name)
     return EntityWrapper::Invalid;
 }
 
+EntityWrapper EntityWrapper::FirstParentWithComponent(const std::string& componentType)
+{
+    EntityWrapper entity = *this;
+    while (entity.Parent().Valid()) {
+        entity = entity.Parent();
+        if (entity.HasComponent(componentType)) {
+            return entity;
+        }
+    }
+    return EntityWrapper::Invalid;
+}
+
 bool EntityWrapper::IsChildOf(EntityWrapper potentialParent)
 {
     EntityWrapper entity = *this;

src/Engine/Network/Client.cpp

@@ -327,8 +327,8 @@ bool Client::OnInputCommand(const Events::InputCommand & e)
 bool Client::OnPlayerDamage(const Events::PlayerDamage & e)
 {
     Packet packet(MessageType::OnInputCommand, m_SendPacketID);
-    packet.WritePrimitive(e.DamageAmount);
-    packet.WritePrimitive(e.PlayerDamagedID);
+    packet.WritePrimitive(e.Damage);
+    packet.WritePrimitive(e.Player.ID);
     send(packet);
     return false;
 }

src/Engine/Network/Server.cpp

@@ -286,8 +286,8 @@ void Server::parseOnInputCommand(Packet& packet)
 void Server::parseOnPlayerDamage(Packet & packet)
 {
     Events::PlayerDamage e;
-    e.DamageAmount = packet.ReadPrimitive<double>();
-    e.PlayerDamagedID = packet.ReadPrimitive<EntityID>();
+    e.Damage = packet.ReadPrimitive<double>();
+    e.Player = EntityWrapper(m_World, packet.ReadPrimitive<EntityID>());
     m_EventBroker->Publish(e);
     //LOG_DEBUG("Server::parseOnPlayerDamage: Command is %s. Value is %f. PlayerID is %i.", e.DamageAmount, e.PlayerDamagedID, e.TypeOfDamage.c_str());
 }

src/Game/Systems/HealthSystem.cpp

@@ -49,7 +49,7 @@ void HealthSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& comp
 bool HealthSystem::OnPlayerDamaged(const Events::PlayerDamage& e)
 {
     //save the changed HP to a vector. it will be taken care of in UpdateComponent
-    m_DeltaHealthVector.push_back(std::make_tuple(e.PlayerDamagedID, -e.DamageAmount));
+    //m_DeltaHealthVector.push_back(std::make_tuple(e.PlayerDamagedID, -e.DamageAmount));
     return true;
 }
 

src/Game/Systems/WeaponSystem.cpp

@@ -5,49 +5,79 @@ WeaponSystem::WeaponSystem(World* world, EventBroker* eventBroker, IRenderer* re
     , ImpureSystem()
     , m_Renderer(renderer)
 {
+    EVENT_SUBSCRIBE_MEMBER(m_EPlayerSpawned, &WeaponSystem::OnPlayerSpawned);
     EVENT_SUBSCRIBE_MEMBER(m_EInputCommand, &WeaponSystem::OnInputCommand);
     EVENT_SUBSCRIBE_MEMBER(m_EShoot, &WeaponSystem::OnShoot);
 }
 
 void WeaponSystem::Update(double dt)
 {
-    for (int i = m_EShootVector.size(); i > 0; i--)
-    {
-        //TODO: check if player has enough ammo and if weapon has a cooldown or not
 
-        //pick the object
-        PickData pickDataFromShot = m_Renderer->Pick(std::get<1>(m_EShootVector[i - 1]));
-        if (pickDataFromShot.Entity == EntityID_Invalid) {
-            m_EShootVector.erase(m_EShootVector.begin() + i - 1);
-            continue;
-        }
-        //if its a player, do PlayerDamage event
-        const bool hasPlayerComponent = m_World->HasComponent(pickDataFromShot.Entity, "Player");
-        if (hasPlayerComponent) {
-            Events::PlayerDamage ePlayerDamage;
-            //TODO: damage based on weapontype/class?
-            //TODO: multiple shots at the same time? (shotgunner)
-            ePlayerDamage.DamageAmount = 25;
-            ePlayerDamage.PlayerDamagedID = pickDataFromShot.Entity;
-            m_EventBroker->Publish(ePlayerDamage);
-        }
-        m_EShootVector.erase(m_EShootVector.begin() + i - 1);
+}
+
+bool WeaponSystem::OnPlayerSpawned(const Events::PlayerSpawned& e)
+{
+    if (e.PlayerID == -1) {
+        m_LocalPlayer = e.Player;
     }
+    return true;
 }
 
 bool WeaponSystem::OnInputCommand(const Events::InputCommand& e)
 {
+    // Only shoot client-side!
+    if (e.PlayerID != -1) {
+        return false;
+    }
+
+    // Only shoot if the player is alive
+    if (!m_LocalPlayer.Valid()) {
+        return false;
+    }
+
     if (e.Command == "PrimaryFire" && e.Value > 0) {
         Events::Shoot eShoot;
-        eShoot.shooter = e.PlayerID;
+        eShoot.Player = m_LocalPlayer;
         m_EventBroker->Publish(eShoot);
     }
+
     return true;
 }
-bool WeaponSystem::OnShoot(const Events::Shoot& e) {
-    //screen center, based on current resolution!
+
+bool WeaponSystem::OnShoot(const Events::Shoot& eShoot) {
+    // Screen center, based on current resolution!
     Rectangle screenResolution = m_Renderer->Resolution();
     glm::vec2 centerScreen = glm::vec2(screenResolution.Width / 2, screenResolution.Height / 2);
-    m_EShootVector.push_back(std::make_pair(e.shooter, centerScreen));
+
+    // 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.Damage = 100;
+    m_EventBroker->Publish(ePlayerDamage);
+
     return true;
-}
+}