Battle.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "common/Result.h"
#include "common/SubjectRef.h"
#include "settlement/Settlement.h"
#include "settlement/SettlementRules.h"
 
#include <string>
#include <vector>
 
namespace eve::rpg {
 
class RPGActor;
class BattleTacticsCatalogue;
struct StatusTickEvent;
 
namespace BattleSide {
inline constexpr int Party   = 0;
inline constexpr int Enemies = 1;
}  // namespace BattleSide
 
enum class BattleTargetPolicy { Auto, Self, LowestHealthAlly, LowestHealthEnemy };
 
struct BattleEvent {
    std::string     action;
    std::string     skillId;
    class RPGActor* caster = nullptr;
    class RPGActor* target = nullptr;
    double          amount = 0.0;
    bool            crit   = false;
};
 
class EVENGINE_API_PLATFORM Battle {
public:
    Battle()  = default;
    ~Battle() = default;
 
    Battle(const Battle&)            = delete;
    Battle& operator=(const Battle&) = delete;
 
    void addActor(RPGActor* actor, int side);
    [[nodiscard]] eve::Result<void> configureSettlementRules(const settlement::SettlementRuleSet& rules);
    [[nodiscard]] eve::Result<std::vector<settlement::SettlementBatchItemResult>> settleStatusTick(
        const StatusTickEvent& tick, SubjectRef source, SimulationTick simulationTick);
    void setAction(RPGActor* actor, const std::string& skillId, RPGActor* target = nullptr);
    [[nodiscard]] eve::Result<void> setActionChecked(RPGActor* actor, const std::string& skillId,
                                                     RPGActor* target = nullptr);
    [[nodiscard]] eve::Result<void> setActionByPolicyChecked(RPGActor* actor, const std::string& skillId,
                                                             BattleTargetPolicy policy);
    void autoEnemyActions();
    void startRound();
    bool executeNextAction();
    bool isFinished() const;
    bool isVictory() const;
    bool isDefeat() const;
    void setPlayerSide(int side);
    int  getPlayerSide() const;
    int getWinnerSide() const;
    int  getTurn() const;
    bool isActorAlive(RPGActor* actor) const;
 
    int getActorCount() const;
    RPGActor* getActor(int index) const;
    int       getSide(int index) const;
 
    int         getEventCount() const;
    BattleEvent getEvent(int index) const;
    void        pollEvents();
    // 事件字段访问（脚本向）
    std::string getEventAction(int index) const;
    std::string getEventSkillId(int index) const;
    RPGActor* getEventCaster(int index) const;
    RPGActor* getEventTarget(int index) const;
    double    getEventAmount(int index) const;
    bool      getEventCrit(int index) const;
 
private:
    struct Participant {
        RPGActor*  actor = nullptr;
        int        side  = 0;
        SubjectRef settlementSubject;
    };
    struct PendingAction {
        RPGActor*   actor = nullptr;
        std::string skillId;
        RPGActor*   target     = nullptr;
        double      initiative = 0.0;
    };
 
    bool                   isDead(const Participant& p) const;
    std::vector<RPGActor*> livingOnSide(int side) const;
    int                    sideOf(RPGActor* actor) const;
    SubjectRef             settlementSubjectOf(RPGActor* actor) const noexcept;
    RPGActor* randomOpponent(int mySide);
    RPGActor* lowestHealthTarget(int side, bool sameSide) const;
    int       computeWinnerSide() const;
    [[nodiscard]] eve::Result<std::vector<settlement::SettlementBatchItemResult>> settleRequest(
        const settlement::SettlementRequest& request);
    void      execute(PendingAction& pa, unsigned& seedCounter);
 
    std::vector<Participant>       participants_;
    std::vector<PendingAction>     queue_;
    std::vector<PendingAction>     roundActions_;
    std::vector<BattleEvent>       events_;
    std::vector<BattleEvent>       polled_;
    int                            turn_                  = 0;
    bool                           started_               = false;
    bool                           finished_              = false;
    int                            winner_                = -1;
    int                            playerSide_            = BattleSide::Party;
    unsigned                       seedCounter_           = 1;
    std::uint64_t                  nextSettlementSubject_ = 1;
    settlement::SettlementPipeline settlement_;
    friend class BattleTacticsCatalogue;
};
 
}  // namespace eve::rpg