CombatCharacter.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
#include "combat/Damage.h"
#include "common/Result.h"
#include "common/SubjectRef.h"
#include "common/Time.h"
 
#include <cstdint>
#include <map>
#include <optional>
#include <string>
#include <vector>
 
namespace eve::combat {
 
struct CombatVector3 {
    double x = 0.0;
    double y = 0.0;
    double z = 0.0;
};
 
enum class CombatCharacterMode : std::uint8_t { Grounded, Airborne, Dodging, Attacking, Stunned, Dead };
 
enum class CombatDodgeRelative : std::uint8_t { Forward, Back, Left, Right };
 
struct CombatCharacterDefinition {
    SubjectRef    subject;
    std::string   ownerId;
    CombatVector3 initialPosition;
    double        maximumSpeed  = 5.0;
    double        acceleration  = 18.0;
    double        jumpSpeed     = 6.0;
    double        gravity       = 20.0;
    double        dodgeSpeed    = 10.0;
    double        dodgeDuration = 0.28;
    std::uint32_t maxAirJumps   = 1;
    double        capsuleRadius = 0.35;
 
    [[nodiscard]] Result<void> validate() const;
};
 
struct CombatCharacterState {
    SubjectRef                   subject;
    std::string                  ownerId;
    CombatVector3                position;
    CombatVector3                velocity;
    CombatVector3                facing{1.0, 0.0, 0.0};
    CombatVector3                moveDirection;
    double                       moveSpeedFraction = 0.0;
    double                       maximumSpeed      = 0.0;
    double                       acceleration      = 0.0;
    double                       jumpSpeed         = 0.0;
    double                       gravity           = 0.0;
    double                       dodgeSpeed        = 0.0;
    double                       dodgeDuration     = 0.0;
    double                       capsuleRadius     = 0.35;
    std::uint32_t                maxAirJumps       = 0;
    std::uint32_t                airJumpsUsed      = 0;
    CombatCharacterMode          mode              = CombatCharacterMode::Grounded;
    double                       modeTimeRemaining = 0.0;
    bool                         invulnerable      = false;
    bool                         timeFrozen        = false;
    std::optional<CombatVector3> rootMotionDelta;
};
 
enum class CombatCharacterEventKind : std::uint8_t { Moved, Jumped, Landed, DodgeStarted, DodgeEnded, ModeChanged };
 
struct CombatCharacterEvent {
    SubjectRef               subject;
    CombatCharacterEventKind kind = CombatCharacterEventKind::Moved;
    CombatCharacterMode      mode = CombatCharacterMode::Grounded;
    CombatVector3            position;
    SimulationTick           tick = SimulationTick::zero();
};
 
struct CombatCharacterAdvance {
    SimulationTick                    tick = SimulationTick::zero();
    std::vector<CombatCharacterEvent> events;
};
 
class ICombatGroundProvider {
public:
    virtual ~ICombatGroundProvider() = default;
    [[nodiscard]] virtual Result<double> sampleHeight(double x, double z) const = 0;
};
 
class ICombatMoveProbe {
public:
    virtual ~ICombatMoveProbe() = default;
    [[nodiscard]] virtual Result<CombatVector3> resolve(const CombatVector3& from, const CombatVector3& to,
                                                        double radius) const = 0;
};
 
class EVENGINE_API_BACKENDS CombatCharacterRuntime {
public:
    [[nodiscard]] Result<void> registerSubject(CombatCharacterDefinition definition);
    [[nodiscard]] Result<void> unregisterSubject(SubjectRef subject);
    [[nodiscard]] Result<CombatCharacterState> state(SubjectRef subject) const;
 
    [[nodiscard]] Result<void> setMoveIntent(SubjectRef subject, CombatVector3 direction, double speedFraction);
    [[nodiscard]] Result<void> jump(SubjectRef subject);
    [[nodiscard]] Result<void> dodge(SubjectRef subject, std::optional<CombatVector3> direction = std::nullopt);
    [[nodiscard]] Result<void> dodgeRelative(SubjectRef subject, CombatVector3 lockTarget,
                                             CombatDodgeRelative relative);
    [[nodiscard]] Result<void> beginAttack(SubjectRef subject);
    [[nodiscard]] Result<void> endAttack(SubjectRef subject);
    [[nodiscard]] Result<void> applyStun(SubjectRef subject, Duration duration);
    [[nodiscard]] Result<void> applyImpulse(SubjectRef subject, CombatVector3 impulse);
    [[nodiscard]] Result<void> applyDamageReaction(SubjectRef subject, HitReaction reaction, Duration stunDuration,
                                                   Impulse3 knockback);
    [[nodiscard]] Result<void> kill(SubjectRef subject);
    [[nodiscard]] Result<void> setRootMotionDelta(SubjectRef subject, CombatVector3 delta);
    [[nodiscard]] Result<void> setFacing(SubjectRef subject, CombatVector3 facing);
    [[nodiscard]] Result<void> setTimeFrozen(SubjectRef subject, bool frozen);
    void setGroundProvider(ICombatGroundProvider& provider) noexcept { ground_ = &provider; }
    void clearGroundProvider() noexcept { ground_ = nullptr; }
    void setMoveProbe(ICombatMoveProbe& probe) noexcept { probe_ = &probe; }
    void clearMoveProbe() noexcept { probe_ = nullptr; }
    [[nodiscard]] Result<CombatCharacterAdvance> advance(const SimulationStep& step);
    [[nodiscard]] std::vector<CombatCharacterState> states() const;
 
private:
    std::map<std::string, CombatCharacterState, std::less<>> states_;
    ICombatGroundProvider*                                   ground_   = nullptr;
    ICombatMoveProbe*                                        probe_    = nullptr;
    SimulationTick                                           lastTick_ = SimulationTick::zero();
};
 
}  // namespace eve::combat