RTSSystems.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "rts/RTSAction.h"
#include "common/ResourceAccount.h"
#include "weapon/ProjectileRuntime.h"
#include "weapon/WeaponTypes.h"
 
#include <cstddef>
#include <functional>
#include <map>
#include <span>
#include <set>
#include <vector>
 
namespace eve::rts {
 
enum class FormationKind : std::uint8_t {
    Line,
    Grid,
    Wedge,
    Column,
    Dispersed,
};
 
struct FormationSpec {
    FormationKind kind    = FormationKind::Line;
    float         spacing = 32.0f;
    int           columns = 0;
    float rotationRadians = 0.f;  
 
    [[nodiscard]] EVENGINE_API_DOMAINS Result<void> validate() const;
};
 
struct MovementGroupBatch {
    std::vector<SubjectRef> units;  
    WorldPosition           target;
    FormationSpec           formation;
    float leadDistance = 2.f;  
};
 
struct SystemContract {
    const char* name              = "";
    const char* view              = "";
    const char* readSet           = "";
    const char* writeSet          = "";
    const char* structuralChanges = "";
    const char* events            = "";
    const char* phase             = "";
};
 
enum class DamageChannel : std::uint8_t { Ability, Projectile, Weapon };
using DamageEventSink = std::function<void(
    const combat::DamageRequest& request, const combat::DamageOutcome& outcome,
    SimulationTick tick, DamageChannel channel)>;
 
enum class CombatFireEventKind : std::uint8_t {
    WeaponFired,
    ProjectileFired,
    ShotMissed,
    ReloadStarted,
    ReloadCompleted,
    WeaponDry,
    FireBlocked,
};
struct CombatFireEvent {
    CombatFireEventKind kind = CombatFireEventKind::WeaponFired;
    SubjectRef source;
    SubjectRef target;
    WorldPosition point;
};
using CombatFireEventSink = std::function<void(const CombatFireEvent&, SimulationTick)>;
 
enum class LifecycleEventKind : std::uint8_t {
    SuppressionRecovered,
    ShieldRecharged,
    ConstructionCompleted,
    ProductionSpawnBlocked,
    ProductionSpawnCleared,
    UnitProduced,
    BuildingCaptured,
    AbilityCast,
    AbilityChannelStarted,
    AbilityChannelTick,
    AbilityChannelCompleted,
    AbilityInterrupted,
    AbilityChannelCancelled,
    StatusApplied,
    StatusExpired,
    AmmoProduced,
    SupplyDispatched,
    SupplyRelayDispatched,
    AmmoResupplied,
    SupplyRelayTransferred,
    SupplyReturning,
    SupplyReturned,
};
struct LifecycleEvent {
    LifecycleEventKind kind = LifecycleEventKind::ConstructionCompleted;
    SubjectRef source;
    SubjectRef target;
    std::string detail;
    double value = 0.0;
};
using LifecycleEventSink = std::function<void(const LifecycleEvent&, SimulationTick)>;
 
class VeterancySystem {
public:
    [[nodiscard]] static Result<int> award(Unit& unit, float experience);
};
 
class EVENGINE_API_DOMAINS FactionRelationSystem {
public:
    [[nodiscard]] static bool isAllied(Faction* left, Faction* right) noexcept;
    [[nodiscard]] static bool isAllied(const FactionLink& left, const FactionLink& right) noexcept;
};
 
class EVENGINE_API_DOMAINS FactionIntelSystem {
public:
    [[nodiscard]] static bool isTargetable(Faction* viewer, SubjectRef subject) noexcept;
};
 
[[nodiscard]] std::span<const SystemContract> systemContracts() noexcept;
 
class EVENGINE_API_DOMAINS FormationPlanner {
public:
    [[nodiscard]] static Result<std::vector<WorldPosition>> plan(std::size_t count, WorldPosition anchor,
                                                                 const FormationSpec& spec);
};
 
using PlacementValidation = std::function<Result<void>(WorldPosition, LogicalId)>;
 
class EVENGINE_API_DOMAINS BuildInfluenceSystem {
public:
    [[nodiscard]] static Result<void> validate(Faction& faction, WorldPosition position,
                                               LogicalId definition, const PlacementValidation& placement,
                                               bool requireInfluence = true);
};
 
struct FanOutReceipt {
    std::size_t              requested = 0;
    std::size_t              accepted  = 0;
    std::vector<std::string> orderIds;
};
 
class EVENGINE_API_DOMAINS CommandFanOutSystem {
public:
    [[nodiscard]] static Result<FanOutReceipt> fanOut(std::span<const ecs::EntityHandle> unitHandles,
                                                      const CommandSpec& command, const FormationSpec& formation);
};
 
class EVENGINE_API_DOMAINS MotionSystem {
public:
    [[nodiscard]] static Result<std::size_t> step(const SimulationStep& step);
};
 
class EVENGINE_API_DOMAINS MovementOrderSystem {
public:
    [[nodiscard]] static Result<std::size_t> step();
};
 
class EVENGINE_API_DOMAINS CommandStateSystem {
public:
    [[nodiscard]] static Result<std::size_t> step();
};
 
}  // namespace eve::rts
 
namespace eve::crowd { class Crowd; }
namespace eve::sensing { class SensingWorld; }
namespace eve::map { class Pathfinder; class Fov; }
 
namespace eve::rts {
 
struct NavigationGrid {
    float cellSize = 1.0f;
    float originX = 0.0f;
    float originY = 0.0f;
};
 
using NavigationEvent = std::function<void(Unit&, const OrderRecord&)>;
 
class EVENGINE_API_DOMAINS NavigationSystem {
public:
    [[nodiscard]] static Result<std::size_t> step(map::Pathfinder& pathfinder, const NavigationGrid& grid,
                                                   const NavigationEvent& unreachable = {});
};
 
class EVENGINE_API_DOMAINS PatrolSystem {
public:
    [[nodiscard]] static Result<std::size_t> step();
};
 
class EVENGINE_API_DOMAINS TrafficReservationSystem {
public:
    [[nodiscard]] static Result<std::size_t> step(const map::Pathfinder& pathfinder,
                                                   const NavigationGrid& grid);
};
 
using FogProvider = std::function<map::Fov*(Faction&)>;
 
class EVENGINE_API_DOMAINS FogOfWarSystem {
public:
    struct State {
        struct Binding {
            ecs::EntityHandle source{};
            ecs::EntityHandle faction{};
            map::Fov*          provider = nullptr;
            int                revealer = -1;
        };
        std::vector<Binding> bindings;
    };
 
    [[nodiscard]] static Result<std::size_t> step(const SimulationStep& step, const NavigationGrid& grid,
                                                   State& state, const FogProvider& provider);
    static void clear(State& state) noexcept;
    [[nodiscard]] static const Faction::Intel::Contact* contact(const Faction& faction,
                                                                SubjectRef subject) noexcept;
};
 
class EVENGINE_API_DOMAINS CrowdMotionSystem {
public:
    [[nodiscard]] static Result<std::size_t> step(const SimulationStep& step, crowd::Crowd& crowd);
};
 
class EVENGINE_API_DOMAINS WorkerAssignmentSystem {
public:
    [[nodiscard]] static Result<std::size_t> step();
};
 
using ResourceCredit = std::function<Result<resource::Receipt>(Unit&, const resource::CostSpec&)>;
 
class EVENGINE_API_DOMAINS MiningSystem {
public:
    [[nodiscard]] static Result<std::size_t> step(const SimulationStep& step, const ResourceCredit& credit);
};
 
class EVENGINE_API_DOMAINS ConstructionSystem {
public:
    [[nodiscard]] static Result<std::size_t> step(const SimulationStep& step,
                                                  const LifecycleEventSink& events = {});
};
 
class EVENGINE_API_DOMAINS WorkforceAssignmentSystem {
public:
    [[nodiscard]] static Result<std::size_t> step();
};
 
using RepairDebit = std::function<Result<resource::Receipt>(Unit&, Building&, const resource::CostSpec&)>;
 
class EVENGINE_API_DOMAINS RepairSystem {
public:
    [[nodiscard]] static Result<std::size_t> step(const SimulationStep& step, combat::DamageRuntime& settlement,
                                                  const RepairDebit& debit);
};
 
class EVENGINE_API_DOMAINS CaptureSystem {
public:
    [[nodiscard]] static Result<std::size_t> step(const SimulationStep& step,
                                                  const LifecycleEventSink& events = {});
};
 
using PassiveIncomeCredit = std::function<Result<resource::Receipt>(Building&, const resource::CostSpec&)>;
 
class EVENGINE_API_DOMAINS InfrastructureSystem {
public:
    [[nodiscard]] static Result<std::size_t> step(const SimulationStep& step,
                                                  const PassiveIncomeCredit& credit = {});
};
 
class EVENGINE_API_DOMAINS ContainmentSystem {
public:
    [[nodiscard]] static Result<std::size_t> step();
    [[nodiscard]] static Result<std::size_t> unload(Unit& transport, WorldPosition destination);
    [[nodiscard]] static Result<std::size_t> evacuate(Building& building, WorldPosition destination);
};
 
using AmmoProductionPurchase = std::function<Result<std::size_t>(
    Building&, std::string_view, std::int64_t, std::size_t)>;
 
class EVENGINE_API_DOMAINS SupplySystem {
public:
    [[nodiscard]] static Result<std::size_t> step(
        const SimulationStep& step, const AmmoProductionPurchase& purchase = {},
        map::Pathfinder* pathfinder = nullptr, const NavigationGrid& grid = {},
        const LifecycleEventSink& events = {});
};
 
struct SupplyRendezvousSelection {
    WorldPosition target;
    float threat = 0.0f;
    bool avoidedThreat = false;
};
 
class EVENGINE_API_DOMAINS SupplyRendezvousSystem {
public:
    [[nodiscard]] static Result<SupplyRendezvousSelection> select(
        Unit& supplier, Unit& relay, WorldPosition predicted,
        map::Pathfinder& pathfinder, const NavigationGrid& grid);
};
 
class EVENGINE_API_DOMAINS SupplyConvoySystem {
public:
    [[nodiscard]] static Result<std::size_t> step();
};
 
class EVENGINE_API_DOMAINS MoraleSystem {
public:
    [[nodiscard]] static Result<std::size_t> step(const SimulationStep& step,
                                                  const LifecycleEventSink& events = {});
};
 
class EVENGINE_API_DOMAINS ShieldSystem {
public:
    [[nodiscard]] static Result<std::size_t> step(const SimulationStep& step,
                                                  const LifecycleEventSink& events = {});
};
 
class EVENGINE_API_DOMAINS CommandNetworkSystem {
public:
    [[nodiscard]] static Result<std::size_t> step();
};
 
using AbilityResourceDebit = std::function<Result<resource::Receipt>(Unit&, const resource::CostSpec&)>;
 
class EVENGINE_API_DOMAINS AbilitySystem {
public:
    [[nodiscard]] static Result<void> cast(Unit& caster, const AbilitySpec& spec,
                                           ecs::EntityHandle target, WorldPosition point,
                                           combat::DamageRuntime& damage,
                                           const AbilityResourceDebit& debit = {},
                                           const DamageEventSink& damageEvents = {},
                                           SimulationTick tick = {},
                                           const LifecycleEventSink& events = {});
    [[nodiscard]] static Result<std::size_t> step(const SimulationStep& step,
                                                  combat::DamageRuntime& damage,
                                                  const DamageEventSink& damageEvents = {},
                                                  const LifecycleEventSink& events = {});
};
 
class ArtillerySystem {
public:
    [[nodiscard]] static Result<std::size_t> step(const SimulationStep& step);
};
 
struct ArtilleryRelocationSelection {
    WorldPosition target;
    float threat = 0.0f;
    int conflicts = 0;
    bool avoidedThreat = false;
    bool deconflicted = false;
    bool avoidedDepartedPosition = false;
};
 
class EVENGINE_API_DOMAINS ArtilleryRelocationSystem {
public:
    [[nodiscard]] static Result<ArtilleryRelocationSelection> select(
        Unit& unit, WorldPosition target, float distance, float weaponRange,
        map::Pathfinder& pathfinder, const NavigationGrid& grid);
};
 
class EVENGINE_API_DOMAINS FireSupportSystem {
public:
    [[nodiscard]] static Result<std::size_t> request(Unit& requester, WorldPosition center, float radius,
                                                     int shotsPerResponder, std::size_t maxResponders = 0);
    [[nodiscard]] static Result<std::size_t> cancel(Unit& requester);
    [[nodiscard]] static Result<std::size_t> step(const SimulationStep& step);
};
 
class EVENGINE_API_DOMAINS TacticsSystem {
public:
    [[nodiscard]] static Result<std::size_t> step(const combat::DamageRuntime* damage = nullptr,
                                                   const SimulationStep& step = {});
};
 
using AIProductionRequest = std::function<Result<void>(Faction&, Building&, const LogicalId&)>;
 
class EVENGINE_API_DOMAINS AISystem {
public:
    [[nodiscard]] static Result<std::size_t> step(const SimulationStep& step,
                                                  const AIProductionRequest& requestProduction);
};
 
using FireLineQuery = std::function<Result<bool>(WorldPosition origin, WorldPosition target,
                                                  ecs::EntityHandle source, ecs::EntityHandle targetEntity,
                                                  const weapon::WeaponDefinition& weapon)>;
struct CombatHeightProfile { float source = 0.0f; float target = 0.0f; };
using CombatHeightQuery = std::function<CombatHeightProfile(
    WorldPosition origin, WorldPosition target, ecs::EntityHandle source, ecs::EntityHandle targetEntity)>;
 
class EVENGINE_API_DOMAINS CombatFireSystem {
public:
    struct State {
        std::set<std::string> mirroredSubjects;
        std::set<std::string> blockedSubjects;
    };
    [[nodiscard]] static Result<std::size_t> step(const SimulationStep& step, State& state,
                                                  sensing::SensingWorld& sensing, combat::DamageRuntime& damage,
                                                  class RTSProjectileSystem* projectiles = nullptr,
                                                  const FireLineQuery& fireLine = {},
                                                  map::Pathfinder* pathfinder = nullptr,
                                                  const NavigationGrid& navigationGrid = {},
                                                  const CombatHeightQuery& heightQuery = {},
                                                  const DamageEventSink& damageEvents = {},
                                                  const CombatFireEventSink& fireEvents = {});
};
 
struct ProjectileCollision {
    WorldPosition position;
    ecs::EntityHandle entity{};
};
 
using ProjectileCollisionQuery = std::function<Result<std::optional<ProjectileCollision>>(
    WorldPosition from, float fromHeight, WorldPosition to, float toHeight,
    SubjectRef source, ecs::EntityHandle intendedTarget)>;
 
struct RTSProjectilePayloadSnapshot {
    std::uint64_t key = 0;
    SubjectRef source;
    SubjectRef faction;
    SubjectRef target;
    SubjectRef observer;
    WorldPosition targetPoint;
    float targetHeight = 0.0f;
    std::string damageType;
    double damage = 0.0;
    float radius = 0.0f;
    float splashMinimumDamageFactor = 0.1f;
    bool targetsGround = true;
    bool targetsAir = true;
    bool friendlyFire = false;
    bool blockedByObstacles = false;
    std::vector<std::string> requiredTargetTags;
    std::vector<std::string> excludedTargetTags;
};
 
struct RTSProjectileSystemSnapshot {
    weapon::ProjectileRuntimeSnapshot runtime;
    std::vector<RTSProjectilePayloadSnapshot> payloads;
};
 
using ProjectileSubjectResolver = std::function<ecs::Entity*(SubjectRef)>;
 
class EVENGINE_API_DOMAINS RTSProjectileSystem final : public weapon::IProjectileTargetProvider {
public:
    [[nodiscard]] Result<void> launch(SubjectRef source, ecs::EntityHandle faction, WorldPosition origin,
                                      ecs::EntityHandle target, WorldPosition targetPoint,
                                      const weapon::WeaponDefinition& weapon, double damageFactor = 1.0,
                                      ecs::EntityHandle observer = {}, float originHeight = 0.0f,
                                      float targetHeight = 0.0f);
    [[nodiscard]] Result<std::size_t> step(const SimulationStep& step, combat::DamageRuntime& damage,
                                           const ProjectileCollisionQuery& collision = {},
                                           const DamageEventSink& damageEvents = {});
    [[nodiscard]] Result<weapon::ProjectilePoint> position(ecs::EntityHandle target) const override;
    [[nodiscard]] std::size_t activeCount() const noexcept { return runtime_.activeCount(); }
    [[nodiscard]] RTSProjectileSystemSnapshot snapshot() const;
    [[nodiscard]] Result<void> restore(const RTSProjectileSystemSnapshot& snapshot,
                                       const ProjectileSubjectResolver& resolver);
 
private:
    struct Payload {
        SubjectRef source;
        ecs::EntityHandle faction{};
        ecs::EntityHandle target{};
        ecs::EntityHandle observer{};
        WorldPosition targetPoint;
        float targetHeight = 0.0f;
        std::string damageType;
        double damage = 0.0;
        float radius = 0.0f;
        float splashMinimumDamageFactor = 0.1f;
        bool targetsGround = true;
        bool targetsAir = true;
        bool friendlyFire = false;
        bool blockedByObstacles = false;
        std::vector<std::string> requiredTargetTags;
        std::vector<std::string> excludedTargetTags;
    };
    static std::uint64_t key(weapon::ProjectileHandle handle) noexcept;
    weapon::ProjectileRuntime runtime_;
    std::map<std::uint64_t, Payload> payloads_;
};
 
class EVENGINE_API_DOMAINS OrderActionSystem {
public:
    [[nodiscard]] static Result<std::size_t> step(const SimulationStep& step, IRTSActionExecutor& executor);
};
 
enum class ProductionSpawnState { Created, Blocked };
 
struct ProductionSpawnOutcome {
    ProductionSpawnState state = ProductionSpawnState::Blocked;
    Unit* unit = nullptr;
};
 
using ProductionSpawn =
    std::function<Result<ProductionSpawnOutcome>(Building&, const production::ProductionTask&, WorldPosition)>;
using ProductionSpawnPosition =
    std::function<Result<std::optional<WorldPosition>>(Building&, const production::ProductionTask&)>;
 
class EVENGINE_API_DOMAINS BuildingProductionSystem {
public:
    [[nodiscard]] static Result<std::size_t> step(const SimulationStep& step, const ProductionSpawn& spawn = {},
                                                   const ProductionSpawnPosition& position = {},
                                                   const LifecycleEventSink& events = {});
};
 
using ReinforcementCancel = std::function<Result<void>(Building&, std::string_view)>;
using ReinforcementEnqueue = std::function<Result<std::string>(Building&, std::string_view)>;
 
struct ReinforcementRequestReceipt {
    std::string requestedProduct;
    std::string queuedProduct;
    std::string taskId;
};
 
class EVENGINE_API_DOMAINS ReinforcementProductionPolicySystem {
public:
    [[nodiscard]] static Result<std::size_t> step(const SimulationStep& step = {},
                                                   const ReinforcementCancel& cancel = {});
    [[nodiscard]] static Result<ReinforcementRequestReceipt> request(
        Building& building, std::string preferredProduct, const ReinforcementEnqueue& enqueue);
};
 
class EVENGINE_API_DOMAINS ReinforcementSystem {
public:
    [[nodiscard]] static Result<std::size_t> step();
};
 
class EffectSystem {
public:
    [[nodiscard]] static Result<std::size_t> step(const SimulationStep& step, combat::DamageRuntime& settlement,
                                                  const LifecycleEventSink& events = {});
};
 
}  // namespace eve::rts