mlangkabel/dota_factory
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

rename behavior components

Browse Source
This commit is contained in:
mlangkabel
2026-05-23 08:26:10 +02:00
parent b57299fd2a
commit f5f4453e2c
11 changed files with 104 additions and 104 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
src/balancing/ArenaSimulation.cpp
View File

@@ -240,10 +240,10 @@ void ArenaSimulation::tick()
{
// Ship behavior systems (tick step 7).
m_shipSystem->clearMovementIntents();
m_aiSystem->tickHomeReturn(m_admin);
m_aiSystem->tickThreatResponse(m_admin, *m_buildingSystem);
m_aiSystem->tickHomeReturnBehavior(m_admin);
m_aiSystem->tickThreatResponseBehavior(m_admin, *m_buildingSystem);
m_aiSystem->tickRepairBehavior(m_admin, *m_buildingSystem);
m_aiSystem->tickScrapCollector(m_admin, *m_scrapSystem, *m_buildingSystem);
m_aiSystem->tickSalvageBehavior(m_admin, *m_scrapSystem, *m_buildingSystem);
// Combat resolution (tick step 8).
std::vector<FireEvent> fireEvents;

4
src/lib/core/EcsComponents.h
View File

@@ -69,8 +69,8 @@ struct ShipIdentity
// ---------------------------------------------------------------------------
// Ship optional components (hardware + behavior, in Ship.h)
// ---------------------------------------------------------------------------
// Weapon, SalvageCargo, RepairTool, ThreatResponse, ScrapCollector,
// RepairBehavior, HomeReturn, RallyBehavior remain defined in Ship.h.
// Weapon, SalvageCargo, RepairTool, ThreatResponseBehavior, SalvageBehavior,
// RepairBehavior, HomeReturnBehavior, RallyBehavior remain defined in Ship.h.
// ---------------------------------------------------------------------------
// Station components

54
src/lib/sim/AiSystem.cpp
View File

@@ -16,29 +16,29 @@
#include "Ship.h"
// ---------------------------------------------------------------------------
// tickHomeReturn (priority 4)
// tickHomeReturnBehavior (priority 4)
// ---------------------------------------------------------------------------
void AiSystem::tickHomeReturn(EntityAdmin& admin)
void AiSystem::tickHomeReturnBehavior(EntityAdmin& admin)
{
admin.forEach<HomeReturn, Health, MovementIntent>(
[](entt::entity /*e*/, const HomeReturn& hr, const Health& h, MovementIntent& intent)
admin.forEach<HomeReturnBehavior, Health, MovementIntent>(
[](entt::entity /*e*/, const HomeReturnBehavior& homeReturnBehavior, const Health& h, MovementIntent& intent)
{
if (h.hp / h.maxHp < hr.retreatHpFraction)
if (h.hp / h.maxHp < homeReturnBehavior.retreatHpFraction)
{
if (4 > intent.priority)
{
intent = MovementIntent{4, hr.homePos};
intent = MovementIntent{4, homeReturnBehavior.homePos};
}
}
});
}
// ---------------------------------------------------------------------------
// tickThreatResponse (priority 3)
// tickThreatResponseBehavior (priority 3)
// ---------------------------------------------------------------------------
void AiSystem::tickThreatResponse(EntityAdmin& admin, const BuildingSystem& buildings)
void AiSystem::tickThreatResponseBehavior(EntityAdmin& admin, const BuildingSystem& buildings)
{
// Snapshot all combatant entities for target acquisition.
struct CombatantInfo
@@ -68,17 +68,17 @@ void AiSystem::tickThreatResponse(EntityAdmin& admin, const BuildingSystem& buil
combatants.push_back({e, pos.value, f.isEnemy, true});
});
admin.forEach<ThreatResponse, Position, Faction, SensorRange, MovementIntent>(
[&](entt::entity e, ThreatResponse& threat, Position& pos, Faction& faction,
admin.forEach<ThreatResponseBehavior, Position, Faction, SensorRange, MovementIntent>(
[&](entt::entity e, ThreatResponseBehavior& threatResponseBehavior, Position& pos, Faction& faction,
SensorRange& sensor, MovementIntent& intent)
{
const float range = sensor.value;
// Validate current target.
bool targetValid = false;
if (threat.currentTarget)
if (threatResponseBehavior.currentTarget)
{
const entt::entity t = *threat.currentTarget;
const entt::entity t = *threatResponseBehavior.currentTarget;
if (admin.isValid(t) && admin.hasAll<Position>(t))
{
const float dist = (admin.get<Position>(t).value - pos.value).length();
@@ -91,7 +91,7 @@ void AiSystem::tickThreatResponse(EntityAdmin& admin, const BuildingSystem& buil
if (!targetValid)
{
threat.currentTarget = std::nullopt;
threatResponseBehavior.currentTarget = std::nullopt;
float bestDist = range;
for (const CombatantInfo& c : combatants)
@@ -113,14 +113,14 @@ void AiSystem::tickThreatResponse(EntityAdmin& admin, const BuildingSystem& buil
if (dist < bestDist)
{
bestDist = dist;
threat.currentTarget = c.entity;
threatResponseBehavior.currentTarget = c.entity;
}
}
}
if (threat.currentTarget)
if (threatResponseBehavior.currentTarget)
{
const entt::entity t = *threat.currentTarget;
const entt::entity t = *threatResponseBehavior.currentTarget;
QVector2D dest = pos.value;
if (admin.isValid(t) && admin.hasAll<Position>(t))
{
@@ -298,10 +298,10 @@ void AiSystem::tickRepairBehavior(EntityAdmin& admin, BuildingSystem& buildings)
}
// ---------------------------------------------------------------------------
// tickScrapCollector (priority 1)
// tickSalvageBehavior (priority 1)
// ---------------------------------------------------------------------------
void AiSystem::tickScrapCollector(EntityAdmin& admin, ScrapSystem& scraps,
void AiSystem::tickSalvageBehavior(EntityAdmin& admin, ScrapSystem& scraps,
BuildingSystem& buildings)
{
// Snapshot enemy ships for threat detection.
@@ -322,24 +322,24 @@ void AiSystem::tickScrapCollector(EntityAdmin& admin, ScrapSystem& scraps,
const std::vector<ScrapInfo> allScrap = scraps.allScrapInfo();
admin.forEach<ScrapCollector, SalvageCargo, Position, SensorRange, MovementIntent>(
[&](entt::entity /*e*/, ScrapCollector& sc, SalvageCargo& cargo,
admin.forEach<SalvageBehavior, SalvageCargo, Position, SensorRange, MovementIntent>(
[&](entt::entity /*e*/, SalvageBehavior& salvageBehavior, SalvageCargo& cargo,
Position& pos, SensorRange& sensor, MovementIntent& intent)
{
const float collectRange = cargo.collectionRange;
// Assign nearest SalvageBay if needed.
if (sc.deliveryBay == kInvalidBuildingId)
if (salvageBehavior.deliveryBay == kInvalidBuildingId)
{
const Building* bay = buildings.findNearestBuilding(pos.value,
BuildingType::SalvageBay);
if (bay)
{
sc.deliveryBay = bay->id;
salvageBehavior.deliveryBay = bay->id;
}
}
const BuildingId bayId = sc.deliveryBay;
const BuildingId bayId = salvageBehavior.deliveryBay;
QVector2D bayPos = pos.value;
if (bayId != kInvalidBuildingId)
@@ -398,18 +398,18 @@ void AiSystem::tickScrapCollector(EntityAdmin& admin, ScrapSystem& scraps,
if (scraps.consume(si.entity))
{
++cargo.current;
sc.scrapTarget = std::nullopt;
salvageBehavior.scrapTarget = std::nullopt;
}
break;
}
}
// Move toward scrap target or find a new one.
if (sc.scrapTarget)
if (salvageBehavior.scrapTarget)
{
if (1 > intent.priority)
{
intent = MovementIntent{1, *sc.scrapTarget};
intent = MovementIntent{1, *salvageBehavior.scrapTarget};
}
}
else
@@ -427,7 +427,7 @@ void AiSystem::tickScrapCollector(EntityAdmin& admin, ScrapSystem& scraps,
}
if (bestPos)
{
sc.scrapTarget = bestPos;
salvageBehavior.scrapTarget = bestPos;
if (1 > intent.priority)
{
intent = MovementIntent{1, *bestPos};

6
src/lib/sim/AiSystem.h
View File

@@ -7,8 +7,8 @@ class ScrapSystem;
class AiSystem
{
public:
void tickHomeReturn(EntityAdmin& admin);
void tickThreatResponse(EntityAdmin& admin, const BuildingSystem& buildings);
void tickHomeReturnBehavior(EntityAdmin& admin);
void tickThreatResponseBehavior(EntityAdmin& admin, const BuildingSystem& buildings);
void tickRepairBehavior(EntityAdmin& admin, BuildingSystem& buildings);
void tickScrapCollector(EntityAdmin& admin, ScrapSystem& scraps, BuildingSystem& buildings);
void tickSalvageBehavior(EntityAdmin& admin, ScrapSystem& scraps, BuildingSystem& buildings);
};

6
src/lib/sim/CombatSystem.cpp
View File

@@ -16,10 +16,10 @@ void CombatSystem::tick(Tick currentTick,
std::vector<FireEvent>& outFireEvents)
{
// Ship weapons.
admin.forEach<Weapon, ThreatResponse, Position, Faction>(
[&](entt::entity e, Weapon& weapon, ThreatResponse& threat, Position& pos, Faction& faction)
admin.forEach<Weapon, ThreatResponseBehavior, Position, Faction>(
[&](entt::entity e, Weapon& weapon, ThreatResponseBehavior& threatResponseBehavior, Position& pos, Faction& faction)
{
weapon.currentTarget = threat.currentTarget;
weapon.currentTarget = threatResponseBehavior.currentTarget;
resolveWeapon(e, weapon, pos, faction, currentTick, admin, outFireEvents);
});

6
src/lib/sim/Ship.h
View File

@@ -41,12 +41,12 @@ struct RepairTool
// Behavior components — AI state consumed by step-6 behavior systems
// ---------------------------------------------------------------------------
struct ThreatResponse
struct ThreatResponseBehavior
{
std::optional<entt::entity> currentTarget;
};
struct ScrapCollector
struct SalvageBehavior
{
std::optional<QVector2D> scrapTarget;
BuildingId deliveryBay; // kInvalidBuildingId until assigned at a salvage bay
@@ -57,7 +57,7 @@ struct RepairBehavior
std::optional<entt::entity> currentTarget;
};
struct HomeReturn
struct HomeReturnBehavior
{
float retreatHpFraction;
QVector2D homePos;

10
src/lib/sim/ShipSystem.cpp
View File

@@ -75,7 +75,7 @@ entt::entity ShipSystem::spawn(const std::string& schematicId, int level, QVecto
w.currentTarget = std::nullopt;
m_admin.addComponent<Weapon>(entity, w);
m_admin.addComponent<ThreatResponse>(entity, ThreatResponse{});
m_admin.addComponent<ThreatResponseBehavior>(entity, ThreatResponseBehavior{});
if (!isEnemy)
{
@@ -91,10 +91,10 @@ entt::entity ShipSystem::spawn(const std::string& schematicId, int level, QVecto
cargo.collectionRange = static_cast<float>(def->salvage->collectionRange);
m_admin.addComponent<SalvageCargo>(entity, cargo);
ScrapCollector sc;
sc.scrapTarget = std::nullopt;
sc.deliveryBay = kInvalidBuildingId;
m_admin.addComponent<ScrapCollector>(entity, sc);
SalvageBehavior salvageBehavior;
salvageBehavior.scrapTarget = std::nullopt;
salvageBehavior.deliveryBay = kInvalidBuildingId;
m_admin.addComponent<SalvageBehavior>(entity, salvageBehavior);
}
if (def->repair)

6
src/lib/sim/Simulation.cpp
View File

@@ -162,10 +162,10 @@ void Simulation::tick()
}
m_shipSystem->clearMovementIntents();
m_aiSystem->tickHomeReturn(m_admin); // priority 4
m_aiSystem->tickThreatResponse(m_admin, *m_buildingSystem); // priority 3
m_aiSystem->tickHomeReturnBehavior(m_admin); // priority 4
m_aiSystem->tickThreatResponseBehavior(m_admin, *m_buildingSystem); // priority 3
m_aiSystem->tickRepairBehavior(m_admin, *m_buildingSystem); // priority 2
m_aiSystem->tickScrapCollector(m_admin, *m_scrapSystem, *m_buildingSystem); // priority 1
m_aiSystem->tickSalvageBehavior(m_admin, *m_scrapSystem, *m_buildingSystem); // priority 1
// Step 8: combat resolution
m_combatSystem->tick(m_currentTick, m_admin,

92
src/test/BehaviorSystemTest.cpp
View File

@@ -64,10 +64,10 @@ struct Fixture
void runBehaviorTick()
{
ships.clearMovementIntents();
ai.tickHomeReturn(admin);
ai.tickThreatResponse(admin, buildings);
ai.tickHomeReturnBehavior(admin);
ai.tickThreatResponseBehavior(admin, buildings);
ai.tickRepairBehavior(admin, buildings);
ai.tickScrapCollector(admin, scraps, buildings);
ai.tickSalvageBehavior(admin, scraps, buildings);
movement.tick(admin);
++tick;
}
@@ -139,40 +139,40 @@ TEST_CASE("BehaviorSystem: tickMovement stops exactly at target without overshoo
}
// ---------------------------------------------------------------------------
// tickHomeReturn
// tickHomeReturnBehavior
// ---------------------------------------------------------------------------
TEST_CASE("BehaviorSystem: tickHomeReturn does nothing when HP is above threshold",
TEST_CASE("BehaviorSystem: tickHomeReturnBehavior does nothing when HP is above threshold",
"[behavior]")
{
Fixture f;
const entt::entity e = f.ships.spawn("interceptor", 1, QVector2D(0.0f, 0.0f));
f.admin.addComponent<HomeReturn>(e, HomeReturn{0.3f, QVector2D(-10.0f, 0.0f)});
f.admin.addComponent<HomeReturnBehavior>(e, HomeReturnBehavior{0.3f, QVector2D(-10.0f, 0.0f)});
f.admin.get<Health>(e).hp = f.admin.get<Health>(e).maxHp; // full HP
f.ships.clearMovementIntents();
f.ai.tickHomeReturn(f.admin);
f.ai.tickHomeReturnBehavior(f.admin);
REQUIRE(intent(f.admin, e).priority == 0);
}
TEST_CASE("BehaviorSystem: tickHomeReturn writes priority-4 intent toward homePos when HP is low",
TEST_CASE("BehaviorSystem: tickHomeReturnBehavior writes priority-4 intent toward homePos when HP is low",
"[behavior]")
{
Fixture f;
const entt::entity e = f.ships.spawn("interceptor", 1, QVector2D(0.0f, 0.0f));
const QVector2D homePos(-10.0f, 0.0f);
f.admin.addComponent<HomeReturn>(e, HomeReturn{0.5f, homePos});
f.admin.addComponent<HomeReturnBehavior>(e, HomeReturnBehavior{0.5f, homePos});
f.admin.get<Health>(e).hp = f.admin.get<Health>(e).maxHp * 0.2f; // below threshold
f.ships.clearMovementIntents();
f.ai.tickHomeReturn(f.admin);
f.ai.tickHomeReturnBehavior(f.admin);
REQUIRE(intent(f.admin, e).priority == 4);
REQUIRE(intent(f.admin, e).target.x() == Approx(homePos.x()));
}
TEST_CASE("BehaviorSystem: tickHomeReturn priority-4 beats tickThreatResponse priority-3",
TEST_CASE("BehaviorSystem: tickHomeReturnBehavior priority-4 beats tickThreatResponseBehavior priority-3",
"[behavior]")
{
Fixture f;
@@ -180,19 +180,19 @@ TEST_CASE("BehaviorSystem: tickHomeReturn priority-4 beats tickThreatResponse pr
f.ships.spawn("interceptor", 1, QVector2D(5.0f, 0.0f), /*isEnemy=*/true);
const QVector2D homePos(-50.0f, 0.0f);
f.admin.addComponent<HomeReturn>(player, HomeReturn{0.5f, homePos});
f.admin.addComponent<HomeReturnBehavior>(player, HomeReturnBehavior{0.5f, homePos});
f.admin.get<Health>(player).hp = f.admin.get<Health>(player).maxHp * 0.1f;
f.ships.clearMovementIntents();
f.ai.tickHomeReturn(f.admin);
f.ai.tickThreatResponse(f.admin, f.buildings);
f.ai.tickHomeReturnBehavior(f.admin);
f.ai.tickThreatResponseBehavior(f.admin, f.buildings);
REQUIRE(intent(f.admin, player).priority == 4);
REQUIRE(intent(f.admin, player).target.x() == Approx(homePos.x()));
}
// ---------------------------------------------------------------------------
// tickThreatResponse — player ships
// tickThreatResponseBehavior — player ships
// ---------------------------------------------------------------------------
TEST_CASE("BehaviorSystem: player combat ship acquires nearest enemy ship in range",
@@ -204,12 +204,12 @@ TEST_CASE("BehaviorSystem: player combat ship acquires nearest enemy ship in ran
/*isEnemy=*/true);
f.ships.clearMovementIntents();
f.ai.tickThreatResponse(f.admin, f.buildings);
f.ai.tickThreatResponseBehavior(f.admin, f.buildings);
REQUIRE(f.admin.hasAll<ThreatResponse>(player));
const ThreatResponse& tr = f.admin.get<ThreatResponse>(player);
REQUIRE(tr.currentTarget.has_value());
REQUIRE(*tr.currentTarget == enemy);
REQUIRE(f.admin.hasAll<ThreatResponseBehavior>(player));
const ThreatResponseBehavior& threatResponseBehavior = f.admin.get<ThreatResponseBehavior>(player);
REQUIRE(threatResponseBehavior.currentTarget.has_value());
REQUIRE(*threatResponseBehavior.currentTarget == enemy);
}
TEST_CASE("BehaviorSystem: player combat ship does not target friendly ships",
@@ -220,10 +220,10 @@ TEST_CASE("BehaviorSystem: player combat ship does not target friendly ships",
f.ships.spawn("interceptor", 1, QVector2D(5.0f, 0.0f)); // also player
f.ships.clearMovementIntents();
f.ai.tickThreatResponse(f.admin, f.buildings);
f.ai.tickThreatResponseBehavior(f.admin, f.buildings);
REQUIRE(f.admin.hasAll<ThreatResponse>(e1));
REQUIRE_FALSE(f.admin.get<ThreatResponse>(e1).currentTarget.has_value());
REQUIRE(f.admin.hasAll<ThreatResponseBehavior>(e1));
REQUIRE_FALSE(f.admin.get<ThreatResponseBehavior>(e1).currentTarget.has_value());
}
TEST_CASE("BehaviorSystem: player combat ship ignores enemy beyond engagement range",
@@ -234,13 +234,13 @@ TEST_CASE("BehaviorSystem: player combat ship ignores enemy beyond engagement ra
f.ships.spawn("interceptor", 1, QVector2D(500.0f, 0.0f), /*isEnemy=*/true);
f.ships.clearMovementIntents();
f.ai.tickThreatResponse(f.admin, f.buildings);
f.ai.tickThreatResponseBehavior(f.admin, f.buildings);
REQUIRE_FALSE(f.admin.get<ThreatResponse>(player).currentTarget.has_value());
REQUIRE_FALSE(f.admin.get<ThreatResponseBehavior>(player).currentTarget.has_value());
}
// ---------------------------------------------------------------------------
// tickThreatResponse — enemy ships
// tickThreatResponseBehavior — enemy ships
// ---------------------------------------------------------------------------
TEST_CASE("BehaviorSystem: enemy ship acquires nearest player ship in range",
@@ -252,12 +252,12 @@ TEST_CASE("BehaviorSystem: enemy ship acquires nearest player ship in range",
/*isEnemy=*/true);
f.ships.clearMovementIntents();
f.ai.tickThreatResponse(f.admin, f.buildings);
f.ai.tickThreatResponseBehavior(f.admin, f.buildings);
REQUIRE(f.admin.hasAll<ThreatResponse>(enemy));
const ThreatResponse& tr = f.admin.get<ThreatResponse>(enemy);
REQUIRE(tr.currentTarget.has_value());
REQUIRE(*tr.currentTarget == player);
REQUIRE(f.admin.hasAll<ThreatResponseBehavior>(enemy));
const ThreatResponseBehavior& threatResponseBehavior = f.admin.get<ThreatResponseBehavior>(enemy);
REQUIRE(threatResponseBehavior.currentTarget.has_value());
REQUIRE(*threatResponseBehavior.currentTarget == player);
}
TEST_CASE("BehaviorSystem: enemy ship with no target writes leftward movement intent",
@@ -268,7 +268,7 @@ TEST_CASE("BehaviorSystem: enemy ship with no target writes leftward movement in
/*isEnemy=*/true);
f.ships.clearMovementIntents();
f.ai.tickThreatResponse(f.admin, f.buildings);
f.ai.tickThreatResponseBehavior(f.admin, f.buildings);
REQUIRE(intent(f.admin, enemy).priority == 3);
REQUIRE(intent(f.admin, enemy).target.x() < 0.0f);
@@ -330,7 +330,7 @@ TEST_CASE("BehaviorSystem: repair ship does not heal above maxHp", "[behavior]")
}
// ---------------------------------------------------------------------------
// tickScrapCollector
// tickSalvageBehavior
// ---------------------------------------------------------------------------
TEST_CASE("BehaviorSystem: salvage ship writes intent toward nearest scrap", "[behavior]")
@@ -342,7 +342,7 @@ TEST_CASE("BehaviorSystem: salvage ship writes intent toward nearest scrap", "[b
f.scraps.spawn(scrapPos, 1, 100000);
f.ships.clearMovementIntents();
f.ai.tickScrapCollector(f.admin, f.scraps, f.buildings);
f.ai.tickSalvageBehavior(f.admin, f.scraps, f.buildings);
REQUIRE(intent(f.admin, ship).priority == 1);
REQUIRE(intent(f.admin, ship).target.x() == Approx(scrapPos.x()));
@@ -355,7 +355,7 @@ TEST_CASE("BehaviorSystem: salvage ship collects scrap on arrival", "[behavior]"
const entt::entity scrapEntity = f.scraps.spawn(QVector2D(0.0f, 0.0f), 1, 100000);
f.ships.clearMovementIntents();
f.ai.tickScrapCollector(f.admin, f.scraps, f.buildings);
f.ai.tickSalvageBehavior(f.admin, f.scraps, f.buildings);
REQUIRE(f.admin.get<SalvageCargo>(ship).current == 1);
REQUIRE_FALSE(f.admin.isValid(scrapEntity));
@@ -383,7 +383,7 @@ TEST_CASE("BehaviorSystem: full-cargo salvage ship moves toward SalvageBay", "[b
cargo.current = cargo.capacity; // full cargo
f.ships.clearMovementIntents();
f.ai.tickScrapCollector(f.admin, f.scraps, f.buildings);
f.ai.tickSalvageBehavior(f.admin, f.scraps, f.buildings);
const MovementIntent& i = intent(f.admin, ship);
REQUIRE(i.priority == 1);
@@ -402,7 +402,7 @@ TEST_CASE("SensorRange: sensorRange is populated from config formula at spawn",
}
// ---------------------------------------------------------------------------
// Sensor range — tickThreatResponse
// Sensor range — tickThreatResponseBehavior
// ---------------------------------------------------------------------------
TEST_CASE("SensorRange: player combat ship acquires enemy just inside sensor range", "[sensor]")
@@ -413,9 +413,9 @@ TEST_CASE("SensorRange: player combat ship acquires enemy just inside sensor ran
/*isEnemy=*/true);
f.ships.clearMovementIntents();
f.ai.tickThreatResponse(f.admin, f.buildings);
f.ai.tickThreatResponseBehavior(f.admin, f.buildings);
REQUIRE(f.admin.get<ThreatResponse>(player).currentTarget == enemy);
REQUIRE(f.admin.get<ThreatResponseBehavior>(player).currentTarget == enemy);
}
TEST_CASE("SensorRange: player combat ship ignores enemy just outside sensor range", "[sensor]")
@@ -425,9 +425,9 @@ TEST_CASE("SensorRange: player combat ship ignores enemy just outside sensor ran
f.ships.spawn("interceptor", 1, QVector2D(210.0f, 0.0f), /*isEnemy=*/true);
f.ships.clearMovementIntents();
f.ai.tickThreatResponse(f.admin, f.buildings);
f.ai.tickThreatResponseBehavior(f.admin, f.buildings);
REQUIRE_FALSE(f.admin.get<ThreatResponse>(player).currentTarget.has_value());
REQUIRE_FALSE(f.admin.get<ThreatResponseBehavior>(player).currentTarget.has_value());
}
TEST_CASE("SensorRange: enemy ship ignores player just outside sensor range", "[sensor]")
@@ -438,9 +438,9 @@ TEST_CASE("SensorRange: enemy ship ignores player just outside sensor range", "[
/*isEnemy=*/true);
f.ships.clearMovementIntents();
f.ai.tickThreatResponse(f.admin, f.buildings);
f.ai.tickThreatResponseBehavior(f.admin, f.buildings);
REQUIRE_FALSE(f.admin.get<ThreatResponse>(enemy).currentTarget.has_value());
REQUIRE_FALSE(f.admin.get<ThreatResponseBehavior>(enemy).currentTarget.has_value());
}
// ---------------------------------------------------------------------------
@@ -486,7 +486,7 @@ TEST_CASE("SensorRange: repair ship does not acquire damaged ally beyond sensor
}
// ---------------------------------------------------------------------------
// Sensor range — tickScrapCollector
// Sensor range — tickSalvageBehavior
// ---------------------------------------------------------------------------
TEST_CASE("SensorRange: salvage ship ignores scrap beyond sensor range", "[sensor]")
@@ -496,8 +496,8 @@ TEST_CASE("SensorRange: salvage ship ignores scrap beyond sensor range", "[senso
f.scraps.spawn(QVector2D(300.0f, 0.0f), 1, 100000);
f.ships.clearMovementIntents();
f.ai.tickScrapCollector(f.admin, f.scraps, f.buildings);
f.ai.tickSalvageBehavior(f.admin, f.scraps, f.buildings);
REQUIRE_FALSE(f.admin.get<ScrapCollector>(ship).scrapTarget.has_value());
REQUIRE_FALSE(f.admin.get<SalvageBehavior>(ship).scrapTarget.has_value());
REQUIRE(intent(f.admin, ship).target.x() > pos(f.admin, ship).value.x());
}

4
src/test/CombatSystemTest.cpp
View File

@@ -68,9 +68,9 @@ struct CombatFixture
admin.get<Weapon>(enemy).currentTarget = playerTarget;
admin.get<Weapon>(enemy).cooldownTicks = 0.0f;
}
if (admin.hasAll<ThreatResponse>(enemy))
if (admin.hasAll<ThreatResponseBehavior>(enemy))
{
admin.get<ThreatResponse>(enemy).currentTarget = playerTarget;
admin.get<ThreatResponseBehavior>(enemy).currentTarget = playerTarget;
}
}
};

10
src/test/ShipTest.cpp
View File

@@ -33,11 +33,11 @@ TEST_CASE("ShipSystem: interceptor spawn has weapon and threatResponse, no cargo
REQUIRE(admin.isValid(e));
REQUIRE(admin.hasAll<Weapon>(e));
REQUIRE(admin.hasAll<ThreatResponse>(e));
REQUIRE(admin.hasAll<ThreatResponseBehavior>(e));
REQUIRE_FALSE(admin.hasAll<SalvageCargo>(e));
REQUIRE_FALSE(admin.hasAll<RepairTool>(e));
REQUIRE_FALSE(admin.hasAll<RepairBehavior>(e));
REQUIRE_FALSE(admin.hasAll<ScrapCollector>(e));
REQUIRE_FALSE(admin.hasAll<SalvageBehavior>(e));
}
TEST_CASE("ShipSystem: interceptor level 1 stats match config formulas", "[ship]")
@@ -100,7 +100,7 @@ TEST_CASE("ShipSystem: salvage_ship spawn has cargo and scrapCollector, no weapo
const entt::entity e = ss.spawn("salvage_ship", 1, QVector2D(0.0f, 0.0f));
REQUIRE(admin.hasAll<SalvageCargo>(e));
REQUIRE(admin.hasAll<ScrapCollector>(e));
REQUIRE(admin.hasAll<SalvageBehavior>(e));
REQUIRE_FALSE(admin.hasAll<Weapon>(e));
REQUIRE_FALSE(admin.hasAll<RepairTool>(e));
}
@@ -116,8 +116,8 @@ TEST_CASE("ShipSystem: salvage_ship cargo capacity matches config", "[ship]")
// cargo_capacity = 10
REQUIRE(admin.get<SalvageCargo>(e).capacity == 10);
REQUIRE(admin.get<SalvageCargo>(e).current == 0);
REQUIRE(admin.get<ScrapCollector>(e).deliveryBay == kInvalidBuildingId);
REQUIRE_FALSE(admin.get<ScrapCollector>(e).scrapTarget.has_value());
REQUIRE(admin.get<SalvageBehavior>(e).deliveryBay == kInvalidBuildingId);
REQUIRE_FALSE(admin.get<SalvageBehavior>(e).scrapTarget.has_value());
}
// ---------------------------------------------------------------------------