RTSTypes.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "attributes/AttributeProjection.h"
#include "common/ECS.h"
#include "common/Identity.h"
#include "common/Result.h"
#include "common/SubjectRef.h"
#include "combat/Damage.h"
#include "common/Time.h"
#include "rts/RTSEffects.h"
#include "production/Production.h"
 
#include <cstddef>
#include <cstdint>
#include <memory>
#include <map>
#include <optional>
#include <span>
#include <string>
#include <string_view>
#include <vector>
 
namespace eve::orders {
class CommandQueue;
}
 
namespace eve::production {
class WorkQueue;
}
 
namespace eve::rts {
 
class RTSProductionActionAdapter;
 
struct WorldPosition {
    float x = 0.0f;
    float y = 0.0f;
};
 
enum class CombatStance : std::uint8_t { Passive, Defensive, Aggressive };
 
[[nodiscard]] const char* combatStanceName(CombatStance stance) noexcept;
 
enum class OrderKind : std::uint8_t {
    Move,
    Attack,
    Build,
    Gather,
    ReturnCargo,
    AttackMove,
    Stop,
    HoldPosition,
    Patrol,
    Repair,
    Garrison,
    BoardTransport,
    Capture,
    AttackGround,
    Resupply,
    Escort,
    SuppressArea,
    SupplyRelay,
};
 
[[nodiscard]] const char* orderKindName(OrderKind kind) noexcept;
 
struct CommandSpec {
    OrderKind     kind = OrderKind::Move;
    WorldPosition target;
    std::string   definitionId;
    int           priority       = 0;
    double        timeoutSeconds = 0.0;
    ecs::EntityHandle targetEntity{};
    WorldPosition secondaryTarget;
    float         radius = 0.0f;
    bool          append = false;
 
    [[nodiscard]] Result<void> validate() const;
};
 
struct OrderRecord {
    std::string   id;
    OrderKind     kind = OrderKind::Move;
    WorldPosition target;
    std::string   definitionId;
    ecs::EntityHandle targetEntity{};
    WorldPosition secondaryTarget;
    float         radius        = 0.0f;
    bool          append        = false;
    int           formationSlot = -1;
};
 
enum class AbilityTarget : std::uint8_t { Self, Ally, Enemy, Point };
 
struct AbilitySpec {
    std::string id;
    LogicalId casterDefinition;
    AbilityTarget target = AbilityTarget::Enemy;
    std::string resourceType;
    std::string damageType = "damage.magic";
    float range = 0.0f;
    float radius = 0.0f;
    float cooldown = 0.0f;
    std::int64_t resourceCost = 0;
    float damage = 0.0f;
    float healing = 0.0f;
    float castTime = 0.0f;
    float channelTickInterval = 0.0f;
    bool interruptOnDamage = true;
    bool appliesEffect = false;
    RTSEffectDefinition effect;
};
 
class EVENGINE_API_DOMAINS TagSet {
public:
    [[nodiscard]] Result<void> add(std::string_view tag);
    [[nodiscard]] Result<void> remove(std::string_view tag);
    [[nodiscard]] bool contains(std::string_view tag) const noexcept;
    [[nodiscard]] const std::vector<std::string>& values() const noexcept { return values_; }
 
private:
    std::vector<std::string> values_;
};
 
struct EntityLinkTag {};
 
template <typename Tag>
class EntityLink {
public:
    [[nodiscard]] static Result<EntityLink> bind(ecs::EntityHandle handle) {
        if (ecs::try_get(handle) == nullptr) {
            return Result<EntityLink>::failure(
                Diagnostic::error(DiagnosticCode::StaleHandle, "RTS entity link target is not live", "link.handle"));
        }
        EntityLink result;
        result.handle_ = handle;
        result.bound_  = true;
        return Result<EntityLink>::success(std::move(result));
    }
 
    [[nodiscard]] static EntityLink fromHandleForRestore(ecs::EntityHandle handle) noexcept {
        EntityLink result;
        result.handle_ = handle;
        result.bound_  = true;
        return result;
    }
 
    [[nodiscard]] bool isBound() const noexcept { return bound_; }
    [[nodiscard]] bool isStale() const noexcept { return bound_ && ecs::try_get(handle_) == nullptr; }
    [[nodiscard]] ecs::Entity* resolve() const noexcept { return bound_ ? ecs::try_get(handle_) : nullptr; }
    [[nodiscard]] const ecs::EntityHandle& handle() const noexcept { return handle_; }
    void reset() noexcept {
        bound_  = false;
        handle_ = {};
    }
 
private:
    ecs::EntityHandle handle_{};
    bool              bound_ = false;
};
 
struct ServiceLinkTag {};
 
template <typename Tag>
class ServiceLink {
public:
    [[nodiscard]] static Result<ServiceLink> bind(std::string_view key) {
        if (key.empty()) {
            return Result<ServiceLink>::failure(Diagnostic::error(
                DiagnosticCode::InvalidArgument, "RTS service link key must not be empty", "link.key"));
        }
        ServiceLink result;
        result.key_ = key;
        return Result<ServiceLink>::success(std::move(result));
    }
 
    [[nodiscard]] static ServiceLink fromKeyForRestore(std::string_view key) {
        ServiceLink result;
        result.key_ = key;
        return result;
    }
 
    [[nodiscard]] bool isBound() const noexcept { return !key_.empty(); }
    [[nodiscard]] bool isStale() const noexcept { return key_.empty(); }
    [[nodiscard]] const std::string& key() const noexcept { return key_; }
    void reset() noexcept { key_.clear(); }
 
private:
    std::string key_;
};
 
struct FactionLinkTag {};
struct WeaponLinkTag {};
struct ResourceNodeLinkTag {};
struct BuildingLinkTag {};
struct ContainerLinkTag {};
using FactionLink = EntityLink<FactionLinkTag>;
using WeaponLink  = EntityLink<WeaponLinkTag>;
using ResourceNodeLink = EntityLink<ResourceNodeLinkTag>;
using BuildingLink     = EntityLink<BuildingLinkTag>;
using ContainerLink    = EntityLink<ContainerLinkTag>;
 
struct SensingLinkTag {};
struct SteeringLinkTag {};
struct CrowdLinkTag {};
struct ActionLinkTag {};
struct SettlementLinkTag {};
struct PlacementLinkTag {};
struct EconomyLinkTag {};
struct AuthorityLinkTag {};
struct SocialLinkTag {};
struct GameEventLinkTag {};
using SensingLink    = ServiceLink<SensingLinkTag>;
using SteeringLink   = ServiceLink<SteeringLinkTag>;
using CrowdLink      = ServiceLink<CrowdLinkTag>;
using ActionLink     = ServiceLink<ActionLinkTag>;
using SettlementLink = ServiceLink<SettlementLinkTag>;
using PlacementLink  = ServiceLink<PlacementLinkTag>;
using EconomyLink    = ServiceLink<EconomyLinkTag>;
using AuthorityLink  = ServiceLink<AuthorityLinkTag>;
using SocialLink     = ServiceLink<SocialLinkTag>;
using GameEventLink  = ServiceLink<GameEventLinkTag>;
 
class EVENGINE_API_DOMAINS AttributeComponent {
public:
    AttributeComponent();
    ~AttributeComponent();
    AttributeComponent(const AttributeComponent& other);
    AttributeComponent& operator=(const AttributeComponent& other);
    AttributeComponent(AttributeComponent&& other) noexcept;
    AttributeComponent& operator=(AttributeComponent&& other) noexcept;
 
    [[nodiscard]] Result<void> setBase(std::string_view attribute, double value);
    [[nodiscard]] Result<void> modifyBase(std::string_view attribute, double delta);
    [[nodiscard]] bool has(std::string_view attribute) const;
    [[nodiscard]] Result<double> getFinal(std::string_view attribute, double fallback = 0.0) const;
    [[nodiscard]] std::size_t modifierCount() const noexcept;
    [[nodiscard]] const eve::attributes::AttributeModifier* modifierAt(int index) const noexcept;
 
    [[nodiscard]] Result<void> bindOwner(ecs::EntityHandle owner);
    [[nodiscard]] bool initialized() const noexcept;
    [[nodiscard]] Result<void> initialize(std::span<const eve::attributes::AttributeSnapshotBase> values);
    [[nodiscard]] bool isStale() const noexcept;
    [[nodiscard]] Result<eve::attributes::ModifierId> addModifier(eve::attributes::AttributeModifier modifier);
    [[nodiscard]] Result<eve::attributes::AttributeProjectionSnapshot> snapshot(
        std::span<const std::string_view> attributes) const;
    [[nodiscard]] Result<void> restore(const eve::attributes::AttributeProjectionSnapshot& snapshot,
                                       Revision                                            expectedRevision);
 
private:
    struct Impl;
    std::unique_ptr<Impl> impl_;
};
 
class EVENGINE_API_DOMAINS OrderComponent {
public:
    struct Snapshot {
        std::string queueJson;
        std::map<std::string, CommandSpec> extended;
    };
    OrderComponent();
    ~OrderComponent();
    OrderComponent(const OrderComponent& other);
    OrderComponent& operator=(const OrderComponent& other);
    OrderComponent(OrderComponent&& other) noexcept;
    OrderComponent& operator=(OrderComponent&& other) noexcept;
 
    [[nodiscard]] Result<std::string> enqueue(const CommandSpec& command, int formationSlot = -1);
    [[nodiscard]] Result<std::string> replace(const CommandSpec& command, int formationSlot = -1);
    [[nodiscard]] Result<OrderRecord> current() const;
    [[nodiscard]] Result<void> complete(std::string_view orderId);
    [[nodiscard]] Result<void> fail(std::string_view orderId, std::string_view reason);
    [[nodiscard]] Result<void> cancel(std::string_view orderId, std::string_view reason);
    [[nodiscard]] bool empty() const noexcept;
    void clear() noexcept;
    [[nodiscard]] std::size_t orderCount() const noexcept;
    [[nodiscard]] Result<std::string> snapshot() const;
    [[nodiscard]] Result<void> restore(std::string_view json);
    [[nodiscard]] Result<Snapshot> snapshotState() const;
    [[nodiscard]] Result<void> restoreState(const Snapshot& snapshot);
 
private:
    friend class RTSProductionActionAdapter;
    friend class RTS;
    friend class CommandFanOutSystem;
    std::uint64_t                       membershipEpoch_ = 0;
    [[nodiscard]] orders::CommandQueue* queueForComposition() noexcept;
 
    struct Impl;
    std::unique_ptr<Impl> impl_;
};
 
class EVENGINE_API_DOMAINS ProductionComponent {
public:
    ProductionComponent();
    ~ProductionComponent();
    ProductionComponent(const ProductionComponent& other);
    ProductionComponent& operator=(const ProductionComponent& other);
    ProductionComponent(ProductionComponent&& other) noexcept;
    ProductionComponent& operator=(ProductionComponent&& other) noexcept;
 
    [[nodiscard]] Result<std::string> enqueue(std::string_view owner, std::string_view kind, std::string_view product,
                                              Duration duration, int priority = 0);
    [[nodiscard]] Result<std::string> enqueue(production::ProductionRequest request);
    [[nodiscard]] Result<void> advance(const SimulationStep& step);
    [[nodiscard]] std::size_t taskCount() const noexcept;
    [[nodiscard]] OptionalRef<const production::ProductionTask> taskAt(int index);
    [[nodiscard]] OptionalRef<const production::ProductionTask> find(std::string_view taskId);
    [[nodiscard]] Result<void> pause(std::string_view taskId);
    [[nodiscard]] Result<void> resume(std::string_view taskId);
    [[nodiscard]] Result<void> cancel(std::string_view taskId, std::string_view reason = "cancelled");
    [[nodiscard]] std::vector<production::ProductionTask> readyToSettle(std::string_view kind) const;
    [[nodiscard]] Result<void> settle(std::string_view taskId, production::ProductionSettlementReceipt receipt);
    [[nodiscard]] Result<std::string> snapshot() const;
    [[nodiscard]] Result<void> restore(std::string_view json);
 
private:
    friend class RTSProductionActionAdapter;
    [[nodiscard]] production::WorkQueue* queueForComposition() noexcept;
 
    struct Impl;
    std::unique_ptr<Impl> impl_;
};
 
class EVENGINE_API_DOMAINS Unit : public ecs::Entity {
public:
    ENTITY(Unit, ecs::Entity)
 
    
    void release() override { ecs::DestroyEntity(this); }
 
    struct Identity {
        ecs::EntityHandle self{};
        SubjectRef        subject;
        std::string       displayName;
    };
    struct Definition {
        LogicalId id;
    };
    struct Attributes {
        AttributeComponent values;
    };
    struct Tags {
        TagSet values;
    };
    struct Effects {
        RTSEffectComponent values;
    };
    struct Orders {
        OrderComponent values;
    };
    struct Sensing {
        SensingLink link;
    };
    struct Steering {
        SteeringLink link;
    };
    struct Crowd {
        CrowdLink link;
        float     radius  = 0.5f;
        float     heading = 0.0f;
    };
    struct Weapon {
        WeaponLink link;
    };
    struct Action {
        ActionLink link;
    };
    struct Settlement {
        SettlementLink link;
    };
    struct Faction {
        rts::FactionLink link;
    };
    struct Motion {
        float x             = 0.0f;
        float y             = 0.0f;
        float speed         = 1.0f;
        float arrivalRadius = 0.01f;
        bool  arrived       = true;
        bool  airborne      = false;
    };
    struct Navigation {
        std::vector<WorldPosition> waypoints;
        std::size_t                waypointIndex = 0;
        std::string                plannedOrderId;
        WorldPosition              plannedGoal;
        WorldPosition              patrolOrigin;
        int                        movementPriority = 0;
        bool                       patrolInitialized = false;
        bool                       patrolTowardTarget = true;
        bool                       trafficWaiting = false;
        bool                       unreachable = false;
        bool                       unreachableReported = false;
        float formationSpeedFactor = 1.f;  
        std::optional<WorldPosition> formationTarget;  
        std::optional<WorldPosition> trafficRecoveryTarget;  
    };
    struct Vision {
        float sightRange = 0.0f;
        float detectionRange = 0.0f;
        float detectionStrength = 0.0f;
        float radarRange = 0.0f;
        float radarResolution = 0.0f;
        float jammingRange = 0.0f;
        float stealth = 0.0f;
        bool  enabled = true;
        bool  cloaked = false;
    };
    struct Worker {
        std::string       resourceType;
        ResourceNodeLink  resourceNode;
        BuildingLink      dropoff;
        float             cargo       = 0.0f;
        float             capacity    = 0.0f;
        float             gatherRate  = 0.0f;
        float             buildRate   = 1.0f;
        float             repairRate  = 0.0f;
        bool              autoAssign  = false;
    };
    struct Combat {
        ecs::EntityHandle target{};
        CombatStance      stance           = CombatStance::Defensive;
        float             acquisitionRange = 0.0f;
        float             engagementRange  = 0.0f;
        float             leashRange       = 0.0f;
        float             guardX           = 0.0f;
        float             guardY           = 0.0f;
        bool              guardSet         = false;
        bool              holdPosition     = false;
        bool              attackMove       = false;
        float             suppressionPerShot = 0.0f;
        float             upgradeDamageFactor = 1.0f;
        float             turnRateDegrees = 0.0f;
        float             aimToleranceDegrees = 0.01f;
        float             firingHeight = 1.0f;
        float             targetHeight = 1.0f;
        std::uint64_t     shotSequence = 0;
        std::map<std::string, float> targetPriorities;
    };
    struct Durability {
        combat::CombatState state;
        bool                alive = true;
    };
    struct Shield {
        float value = 0.0f;
        float capacity = 0.0f;
        float regenRate = 0.0f;
        float regenDelay = 0.0f;
        float cooldown = 0.0f;
    };
    struct Veterancy {
        float experience = 0.0f;
        int level = 0;
        float veteranThreshold = 0.0f;
        float eliteThreshold = 0.0f;
        float veteranDamageFactor = 1.0f;
        float eliteDamageFactor = 1.0f;
        float veteranHealthFactor = 1.0f;
        float eliteHealthFactor = 1.0f;
    };
    struct Command {
        float range = 0.0f;
        int capacity = 0;
        int load = 0;
        int cost = 1;
        int priority = 0;
        float jammingRange = 0.0f;
        float outOfCommandSpeedFactor = 1.0f;
        float outOfCommandDamageFactor = 1.0f;
        bool requiresCommand = false;
        bool relayRequiresUplink = false;
        bool relayActive = false;
        bool jammed = false;
        bool inCommand = true;
        ecs::EntityHandle source{};
        ecs::EntityHandle uplink{};
    };
    struct Abilities {
        struct Cooldown { std::string id; float remaining = 0.0f; };
        struct Channel {
            AbilitySpec spec;
            ecs::EntityHandle target{};
            WorldPosition point;
            double startingHealth = 0.0;
            float remaining = 0.0f;
            float tickRemaining = 0.0f;
        };
        std::vector<Cooldown> cooldowns;
        std::optional<Channel> channel;
    };
    struct Capture {
        float rate = 0.0f;
    };
    struct Containment {
        ContainerLink                  container;
        std::size_t                    capacity = 0;
        std::vector<ecs::EntityHandle> occupants;
    };
    struct Supply {
        float stock = 0.0f;
        float capacity = 0.0f;
        float range = 0.0f;
        float transferRate = 0.0f;
        float transferProgress = 0.0f;
        float reservedStock = 0.0f;
        float autoThreshold = 0.5f;
        float priority = 1.0f;
        bool  autoDispatch = false;
        bool  relayEnabled = false;
        bool  returning = false;
        bool  rendezvousActive = false;
        bool  convoyWaiting = false;
        std::size_t convoyIndex = 0;
        ecs::EntityHandle assignedTarget{};
        ecs::EntityHandle convoyLeader{};
        WorldPosition returnPoint;
        WorldPosition rendezvousPoint;
        float rendezvousThreat = 0.0f;
        bool rendezvousAvoidedThreat = false;
        float routeThreat = 0.0f;
        bool routeAvoidedThreat = false;
    };
    struct Morale {
        float suppression = 0.0f;
        float capacity = 0.0f;
        float recoveryRate = 0.0f;
        float suppressedSpeedFactor = 1.0f;
        float suppressedDamageFactor = 1.0f;
        float retreatThreshold = 0.8f;
        float retreatDistance = 6.0f;
        float auraRange = 0.0f;
        float auraSuppressionFactor = 1.0f;
        float auraRecoveryBonus = 0.0f;
        bool active = false;
        bool retreatEnabled = false;
        bool retreating = false;
    };
    struct Artillery {
        float deployTime = 0.0f;
        float deployRemaining = 0.0f;
        float shootAndScootDistance = 0.0f;
        float previousX = 0.0f;
        float previousY = 0.0f;
        WorldPosition relocationTarget;
        WorldPosition departedPosition;
        float relocationThreat = 0.0f;
        int relocationConflictCount = 0;
        bool  positionInitialized = false;
        bool  relocating = false;
        bool  hasDepartedPosition = false;
        std::uint32_t shotSequence = 0;
        int suppressionShotsRemaining = -1;
        ecs::EntityHandle fireSupportRequester{};
        ecs::EntityHandle observedFireSpotter{};
        bool usingObservedFire = false;
        SimulationTick lastFireTick{};
        WorldPosition lastFirePosition;
        bool autoCounterBattery = false;
        std::uint64_t counterBatteryWindowTicks = 0;
    };
    struct Tactics {
        std::uint64_t combatGroup = 0;
        int threatSector = 0;
        float coordinatedVolleyInterval = 0.0f;
        float volleyReleaseRemaining = 0.0f;
        float fireControlEffectiveness = 1.0f;
        bool volleyHolding = false;
        ecs::EntityHandle escortTarget{};
        float escortOffsetX = 0.0f;
        float escortOffsetY = 0.0f;
        float protectionRange = 8.0f;
        float guardX = 0.0f;
        float guardY = 0.0f;
        bool  guardSet = false;
        int escortScreenSector = 0;
        bool escortSectorMatched = false;
        bool escortReinforcing = false;
        int escortReinforcementSector = 0;
        bool escortRearGuard = false;
        SubjectRef escortInterceptTarget;
        std::uint32_t escortHandoffCount = 0;
        int retreatFireTeam = -1;
        float retreatCoverElapsed = 0.0f;
        bool retreatCovering = false;
    };
    struct Technology {
        std::vector<std::string> applied;
    };
 
    COMPONENT(Identity, identity)
    COMPONENT(Definition, definition)
    COMPONENT(Attributes, attributes)
    COMPONENT(Tags, tags)
    COMPONENT(Effects, effects)
    COMPONENT(Orders, orders)
    COMPONENT(Sensing, sensing)
    COMPONENT(Steering, steering)
    COMPONENT(Crowd, crowd)
    COMPONENT(Weapon, weapon)
    COMPONENT(Action, action)
    COMPONENT(Settlement, settlement)
    COMPONENT(Faction, faction)
    COMPONENT(Motion, motion)
    COMPONENT(Navigation, navigation)
    COMPONENT(Vision, vision)
    COMPONENT(Worker, worker)
    COMPONENT(Combat, combat)
    COMPONENT(Durability, durability)
    COMPONENT(Shield, shield)
    COMPONENT(Veterancy, veterancy)
    COMPONENT(Command, command)
    COMPONENT(Abilities, abilities)
    COMPONENT(Capture, capture)
    COMPONENT(Containment, containment)
    COMPONENT(Supply, supply)
    COMPONENT(Morale, morale)
    COMPONENT(Artillery, artillery)
    COMPONENT(Tactics, tactics)
    COMPONENT(Technology, technology)
 
    
    [[nodiscard]] static Unit* createUnit(SubjectRef subject = {}, LogicalId definition = {});
};
 
class EVENGINE_API_DOMAINS Building : public ecs::Entity {
public:
    ENTITY(Building, ecs::Entity)
 
    
    void release() override { ecs::DestroyEntity(this); }
 
    struct Identity {
        ecs::EntityHandle self{};
        SubjectRef        subject;
        std::string       displayName;
    };
    struct Definition {
        LogicalId id;
    };
    struct Placement {
        PlacementLink link;
        int           cellX    = 0;
        int           cellY    = 0;
        float         worldX   = 0.0f;
        float         worldY   = 0.0f;
        float         rotation = 0.0f;
        bool          placed   = false;
    };
    struct Production {
        ProductionComponent values;
    };
    struct Economy {
        EconomyLink link;
    };
    struct Orders {
        OrderComponent values;
    };
    struct Tags {
        TagSet values;
    };
    struct Effects {
        RTSEffectComponent values;
    };
    struct Settlement {
        SettlementLink link;
    };
    struct Faction {
        rts::FactionLink link;
    };
    struct Construction {
        float                          progress = 1.0f;
        float                          buildTimeSeconds = 0.0f;
        bool                           paused = false;
        std::vector<ecs::EntityHandle> builders;
    };
    struct Integrity {
        combat::CombatState state;
        bool        alive               = true;
        float       repairCostPerHealth = 0.0f;
        float       repairCostRemainder = 0.0f;
        std::string repairResource;
    };
    struct Shield {
        float value = 0.0f;
        float capacity = 0.0f;
        float regenRate = 0.0f;
        float regenDelay = 0.0f;
        float cooldown = 0.0f;
    };
    struct Capture {
        bool              capturable = false;
        float             durationSeconds = 5.0f;
        float             progress = 0.0f;
        ecs::EntityHandle capturingFaction{};
        bool              blockedByGarrison = false;
    };
    struct Dropoff {
        std::vector<std::string> acceptedResources;
        float                    radius = 1.0f;
    };
    struct Rally {
        bool          enabled = false;
        CommandSpec   command;
        std::uint64_t combatGroup = 0;
        ecs::EntityHandle transport{};
        std::size_t minimumTransportLoad = 1;
        bool transportActive = false;
        bool productionSpawnBlocked = false;
        std::string blockedProductionTask;
        std::vector<std::string> settledProductionTasks;
        std::vector<ecs::EntityHandle> reinforcements;
        std::size_t reinforcementLimit = 0;
        std::map<std::string, std::size_t> reinforcementTypeLimits;
        std::map<std::string, int> reinforcementTypePriorities;
        std::map<std::string, std::string> reinforcementFallbacks;
        bool reinforcementCapped = false;
        std::string reinforcementPolicyPausedTask;
        float reinforcementAutoCancelDelay = 0.0f;
        float reinforcementCappedSeconds = 0.0f;
    };
    struct Weapon {
        WeaponLink link;
    };
    struct Combat {
        ecs::EntityHandle target{};
        ecs::EntityHandle airDefenseNetworkRoot{};
        float acquisitionRange = 0.0f;
        float engagementRange = 0.0f;
        float airDefenseNetworkRange = 0.0f;
        std::size_t airDefenseNetworkSize = 0;
        float turnRateDegrees = 0.0f;
        float aimToleranceDegrees = 0.01f;
        float firingHeight = 2.0f;
        float targetHeight = 1.5f;
        std::uint64_t shotSequence = 0;
        std::map<std::string, float> targetPriorities;
    };
    struct Garrison {
        std::size_t                    capacity = 0;
        float                          damageBonusPerOccupant = 0.0f;
        std::vector<ecs::EntityHandle> occupants;
    };
    struct Supply {
        float stock = 0.0f;
        float capacity = 0.0f;
        float range = 0.0f;
        float transferRate = 0.0f;
        float transferProgress = 0.0f;
        std::string productionResource;
        std::int64_t productionCostPerRound = 0;
        float productionRate = 0.0f;
        float productionProgress = 0.0f;
    };
    struct Vision {
        float sightRange = 0.0f;
        float detectionRange = 0.0f;
        float detectionStrength = 0.0f;
        float radarRange = 0.0f;
        float radarResolution = 0.0f;
        float jammingRange = 0.0f;
        bool  enabled = true;
    };
    struct Technology {
        std::vector<std::string> applied;
    };
    struct Infrastructure {
        float powerProduced = 0.0f;
        float powerConsumed = 0.0f;
        int   powerPriority = 0;
        bool  powered = true;
        float buildInfluenceRadius = 0.0f;
        std::string incomeResource;
        float incomeRate = 0.0f;
        float incomeProgress = 0.0f;
    };
    struct Command {
        float range = 0.0f;
        int capacity = 0;
        int load = 0;
        float jammingRange = 0.0f;
        bool jammed = false;
        bool active = false;
    };
    struct IndirectFire {
        SimulationTick lastFireTick{};
        WorldPosition lastFirePosition;
    };
 
    COMPONENT(Identity, identity)
    COMPONENT(Definition, definition)
    COMPONENT(Placement, placement)
    COMPONENT(Production, production)
    COMPONENT(Economy, economy)
    COMPONENT(Orders, orders)
    COMPONENT(Tags, tags)
    COMPONENT(Effects, effects)
    COMPONENT(Settlement, settlement)
    COMPONENT(Faction, faction)
    COMPONENT(Construction, construction)
    COMPONENT(Integrity, integrity)
    COMPONENT(Shield, shield)
    COMPONENT(Capture, capture)
    COMPONENT(Dropoff, dropoff)
    COMPONENT(Rally, rally)
    COMPONENT(Weapon, weapon)
    COMPONENT(Combat, combat)
    COMPONENT(Garrison, garrison)
    COMPONENT(Supply, supply)
    COMPONENT(Vision, vision)
    COMPONENT(Technology, technology)
    COMPONENT(Infrastructure, infrastructure)
    COMPONENT(Command, command)
    COMPONENT(IndirectFire, indirectFire)
 
    
    [[nodiscard]] static Building* createBuilding(SubjectRef subject = {}, LogicalId definition = {});
};
 
class EVENGINE_API_DOMAINS ResourceNode : public ecs::Entity {
public:
    ENTITY(ResourceNode, ecs::Entity)
 
    
    void release() override { ecs::DestroyEntity(this); }
 
    struct Identity {
        ecs::EntityHandle self{};
        SubjectRef        subject;
        std::string       displayName;
    };
    struct Position {
        float x = 0.0f;
        float y = 0.0f;
        float radius = 1.0f;
    };
    struct Stock {
        std::string resourceType;
        float       remaining = 0.0f;
        float       maximum = 0.0f;
        bool        infinite = false;
    };
    struct Harvest {
        std::size_t                    capacity = 1;
        std::vector<ecs::EntityHandle> workers;
    };
 
    COMPONENT(Identity, identity)
    COMPONENT(Position, position)
    COMPONENT(Stock, stock)
    COMPONENT(Harvest, harvest)
 
    
    [[nodiscard]] static ResourceNode* createResourceNode(SubjectRef subject = {});
};
 
class Player : public ecs::Entity {
public:
    ENTITY(Player, ecs::Entity)
 
    
    void release() override { ecs::DestroyEntity(this); }
 
    struct Identity {
        ecs::EntityHandle self{};
        SubjectRef        subject;
        std::string       displayName;
    };
    struct Authority {
        AuthorityLink link;
    };
    struct Economy {
        EconomyLink link;
    };
    struct Social {
        SocialLink link;
    };
    struct Selection {
        std::vector<ecs::EntityHandle> units;
        std::vector<ecs::EntityHandle> buildings;
        std::uint64_t revision = 0;
        SimulationTick tick = SimulationTick::zero();
    };
    struct GameEvent {
        GameEventLink link;
    };
    COMPONENT(Identity, identity)
    COMPONENT(Authority, authority)
    COMPONENT(Economy, economy)
    COMPONENT(Social, social)
    COMPONENT(Selection, selection)
    COMPONENT(GameEvent, eventStream)
 
    
    [[nodiscard]] static Player* createPlayer(SubjectRef subject = {});
};
 
class EVENGINE_API_DOMAINS Faction : public ecs::Entity {
public:
    ENTITY(Faction, ecs::Entity)
 
    
    void release() override { ecs::DestroyEntity(this); }
 
    struct Identity {
        ecs::EntityHandle self{};
        SubjectRef        subject;
        std::string       displayName;
    };
    struct Authority {
        AuthorityLink link;
    };
    struct Economy {
        EconomyLink link;
    };
    struct Social {
        SocialLink link;
    };
    struct Members {
        std::vector<ecs::EntityHandle> units;
        std::vector<ecs::EntityHandle> buildings;
    };
    struct GameEvent {
        GameEventLink link;
    };
    struct Strategy {
        LogicalId workerDefinition;
        LogicalId armyDefinition;
        LogicalId targetBuildingDefinition;
        int desiredWorkers = 0;
        int attackThreshold = 1;
        float thinkInterval = 1.0f;
        float thinkAccumulator = 0.0f;
        float formationSpacing = 1.1f;
        bool enabled = false;
    };
    struct Workforce {
        bool autoConstruction = false;
        bool autoRepair = false;
        std::size_t maxBuildersPerSite = 2;
        std::size_t maxRepairersPerBuilding = 2;
        std::size_t reserveWorkers = 0;
    };
    struct ProductionPolicy {
        struct Reserve {
            std::int64_t amount = 0;
            int minimumPriority = 0;
        };
        std::map<std::string, Reserve> resourceReserves;
    };
    struct Intel {
        struct Contact {
            SubjectRef    subject;
            std::string   kind;
            WorldPosition position;
            double        ageSeconds = 0.0;
            bool          visible = false;
            bool          detected = false;
        };
        bool enabled = false;
        std::vector<Contact> contacts;
    };
    struct Technology {
        std::vector<std::string> unlocked;
        std::vector<std::string> consumedTasks;
        std::map<std::string, Value::Object> unlockedDefinitions;
    };
 
    COMPONENT(Identity, identity)
    COMPONENT(Authority, authority)
    COMPONENT(Economy, economy)
    COMPONENT(Social, social)
    COMPONENT(Members, members)
    COMPONENT(GameEvent, eventStream)
    COMPONENT(Strategy, strategy)
    COMPONENT(Workforce, workforce)
    COMPONENT(ProductionPolicy, productionPolicy)
    COMPONENT(Intel, intel)
    COMPONENT(Technology, technology)
 
    
    [[nodiscard]] static Faction* createFaction(SubjectRef subject = {});
};
 
enum class VictoryRule : std::uint8_t { Annihilation, DestroyHeadquarters, ResourceTarget };
enum class MatchPhase : std::uint8_t { Setup, Running, Finished };
 
class EVENGINE_API_DOMAINS Match : public ecs::Entity {
public:
    ENTITY(Match, ecs::Entity)
    void release() override { ecs::DestroyEntity(this); }
 
    struct Identity {
        ecs::EntityHandle self{};
        SubjectRef subject;
    };
    struct Rules {
        VictoryRule rule = VictoryRule::Annihilation;
        std::string archetype;
        double targetValue = 0.0;
    };
    struct Participants {
        struct Entry {
            FactionLink faction;
            int team = 0;
            bool eliminated = false;
            bool surrendered = false;
            std::string reason;
        };
        std::vector<Entry> entries;
    };
    struct State {
        MatchPhase phase = MatchPhase::Setup;
        int winningTeam = -1;
        std::uint64_t updateSequence = 0;
    };
    struct Events {
        struct Event {
            std::uint64_t sequence = 0;
            std::string kind;
            SubjectRef faction;
            int team = -1;
            std::string reason;
        };
        std::vector<Event> values;
    };
 
    COMPONENT(Identity, identity)
    COMPONENT(Rules, rules)
    COMPONENT(Participants, participants)
    COMPONENT(State, state)
    COMPONENT(Events, events)
 
    
    [[nodiscard]] static Match* createMatch(SubjectRef subject = {});
};
 
}  // namespace eve::rts