TacticsTypes.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "common/ECS.h"
#include "common/Identity.h"
#include "common/Result.h"
#include "common/Revision.h"
#include "common/SubjectRef.h"
#include "common/Time.h"
 
#include <compare>
#include <cstdint>
#include <map>
#include <optional>
#include <string>
#include <string_view>
#include <tuple>
#include <utility>
#include <vector>
 
namespace eve::tactics {
 
struct Cell {
    int x     = 0;
    int y     = 0;
    int layer = 0;
 
    friend bool operator==(const Cell&, const Cell&) noexcept = default;
    friend auto operator<=>(const Cell& left, const Cell& right) noexcept {
        return std::tie(left.y, left.x, left.layer) <=> std::tie(right.y, right.x, right.layer);
    }
};
 
enum class BoardTopology : std::uint8_t { Square4, Square8, HexAxial, ExplicitGraph };
 
enum class BattleStatus : std::uint8_t { Setup, Running, Ended };
 
enum class BattlePhase : std::uint8_t {
    Setup,
    BattleStart,
    RoundStart,
    TurnStart,
    Acting,
    Reaction,
    TurnEnd,
    RoundEnd,
    BattleEnd,
};
 
inline constexpr std::string_view kSideAlternatingPolicyId = "side_alternating";
inline constexpr std::string_view kInitiativePolicyId = "initiative";
inline constexpr std::string_view kChargeTimeBattlePolicyId = "charge_time_battle";
inline constexpr int kChargeTimeBattleThreshold = 100;
 
struct TurnPolicyKind {
    static constexpr std::string_view SideAlternating = kSideAlternatingPolicyId;
    static constexpr std::string_view Initiative      = kInitiativePolicyId;
    static constexpr std::string_view ChargeTimeBattle = kChargeTimeBattlePolicyId;
};
 
struct CellState {
    int                      moveCost = 100;
    int                      height   = 0;
    bool                     passable = true;
    std::vector<std::string> tags;
};
 
struct EdgeState {
    bool                     passable  = true;
    int                      extraCost = 0;
    std::vector<std::string> tags;
};
 
struct BoardCellRecord {
    Cell                      cell;
    CellState                 state;
    std::optional<SubjectRef> occupant;
};
 
struct BoardEdgeRecord {
    Cell      from;
    Cell      to;
    EdgeState state;
};
 
struct TurnResourceSpec {
    int actionPoints   = 0;
    int movePoints     = 0;
    int reactionPoints = 0;
    int initiative     = 0;
 
    [[nodiscard]] Result<void> validate() const;
};
 
class EVENGINE_API_DOMAINS BoardState {
public:
    BoardState() = default;
 
    [[nodiscard]] BoardTopology topology() const noexcept { return topology_; }
    void setTopology(BoardTopology topology) noexcept { topology_ = topology; }
 
    [[nodiscard]] Result<void> addCell(Cell cell, CellState state = {});
    [[nodiscard]] bool contains(Cell cell) const noexcept;
    [[nodiscard]] Result<CellState> cell(Cell cell) const;
 
    [[nodiscard]] Result<void> place(SubjectRef subject, Cell cell);
    [[nodiscard]] Result<void> move(SubjectRef subject, Cell destination);
    [[nodiscard]] Result<void> remove(SubjectRef subject);
 
    [[nodiscard]] std::optional<SubjectRef> occupant(Cell cell) const;
    [[nodiscard]] std::optional<Cell> position(SubjectRef subject) const;
    [[nodiscard]] std::vector<Cell> cells() const;
    [[nodiscard]] std::vector<BoardCellRecord> records() const;
    [[nodiscard]] std::vector<Cell> neighbours(Cell origin) const;
 
    [[nodiscard]] Result<void> addEdge(Cell from, Cell to, EdgeState state = {});
    [[nodiscard]] Result<EdgeState> edge(Cell from, Cell to) const;
    [[nodiscard]] std::optional<EdgeState> tryEdge(Cell from, Cell to) const;
    [[nodiscard]] std::vector<BoardEdgeRecord> edgeRecords() const;
    [[nodiscard]] Result<void> validateInvariants() const;
 
private:
    [[nodiscard]] static std::string subjectKey(SubjectRef subject);
 
    BoardTopology                    topology_ = BoardTopology::Square4;
    std::map<Cell, CellState>        cells_;
    std::map<Cell, SubjectRef>       occupantByCell_;
    std::map<std::string, Cell>      cellBySubject_;
    std::map<std::pair<Cell, Cell>, EdgeState> edges_;
};
 
class TacticalSide : public ecs::Entity {
public:
    ENTITY(TacticalSide, ecs::Entity)
 
    
    void release() override { ecs::DestroyEntity(this); }
 
    struct Identity {
        ecs::EntityHandle self{};
        SubjectRef        subject;
        std::string       displayName;
    };
 
    COMPONENT(Identity, identity)
};
 
class TacticalUnit : public ecs::Entity {
public:
    ENTITY(TacticalUnit, ecs::Entity)
 
    
    void release() override { ecs::DestroyEntity(this); }
 
    struct Identity {
        ecs::EntityHandle self{};
        SubjectRef        subject;
        LogicalId         definition;
    };
    struct Membership {
        ecs::EntityHandle battle{};
        ecs::EntityHandle side{};
    };
    struct Position {
        Cell cell;
        int  facing = 0;
        bool placed = false;
    };
    struct TurnResources {
        int  actionPoints         = 0;
        int  movePoints           = 0;
        int  reactionPoints       = 0;
        int  roundActionPoints    = 0;
        int  roundMovePoints      = 0;
        int  roundReactionPoints  = 0;
        int  initiative           = 0;
        int  charge               = 0;
        bool alive                = true;
        bool acted                = false;
    };
 
    COMPONENT(Identity, identity)
    COMPONENT(Membership, membership)
    COMPONENT(Position, position)
    COMPONENT(TurnResources, turn)
};
 
struct BattleEvent {
    std::uint64_t sequence = 0;
    std::uint64_t causationCommand = 0;
    std::uint64_t correlationCommand = 0;
    BattlePhase  from     = BattlePhase::Setup;
    BattlePhase  to       = BattlePhase::Setup;
    SimulationTick tick   = SimulationTick::zero();
    std::string   type;
    SubjectRef    subject;
};
 
struct ReactionCandidate {
    SubjectRef reactor;
    LogicalId  action;
    int        priority   = 0;
    int        initiative = 0;
};
 
struct ReactionWindow {
    std::uint64_t                  triggerSequence = 0;
    std::size_t                    depth           = 0;
    std::vector<ReactionCandidate> candidates;
};
 
struct ReactionReceipt {
    std::uint64_t triggerSequence        = 0;
    SubjectRef   reactor;
    LogicalId    action;
    int          remainingReactionPoints = 0;
};
 
inline constexpr std::size_t kMaxAbilityPayloadBytes = 4096;
 
enum class BattleCommandKind : std::uint8_t {
    Start,
    Advance,
    Move,
    Face,
    Wait,
    EndTurn,
    Finish,
    OpenReaction,
    AcceptReaction,
    DeclineReaction,
    DefeatUnit,
    RollRandom,
    UseAbility,
};
 
struct BattleCommand {
    std::uint64_t                 sequence = 0;
    BattleCommandKind             kind = BattleCommandKind::Advance;
    Revision                      expectedRevision;
    Revision                      resultingRevision;
    SimulationStep                step;
    SubjectRef                    actor;
    Cell                          cell;
    SubjectRef                    targetUnit;
    std::string                   payload;
    int                           facing = 0;
    std::string                   policyId{kSideAlternatingPolicyId};
    std::uint64_t                 triggerSequence = 0;
    LogicalId                     action;
    std::vector<ReactionCandidate> candidates;
};
 
enum class ObjectiveKind : std::uint8_t { EliminateSide, SurviveRounds, OccupyCells };
 
enum class ObjectiveStatus : std::uint8_t { Pending, Completed };
 
struct ObjectiveSpec {
    LogicalId         id;
    ObjectiveKind     kind = ObjectiveKind::EliminateSide;
    SubjectRef        beneficiarySide;
    SubjectRef        targetSide;
    std::uint64_t     requiredRound = 0;
    std::vector<Cell> requiredCells;
    bool              endsBattle = true;
};
 
struct ObjectiveState {
    ObjectiveSpec   spec;
    ObjectiveStatus status = ObjectiveStatus::Pending;
    Revision        completedRevision;
};
 
class Battle : public ecs::Entity {
public:
    ENTITY(Battle, ecs::Entity)
 
    
    void release() override { ecs::DestroyEntity(this); }
 
    struct Identity {
        ecs::EntityHandle self{};
        SubjectRef        subject;
        std::uint64_t     seed = 0;
    };
    struct Board {
        BoardState value;
    };
    struct TurnState {
        Revision                     revision;
        BattleStatus                 status = BattleStatus::Setup;
        BattlePhase                  phase  = BattlePhase::Setup;
        std::string                  policyId{kSideAlternatingPolicyId};
        SimulationTick               tick   = SimulationTick::zero();
        std::uint64_t                round  = 0;
        std::size_t                  cursor = 0;
        std::optional<ecs::EntityHandle> activeSide;
        std::optional<ecs::EntityHandle> activeUnit;
        std::vector<ecs::EntityHandle>   sides;
        std::vector<ecs::EntityHandle>   units;
        std::vector<ecs::EntityHandle>   schedule;
    };
    struct Events {
        std::uint64_t            nextSequence = 1;
        std::vector<BattleEvent> values;
    };
    struct Reactions {
        std::size_t                 maxDepth = 8;
        std::vector<ReactionWindow> stack;
        std::vector<std::string>    seen;
    };
    struct Commands {
        std::uint64_t              nextSequence = 1;
        std::vector<BattleCommand> values;
    };
    struct Objectives {
        std::vector<ObjectiveState> values;
    };
    struct RandomStreamState {
        std::uint64_t state = 0;
        std::uint64_t rollIndex = 0;
    };
    struct Random {
        std::map<std::string, RandomStreamState> streams;
    };
 
    COMPONENT(Identity, identity)
    COMPONENT(Board, board)
    COMPONENT(TurnState, turn)
    COMPONENT(Events, events)
    COMPONENT(Reactions, reactions)
    COMPONENT(Commands, commands)
    COMPONENT(Objectives, objectives)
    COMPONENT(Random, random)
};
 
[[nodiscard]] std::string_view phaseName(BattlePhase phase) noexcept;
[[nodiscard]] std::string_view statusName(BattleStatus status) noexcept;
[[nodiscard]] std::string_view commandKindName(BattleCommandKind kind) noexcept;
 
}  // namespace eve::tactics