refactor AI system

src/lib/ecs/system/RepairSystem.cpp

@@ -0,0 +1,70 @@
+#include "RepairSystem.h"
+
+#include <algorithm>
+#include <optional>
+#include <vector>
+
+#include <QVector2D>
+
+#include "BehaviorTargeting.h"
+#include "EntityAdmin.h"
+#include "HealthComponent.h"
+#include "ModuleOwnerComponent.h"
+#include "PositionComponent.h"
+#include "RepairToolComponent.h"
+#include "tracing.h"
+
+RepairSystem::RepairSystem(EntityAdmin& admin)
+    : m_admin(admin)
+{
+}
+
+void RepairSystem::tick()
+{
+    TRACE();
+    const std::vector<RepairableInfo> repairables = buildRepairables(m_admin);
+
+    m_admin.forEach<RepairToolComponent, ModuleOwnerComponent>(
+        [&](entt::entity /*re*/, RepairToolComponent& tool, const ModuleOwnerComponent& owner)
+        {
+            if (!m_admin.hasAll<PositionComponent>(owner.owner)) { return; }
+            const QVector2D ownerPos = m_admin.get<PositionComponent>(owner.owner).value;
+
+            // Honour the executor-set target if it is still valid and in range.
+            if (tool.currentTarget)
+            {
+                const entt::entity t = *tool.currentTarget;
+                if (m_admin.isValid(t) && m_admin.hasAll<HealthComponent, PositionComponent>(t))
+                {
+                    HealthComponent& th = m_admin.get<HealthComponent>(t);
+                    const float dist =
+                        (m_admin.get<PositionComponent>(t).value - ownerPos).length();
+                    if (th.hp > 0.0f && th.hp < th.maxHp && dist <= tool.range_tiles)
+                    {
+                        th.hp = std::min(th.hp + tool.ratePerTick, th.maxHp);
+                        return;
+                    }
+                }
+            }
+
+            // Fallback: heal the nearest damaged friendly within tool range.
+            tool.currentTarget = std::nullopt;
+            float bestDist = tool.range_tiles;
+            for (const RepairableInfo& r : repairables)
+            {
+                if (r.isEnemy) { continue; }
+                if (r.hp <= 0.0f || r.hp >= r.maxHp) { continue; }
+                const float dist = (r.position - ownerPos).length();
+                if (dist < bestDist)
+                {
+                    bestDist = dist;
+                    tool.currentTarget = r.entity;
+                }
+            }
+
+            if (!tool.currentTarget) { return; }
+
+            HealthComponent& targetHealth = m_admin.get<HealthComponent>(*tool.currentTarget);
+            targetHealth.hp = std::min(targetHealth.hp + tool.ratePerTick, targetHealth.maxHp);
+        });
+}