RTS.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "common/GameplayControl.h"
#include "common/GameplayInstanceCatalog.h"
#include "common/Module.h"
#include "common/Snapshot.h"
#include "rts/RTSArchetype.h"
#include "rts/RTSAttributes.h"
#include "rts/RTSContent.h"
#include "rts/RTSEffects.h"
#include "rts/RTSMatch.h"
#include "rts/RTSProductionAction.h"
#include "rts/RTSReplay.h"
#include "rts/RTSSnapshot.h"
#include "rts/RTSSystems.h"
#include "rts/RTSTech.h"
 
#include <cstddef>
#include <memory>
#include <span>
#include <utility>
#include <vector>
 
namespace eve::rts {
 
struct RTSFrameDamageEvent {
    std::uint64_t sequence = 0;
    SimulationTick tick;
    DamageChannel channel = DamageChannel::Weapon;
    combat::DamageRequest request;
    combat::DamageOutcome outcome;
};
 
struct RTSFrameCombatEvent {
    std::uint64_t sequence = 0;
    SimulationTick tick;
    CombatFireEvent event;
};
 
struct RTSFrameLifecycleEvent {
    std::uint64_t sequence = 0;
    SimulationTick tick;
    LifecycleEvent event;
};
 
class EVENGINE_API_DOMAINS RTS : public Module, public IGameplayControlProvider, public IGameplayInstanceCatalog {
public:
    Module_REG(RTS);
 
    RTS();
    ~RTS() override;
 
    [[nodiscard]] std::string_view gameplayDomain() const noexcept override;
    [[nodiscard]] std::vector<SubjectRef> gameplayInstances() const override;
    [[nodiscard]] Result<GameplayObservation> observeGameplay(const GameplaySession& session,
                                                               SubjectRef instance) const override;
    [[nodiscard]] Result<std::vector<GameplayActionDescriptor>> availableGameplayActions(
        const GameplaySession& session, SubjectRef instance, SubjectRef subject) const override;
    [[nodiscard]] Result<GameplayCommandReceipt> submitGameplay(const GameplaySession& session,
                                                                 SubjectRef instance,
                                                                 const GameplayCommand& command) override;
    [[nodiscard]] Result<GameplayObservation> advanceGameplay(const GameplaySession& session,
                                                               SubjectRef instance,
                                                               const SimulationStep& step) override;
    [[nodiscard]] Result<std::vector<GameplayEvent>> gameplayEvents(const GameplaySession& session,
                                                                     SubjectRef instance,
                                                                     std::uint64_t afterSequence) const override;
 
    [[nodiscard]] Result<Unit*> newUnit(SubjectRef subject, LogicalId definition = {});
    [[nodiscard]] Result<Building*> newBuilding(SubjectRef subject, LogicalId definition = {});
    [[nodiscard]] Result<ResourceNode*> newResourceNode(SubjectRef subject, std::string resourceType,
                                                        float amount, WorldPosition position,
                                                        std::size_t workerCapacity = 1);
    [[nodiscard]] Result<Player*> newPlayer(SubjectRef subject);
    [[nodiscard]] Result<Faction*> newFaction(SubjectRef subject);
    [[nodiscard]] Result<Unit*> newFactionUnit(Faction& faction, SubjectRef subject,
                                                LogicalId definition = {});
    [[nodiscard]] Result<Building*> newFactionBuilding(Faction& faction, SubjectRef subject,
                                                        LogicalId definition = {});
    [[nodiscard]] Result<Match*> newMatch(SubjectRef subject);
    [[nodiscard]] Result<void> configureMatch(Match& match, VictoryRule rule,
                                               std::string archetype = {}, double targetValue = 0.0) const;
    [[nodiscard]] Result<void> addMatchParticipant(Match& match, Faction& faction, int team) const;
    [[nodiscard]] Result<void> startMatch(Match& match) const;
    [[nodiscard]] Result<void> surrenderMatch(Match& match, Faction& faction) const;
    [[nodiscard]] Result<Value> inspectMatch(Match& match) const;
 
    [[nodiscard]] Unit* findUnit(SubjectRef subject) const noexcept;
    [[nodiscard]] Building* findBuilding(SubjectRef subject) const noexcept;
    [[nodiscard]] ResourceNode* findResourceNode(SubjectRef subject) const noexcept;
    [[nodiscard]] Faction* findFaction(SubjectRef subject) const noexcept;
    [[nodiscard]] Match* findMatch(SubjectRef subject) const noexcept;
    [[nodiscard]] Result<RTSStateSnapshot> snapshotState() const;
    [[nodiscard]] Result<void> restoreState(const RTSStateSnapshot& snapshot);
    [[nodiscard]] Result<void> rebuildState(const RTSStateSnapshot& snapshot);
    [[nodiscard]] Result<std::string> canonicalStateJson() const;
    [[nodiscard]] Result<ContentId> stateHash(const SnapshotHashProvider& hashProvider) const;
 
    [[nodiscard]] Result<FanOutReceipt> fanOut(Player::Selection& selection, const CommandSpec& command,
                                               const FormationSpec& formation) const;
 
    [[nodiscard]] Result<FanOutReceipt> commandUnits(std::span<const SubjectRef> subjects,
                                                      const CommandSpec& command,
                                                      const FormationSpec& formation = {}) const;
 
    [[nodiscard]] Result<FanOutReceipt> submitMovementGroup(const MovementGroupBatch& batch);
 
    [[nodiscard]] Result<void> setUnitStance(std::span<const SubjectRef> subjects,
                                             CombatStance stance, float leashRange) const;
    [[nodiscard]] Result<void> setUnitMovementPriority(std::span<const SubjectRef> subjects,
                                                       int priority) const;
    [[nodiscard]] Result<void> assignWorker(Unit& worker, ResourceNode& node,
                                             Building& dropoff) const;
    [[nodiscard]] Result<void> setWorkerAutoAssignment(std::span<const SubjectRef> subjects,
                                                        bool enabled) const;
    [[nodiscard]] Result<void> configureWorkforce(
        Faction& faction, bool autoConstruction, int maxBuildersPerSite,
        bool autoRepair, int maxRepairersPerBuilding, int reserveWorkers) const;
    [[nodiscard]] Result<std::string> assignBuilder(Unit& worker, Building& building) const;
    [[nodiscard]] Result<int> addUnitReserveAmmo(Unit& unit, int rounds) const;
    [[nodiscard]] Result<float> addUnitAmmoSupply(Unit& unit, float rounds) const;
    [[nodiscard]] Result<float> addBuildingAmmoSupply(Building& building, float rounds) const;
    [[nodiscard]] Result<void> setUnitAutoResupply(Unit& unit, bool enabled) const;
    [[nodiscard]] Result<FanOutReceipt> suppressArea(
        std::span<const SubjectRef> subjects, WorldPosition start, WorldPosition end,
        float width = 1.0f, int shotsPerUnit = 0) const;
    [[nodiscard]] Result<FanOutReceipt> escortUnits(
        std::span<const SubjectRef> subjects, SubjectRef protectedSubject,
        float guardRadius = 6.0f, float spacing = 1.5f) const;
 
    [[nodiscard]] Value inspectState() const;
 
    [[nodiscard]] Value inspectFrameEvents() const;
 
    [[nodiscard]] Result<double> readUnitAttribute(Unit& unit, std::string_view attribute) const;
    [[nodiscard]] Result<void> setUnitAttribute(Unit& unit, std::string_view attribute, double value) const;
    [[nodiscard]] Result<effects::EffectHandle> applyEffect(Unit& unit, const RTSEffectDefinition& definition) const;
    [[nodiscard]] Result<effects::EffectHandle> applyEffect(Building&                  building,
                                                            const RTSEffectDefinition& definition) const;
    [[nodiscard]] Result<double> heal(SubjectRef source, SubjectRef target, double amount) const;
    [[nodiscard]] Result<effects::EffectHandle> applyStatusEffect(
        SubjectRef source, SubjectRef target, std::string effect, double durationOverride = -1.0);
 
    [[nodiscard]] Result<RTSBuildReceipt> build(Building& building, action::ActionRuntime& action,
                                                resource::IResourceAccount& account, resource::CostSpec cost,
                                                std::string product, Duration duration,
                                                std::string productionKind = "unit", int priority = 0,
                                                std::string transactionId = {},
                                                definition::DefinitionHandle definition = {});
 
    [[nodiscard]] Result<void> setProductionResourceReserve(
        Faction& faction, std::string resource, std::int64_t amount, int minimumPriority);
 
    [[nodiscard]] Result<RTSCancelProductionReceipt> cancelProduction(
        Building& building, resource::IResourceAccount& account, std::string productionTaskId,
        std::string orderId, resource::CostSpec refund, std::string reason = "production cancelled");
 
    [[nodiscard]] Result<ContentImportReceipt> loadContent(definitions::DefinitionRegistry& registry,
                                                            std::string_view json) {
        auto loaded = RTSContentLoader::load(registry, json);
        if (loaded) definitions_ = &registry;
        return loaded;
    }
    void setDefinitionRegistry(definitions::DefinitionRegistry* registry) noexcept { definitions_ = registry; }
 
    void setResourceCredit(ResourceCredit credit) { resourceCredit_ = std::move(credit); }
    void setRepairDebit(RepairDebit debit) { repairDebit_ = std::move(debit); }
    void setCrowdProvider(crowd::Crowd* crowd) noexcept;
    void setNavigationProvider(map::Pathfinder* pathfinder, NavigationGrid grid = {},
                               NavigationEvent unreachable = {}) noexcept;
    void setFogProvider(FogProvider provider) noexcept;
    void setCombatProviders(sensing::SensingWorld* sensing, combat::DamageRuntime* damage) noexcept;
    [[nodiscard]] Result<void> configureSettlementRules(const settlement::SettlementRuleSet& rules);
    void setFireLineQuery(FireLineQuery query) { fireLineQuery_ = std::move(query); }
    void setCombatHeightQuery(CombatHeightQuery query) { combatHeightQuery_ = std::move(query); }
    void setProjectileCollisionQuery(ProjectileCollisionQuery query) {
        projectileCollisionQuery_ = std::move(query);
    }
    void setAIProductionRequest(AIProductionRequest request) { aiProductionRequest_ = std::move(request); }
    void setMatchResourceQuery(MatchResourceQuery query) { matchResourceQuery_ = std::move(query); }
    void setPassiveIncomeCredit(PassiveIncomeCredit credit) { passiveIncomeCredit_ = std::move(credit); }
    void setAmmoProductionPurchase(AmmoProductionPurchase purchase) {
        ammoProductionPurchase_ = std::move(purchase);
    }
    void setProductionSpawn(ProductionSpawn spawn) { productionSpawn_ = std::move(spawn); }
    void setProductionSpawnPosition(ProductionSpawnPosition position) {
        productionSpawnPosition_ = std::move(position);
    }
    void setReinforcementCancel(ReinforcementCancel cancel) { reinforcementCancel_ = std::move(cancel); }
 
    [[nodiscard]] Result<std::size_t> step(const SimulationStep& step, IRTSActionExecutor& executor);
 
    [[nodiscard]] Result<std::size_t> stepScript(double seconds);
 
    [[nodiscard]] Result<void> configureScriptWorld(int width, int height, float cellSize,
                                                     float originX = 0.0f, float originY = 0.0f);
    [[nodiscard]] Result<void> setScriptNavigationBlocked(int x, int y, bool blocked);
    [[nodiscard]] Result<void> setScriptNavigationCost(int x, int y, float cost);
    [[nodiscard]] Result<void> setScriptTerrainElevation(int x, int y, float elevation);
    [[nodiscard]] Result<float> scriptTerrainElevation(int x, int y) const;
    [[nodiscard]] Result<void> addScriptResource(Faction& faction, std::string resource, std::int64_t amount);
    [[nodiscard]] Result<std::int64_t> scriptResource(Faction& faction, std::string_view resource) const;
    [[nodiscard]] Result<void> configureScriptAI(Faction& faction, LogicalId workerDefinition,
        LogicalId armyDefinition, LogicalId targetBuildingDefinition, int desiredWorkers,
        int attackThreshold, float thinkInterval = 1.0f, float formationSpacing = 1.2f,
        bool enabled = true);
    [[nodiscard]] Result<ContentImportReceipt> loadScriptContent(std::string_view json);
    [[nodiscard]] Result<RTSBuildReceipt> queueScriptUnit(Building& producer, SubjectRef unitSubject,
                                                           LogicalId unitDefinition, int priority = 0);
    [[nodiscard]] Result<ReinforcementRequestReceipt> queueScriptReinforcement(
        Building& producer, SubjectRef unitSubject, LogicalId preferredDefinition, int priority = 0);
    [[nodiscard]] Result<Building*> startScriptConstruction(Faction& faction, SubjectRef buildingSubject,
                                                             LogicalId buildingDefinition, WorldPosition position,
                                                             Unit& builder);
    [[nodiscard]] Result<resource::Receipt> cancelScriptConstruction(Building& building);
    [[nodiscard]] Result<resource::Receipt> sellScriptBuilding(Building& building);
    [[nodiscard]] Result<RTSBuildReceipt> queueScriptResearch(Building& producer, std::string upgrade,
                                                               int priority = 0);
    [[nodiscard]] Result<RTSCancelProductionReceipt> cancelScriptProduction(
        Building& producer, int queueIndex = -1);
    [[nodiscard]] Result<void> setBuildingRally(
        Building& producer, CommandSpec command, bool groupedReinforcements = false) const;
    [[nodiscard]] Result<void> linkBuildingRally(Building& producer, Building& source) const;
    [[nodiscard]] Result<void> clearBuildingRally(Building& producer) const;
    [[nodiscard]] Result<void> setReinforcementLimit(Building& producer, std::size_t maximum) const;
    [[nodiscard]] Result<void> setReinforcementTypeLimit(
        Building& producer, std::string unitType, std::size_t maximum) const;
    [[nodiscard]] Result<void> setReinforcementTypePriority(
        Building& producer, std::string unitType, int priority) const;
    [[nodiscard]] Result<void> setReinforcementFallback(
        Building& producer, std::string preferred, std::string fallback) const;
    [[nodiscard]] Result<void> setReinforcementAutoCancel(Building& producer, float seconds) const;
    [[nodiscard]] Result<void> setReinforcementTransport(
        Building& producer, Unit* transport, std::size_t minimumLoad = 0) const;
    [[nodiscard]] Result<void> castScriptAbility(Unit& caster, std::string ability,
                                                  SubjectRef target, WorldPosition point);
    [[nodiscard]] Result<void> cancelScriptAbility(Unit& caster);
    [[nodiscard]] Result<std::size_t> requestFireSupport(
        Unit& requester, WorldPosition center, float radius, int shotsPerResponder,
        std::size_t maxResponders = 0) const;
    [[nodiscard]] Result<std::size_t> cancelFireSupport(Unit& requester) const;
    [[nodiscard]] Result<std::size_t> unloadTransport(Unit& transport, WorldPosition destination) const;
    [[nodiscard]] Result<std::size_t> evacuateBuilding(Building& building, WorldPosition destination) const;
    [[nodiscard]] Result<void> setUnitCloaked(Unit& unit, bool cloaked) const;
    [[nodiscard]] Result<void> queueScriptCommand(RTSReplayCommand command);
    [[nodiscard]] Result<std::string> exportScriptCommandLog() const;
    [[nodiscard]] Result<void> importScriptCommandLog(std::string_view text, bool clearExisting = true);
    [[nodiscard]] std::uint64_t scriptTick() const noexcept;
    [[nodiscard]] Result<void> captureScriptCheckpoint(std::string name);
    [[nodiscard]] Result<void> restoreScriptCheckpoint(std::string_view name);
    [[nodiscard]] Result<void> removeScriptCheckpoint(std::string_view name);
    [[nodiscard]] Result<bool> scriptCellVisible(Faction& faction, int x, int y) const;
    [[nodiscard]] Result<bool> scriptCellExplored(Faction& faction, int x, int y) const;
    [[nodiscard]] Result<Value> scriptContact(Faction& faction, SubjectRef target) const;
 
    [[nodiscard]] Result<void> remove(SubjectRef subject);
    [[nodiscard]] Result<std::size_t> cleanupDestroyed();
 
    [[nodiscard]] std::size_t unitCount() const noexcept;
    [[nodiscard]] std::size_t buildingCount() const noexcept;
    [[nodiscard]] std::size_t resourceNodeCount() const noexcept;
    [[nodiscard]] std::size_t playerCount() const noexcept;
    [[nodiscard]] std::size_t factionCount() const noexcept;
    [[nodiscard]] std::size_t matchCount() const noexcept;
 
private:
    struct MovementGroup {
        RTSMovementGroupSnapshot       state;
        std::vector<ecs::EntityHandle> handles;
        std::vector<std::uint64_t>     epochs;
    };
    std::vector<MovementGroup>                                  movementGroups_;
    [[nodiscard]] Result<std::size_t>                           stepMovementGroups();
    [[nodiscard]] Result<std::vector<RTSMovementGroupSnapshot>> captureMovementGroups() const;
    [[nodiscard]] Result<std::vector<MovementGroup>> prepareMovementGroups(const RTSStateSnapshot& snapshot) const;
    struct GameplayRuntime;
    [[nodiscard]] Player* resolvePlayer(SubjectRef subject) const noexcept;
    [[nodiscard]] Unit* resolveUnit(SubjectRef subject) const noexcept;
    enum class SubjectClaimScope { Live, LiveOrReserved };
    [[nodiscard]] bool         ownsSubject(SubjectRef        subject,
                                           SubjectClaimScope scope = SubjectClaimScope::Live) const noexcept;
    void recordDamageEvent(const combat::DamageRequest& request,
                           const combat::DamageOutcome& outcome,
                           SimulationTick tick, DamageChannel channel);
    void recordCombatEvent(const CombatFireEvent& event, SimulationTick tick);
    void recordLifecycleEvent(const LifecycleEvent& event, SimulationTick tick);
    void clearOwnedRoots() noexcept;
    [[nodiscard]] Result<void> rebindScriptRootProviders();
    [[nodiscard]] Result<void> materialize(Unit& unit);
    [[nodiscard]] Result<void> materialize(Building& building);
    enum class UnitRemovalReason { Gameplay, SpawnRollback };
    [[nodiscard]] Result<ProductionSpawnOutcome> placeProducedUnit(Unit& unit, WorldPosition requested);
    void                             removeUnitRoot(Unit& unit, UnitRemovalReason reason = UnitRemovalReason::Gameplay);
    void removeBuildingRoot(Building& building, bool destroyOccupants);
    void removeResourceNodeRoot(ResourceNode& node);
    std::vector<ecs::EntityHandle> units_;
    std::vector<ecs::EntityHandle> buildings_;
    std::vector<ecs::EntityHandle> resourceNodes_;
    std::vector<ecs::EntityHandle> players_;
    std::vector<ecs::EntityHandle> factions_;
    std::vector<ecs::EntityHandle> matches_;
    std::vector<ecs::EntityHandle> weapons_;
    ResourceCredit resourceCredit_;
    RepairDebit repairDebit_;
    crowd::Crowd* crowd_ = nullptr;
    map::Pathfinder* pathfinder_ = nullptr;
    NavigationGrid navigationGrid_;
    NavigationEvent navigationEvent_;
    FogProvider fogProvider_;
    FogOfWarSystem::State fogState_;
    sensing::SensingWorld* sensing_ = nullptr;
    combat::DamageRuntime* damage_ = nullptr;
    CombatFireSystem::State combatState_;
    FireLineQuery fireLineQuery_;
    CombatHeightQuery combatHeightQuery_;
    ProjectileCollisionQuery projectileCollisionQuery_;
    RTSProjectileSystem projectiles_;
    std::vector<RTSFrameDamageEvent> frameDamageEvents_;
    std::vector<RTSFrameCombatEvent> frameCombatEvents_;
    std::vector<RTSFrameLifecycleEvent> frameLifecycleEvents_;
    std::uint64_t frameEventSequence_ = 0;
    bool preserveFrameEventsOnNextStep_ = false;
    AIProductionRequest aiProductionRequest_;
    definitions::DefinitionRegistry* definitions_ = nullptr;
    MatchResourceQuery matchResourceQuery_;
    PassiveIncomeCredit passiveIncomeCredit_;
    AmmoProductionPurchase ammoProductionPurchase_;
    ProductionSpawn productionSpawn_;
    ProductionSpawnPosition productionSpawnPosition_;
    ReinforcementCancel reinforcementCancel_;
    struct ScriptRuntime;
    std::unique_ptr<ScriptRuntime> scriptRuntime_;
    std::unique_ptr<GameplayRuntime> gameplayRuntime_;
    std::uint64_t                   nextGameplayEventSequence_ = 1;
    std::vector<GameplayEvent>      gameplayEvents_;
};
 
}  // namespace eve::rts