move ecs related code to own folder

src/lib/ecs/system/CombatSystem.cpp

@@ -0,0 +1,142 @@
+#include "CombatSystem.h"
+
+#include "EntityAdmin.h"
+#include "FactionComponent.h"
+#include "HealthComponent.h"
+#include "PositionComponent.h"
+#include "ShipIdentityComponent.h"
+#include "ThreatResponseBehaviorComponent.h"
+#include "WeaponComponent.h"
+
+static constexpr Tick kWeaponImpactDelayTicks = 5;
+
+CombatSystem::CombatSystem(const GameConfig& config)
+    : m_config(config)
+{
+}
+
+void CombatSystem::tick(Tick currentTick,
+                         EntityAdmin& admin,
+                         BuildingSystem& /*buildings*/,
+                         std::vector<FireEvent>& outFireEvents)
+{
+    // Ship weapons.
+    admin.forEach<WeaponComponent, ThreatResponseBehaviorComponent,
+                  PositionComponent, FactionComponent>(
+        [&](entt::entity e, WeaponComponent& weapon,
+            ThreatResponseBehaviorComponent& threatResponseBehavior,
+            PositionComponent& pos, FactionComponent& faction)
+        {
+            weapon.currentTarget = threatResponseBehavior.currentTarget;
+            resolveWeapon(e, weapon, pos, faction, currentTick, admin, outFireEvents);
+        });
+
+    // Station weapons.
+    admin.forEach<WeaponComponent, PositionComponent, FactionComponent>(
+        [&](entt::entity e, WeaponComponent& weapon, PositionComponent& pos,
+            FactionComponent& faction)
+        {
+            resolveWeapon(e, weapon, pos, faction, currentTick, admin, outFireEvents);
+        });
+}
+
+void CombatSystem::resolveWeapon(
+    entt::entity shipEntity,
+    WeaponComponent& weapon,
+    const PositionComponent& ownPos,
+    const FactionComponent& ownFaction,
+    Tick currentTick,
+    EntityAdmin& admin,
+    std::vector<FireEvent>& out)
+{
+    if (weapon.cooldownTicks > 0.0f)
+    {
+        weapon.cooldownTicks -= 1.0f;
+    }
+    if (weapon.cooldownTicks > 0.0f)
+    {
+        return;
+    }
+
+    // Validate or clear existing target.
+    if (weapon.currentTarget)
+    {
+        const entt::entity t = *weapon.currentTarget;
+        if (!admin.isValid(t) || !admin.hasAll<PositionComponent>(t))
+        {
+            weapon.currentTarget = std::nullopt;
+        }
+        else
+        {
+            const float distanceSquared =
+                (ownPos.value - admin.get<PositionComponent>(t).value).lengthSquared();
+            if (distanceSquared > weapon.range * weapon.range)
+            {
+                weapon.currentTarget = std::nullopt;
+            }
+        }
+    }
+
+    // Acquire a new target if needed (nearest opposing-faction ship).
+    if (!weapon.currentTarget)
+    {
+        float bestDistanceSquared = weapon.range * weapon.range;
+        admin.forEach<ShipIdentityComponent, PositionComponent, FactionComponent>(
+            [&](entt::entity candidate, const ShipIdentityComponent& /*si*/,
+                const PositionComponent& candidatePos,
+                const FactionComponent& candidateFaction)
+            {
+                const bool isValidTarget = ownFaction.isEnemy
+                    ? !candidateFaction.isEnemy
+                    : candidateFaction.isEnemy;
+                if (!isValidTarget)
+                {
+                    return;
+                }
+                const float distanceSquared =
+                    (candidatePos.value - ownPos.value).lengthSquared();
+                if (distanceSquared < bestDistanceSquared)
+                {
+                    bestDistanceSquared = distanceSquared;
+                    weapon.currentTarget = candidate;
+                }
+            });
+    }
+
+    if (!weapon.currentTarget)
+    {
+        return;
+    }
+
+    const entt::entity targetEntity = *weapon.currentTarget;
+    m_pendingDamage.push_back({targetEntity, weapon.damage,
+                               currentTick + kWeaponImpactDelayTicks});
+
+    FireEvent evt;
+    evt.shooter   = shipEntity;
+    evt.target    = targetEntity;
+    evt.emittedAt = currentTick;
+    out.push_back(evt);
+
+    weapon.cooldownTicks = static_cast<float>(kTickRateHz) / weapon.fireRateHz;
+}
+
+void CombatSystem::applyPendingDamage(Tick currentTick, EntityAdmin& admin)
+{
+    std::vector<PendingDamage>::iterator it = m_pendingDamage.begin();
+    while (it != m_pendingDamage.end())
+    {
+        if (it->appliesAt <= currentTick)
+        {
+            if (admin.isValid(it->target) && admin.hasAll<HealthComponent>(it->target))
+            {
+                admin.get<HealthComponent>(it->target).hp -= it->amount;
+            }
+            it = m_pendingDamage.erase(it);
+        }
+        else
+        {
+            ++it;
+        }
+    }
+}