Tactics.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "common/GameplayControl.h"
#include "common/GameplayInstanceCatalog.h"
#include "common/Module.h"
#include "common/SquirrelOwnership.h"
#include "tactics/Interaction.h"
#include "tactics/Presentation.h"
#include "tactics/TacticsBattle.h"
#include "tactics/TacticsPersistence.h"
#include "tactics/TacticsReplay.h"
 
#include <cstddef>
#include <vector>
 
namespace eve::tactics {
 
struct TacticsBattleSessionTag {};
using TacticsBattleSessionRef = script::RuntimeHandleRef<TacticsBattleSessionTag>;
 
struct TacticsBattleSession {
    ~TacticsBattleSession() noexcept;
 
    ecs::EntityHandle battle{};
};
 
class EVENGINE_API_DOMAINS Tactics : public Module, public IGameplayControlProvider, public IGameplayInstanceCatalog {
public:
    Module_REG(Tactics);
 
    Tactics();
    ~Tactics() 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<ecs::EntityHandle> newBattle(SubjectRef subject, std::uint64_t seed = 0);
    [[nodiscard]] Result<ecs::EntityHandle> newSide(ecs::EntityHandle battle, SubjectRef subject);
    [[nodiscard]] Result<ecs::EntityHandle> newUnit(ecs::EntityHandle battle, ecs::EntityHandle side,
                                                     SubjectRef subject, LogicalId definition, Cell cell,
                                                     TurnResourceSpec resources = {});
 
    [[nodiscard]] Result<void> addCell(ecs::EntityHandle battle, Cell cell, CellState state = {});
    [[nodiscard]] Result<void> setTopology(ecs::EntityHandle battle, BoardTopology topology);
    [[nodiscard]] Result<void> start(ecs::EntityHandle battle, std::string_view policyId);
    [[nodiscard]] Result<BattlePhase> advance(ecs::EntityHandle battle, const SimulationStep& step);
    [[nodiscard]] Result<void> endTurn(ecs::EntityHandle battle, SubjectRef actor);
    [[nodiscard]] Result<AbilityReceipt> useAbility(ecs::EntityHandle battle, SubjectRef actor,
                                                    const LogicalId& action, Cell targetCell,
                                                    SubjectRef targetUnit = {}, std::string payload = {});
 
    [[nodiscard]] Result<AbilityReceipt> previewAbility(ecs::EntityHandle battle, SubjectRef actor,
                                                        const LogicalId& action, Cell targetCell,
                                                        SubjectRef targetUnit = {},
                                                        std::string_view payload = {});
    [[nodiscard]] Result<MoveReceipt> moveUnit(ecs::EntityHandle battle, SubjectRef actor, Cell destination);
    [[nodiscard]] Result<void> faceUnit(ecs::EntityHandle battle, SubjectRef actor, int facing);
    [[nodiscard]] Result<void> waitUnit(ecs::EntityHandle battle, SubjectRef actor);
    [[nodiscard]] Result<void> finish(ecs::EntityHandle battle);
 
    [[nodiscard]] Result<MoveReceipt> previewMove(ecs::EntityHandle battle, SubjectRef actor, Cell destination);
    [[nodiscard]] Result<void> previewFace(ecs::EntityHandle battle, SubjectRef actor, int facing);
    [[nodiscard]] Result<void> previewWait(ecs::EntityHandle battle, SubjectRef actor);
 
    [[nodiscard]] Result<Reachability> reachable(ecs::EntityHandle battle, SubjectRef subject, int budget);
    [[nodiscard]] Result<std::vector<Cell>> cellsInRange(ecs::EntityHandle battle, Cell origin, int minimum,
                                                         int maximum, CellRangeMetric metric);
    [[nodiscard]] Result<TacticalUnit::TurnResources> unitResources(ecs::EntityHandle battle, SubjectRef unit);
 
    [[nodiscard]] Result<void> addEdge(ecs::EntityHandle battle, Cell from, Cell to, EdgeState state = {});
    [[nodiscard]] Result<EdgeState> edge(ecs::EntityHandle battle, Cell from, Cell to);
    [[nodiscard]] std::optional<EdgeState> tryEdge(ecs::EntityHandle battle, Cell from, Cell to);
    [[nodiscard]] Result<std::string> policyId(ecs::EntityHandle battle);
    [[nodiscard]] Result<std::size_t> openReaction(ecs::EntityHandle battle, std::uint64_t triggerSequence,
                                                   std::vector<ReactionCandidate> candidates);
    [[nodiscard]] Result<ReactionReceipt> acceptReaction(ecs::EntityHandle battle, SubjectRef reactor,
                                                          const LogicalId& action);
    [[nodiscard]] Result<void> declineReaction(ecs::EntityHandle battle);
    [[nodiscard]] Result<void> addObjective(ecs::EntityHandle battle, ObjectiveSpec objective);
    [[nodiscard]] Result<void> defeatUnit(ecs::EntityHandle battle, SubjectRef unit);
    [[nodiscard]] Result<std::uint64_t> roll(ecs::EntityHandle battle, const LogicalId& stream);
 
    [[nodiscard]] Result<BattleStatus> status(ecs::EntityHandle battle);
    [[nodiscard]] Result<BattlePhase> phase(ecs::EntityHandle battle);
    [[nodiscard]] Result<SubjectRef> activeUnit(ecs::EntityHandle battle);
    [[nodiscard]] Result<SnapshotEnvelope> snapshot(ecs::EntityHandle battle,
                                                    const SnapshotHashProvider& hashProvider);
    [[nodiscard]] Result<void> restore(ecs::EntityHandle battle, const SnapshotEnvelope& snapshot,
                                       const SnapshotHashProvider& hashProvider);
    [[nodiscard]] Result<std::vector<BattleCommand>> commandsFrom(ecs::EntityHandle battle, Revision revision);
    [[nodiscard]] Result<void> replay(ecs::EntityHandle battle, std::span<const BattleCommand> commands);
 
    [[nodiscard]] Result<std::string> snapshotJson(ecs::EntityHandle battle);
 
    [[nodiscard]] Result<void> restoreJson(ecs::EntityHandle battle, std::string_view json);
 
    [[nodiscard]] Result<std::string> commandLogJson(ecs::EntityHandle battle, Revision revision);
 
    [[nodiscard]] Result<void> replayJson(ecs::EntityHandle battle, std::string_view json);
 
    [[nodiscard]] Result<std::vector<Cell>> visibleCellsInRange(ecs::EntityHandle battle, Cell origin, int minimum,
                                                                int maximum, CellRangeMetric metric);
 
    [[nodiscard]] Result<InteractionContext> interactionContext(ecs::EntityHandle battle, SubjectRef controlledUnit);
 
    [[nodiscard]] std::string_view lineOfSightAlgorithm() const noexcept;
 
    [[nodiscard]] Result<void> attachLineOfSightBoard(ecs::EntityHandle battle);
 
    [[nodiscard]] Result<void> detachLineOfSightBoard(ecs::EntityHandle battle);
 
    [[nodiscard]] Result<std::vector<PresentationCommand>> presentationIntents(ecs::EntityHandle battle,
                                                                             std::uint64_t afterSequence,
                                                                             std::uint64_t transientTicks = 20);
 
    [[nodiscard]] std::string_view snapshotHashAlgorithm() const noexcept;
 
    [[nodiscard]] std::size_t battleCount() const noexcept;
    [[nodiscard]] std::size_t unitCount() const noexcept;
    [[nodiscard]] std::size_t sideCount() const noexcept;
 
    [[nodiscard]] static Result<TacticsBattleSessionRef> newSession(SubjectRef subject, std::uint64_t seed = 0);
    [[nodiscard]] static script::Borrowed<TacticsBattleSession> resolve(TacticsBattleSessionRef reference) noexcept;
    [[nodiscard]] static Result<void> release(TacticsBattleSessionRef reference);
    [[nodiscard]] static bool isStale(TacticsBattleSessionRef reference) noexcept;
 
private:
    [[nodiscard]] Battle* resolveBattle(ecs::EntityHandle handle) const noexcept;
    [[nodiscard]] Battle* resolveBattle(SubjectRef subject) const noexcept;
    [[nodiscard]] TacticalUnit* findUnit(SubjectRef subject) const noexcept;
    [[nodiscard]] bool owns(const std::vector<ecs::EntityHandle>& handles,
                            const ecs::EntityHandle&              handle) const noexcept;
 
    std::vector<ecs::EntityHandle> battles_;
    std::vector<ecs::EntityHandle> units_;
    std::vector<ecs::EntityHandle> sides_;
    script::RuntimeObjectRegistry<TacticsBattleSession, TacticsBattleSessionTag> sessions_;
};
 
}  // namespace eve::tactics