MeleeHit.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
#include "action/Action.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 MeleePoint3 {
    double x = 0.0;
    double y = 0.0;
    double z = 0.0;
};
 
enum class MeleeShapeKind : std::uint8_t { Sphere, Capsule };
 
struct MeleeShape {
    MeleeShapeKind kind      = MeleeShapeKind::Sphere;
    double         radius    = 0.0;
    double         halfHeight = 0.0;
 
    [[nodiscard]] Result<void> validate() const;
};
 
struct MeleePose {
    MeleePoint3 position;
    double      yawRadians = 0.0;
 
    [[nodiscard]] Result<void> validate() const;
};
 
struct MeleeHurtboxDefinition {
    SubjectRef  subject;
    std::string hurtboxId;
    std::string bodyPart;
    MeleeShape  shape;
 
    [[nodiscard]] Result<void> validate() const;
};
 
struct MeleeHitboxDefinition {
    std::string hitboxId;
    MeleeShape  shape;
    MeleePoint3 localOffset;
    double      healthDamage = 0.0;
    double      poiseDamage  = 0.0;
    std::string damageType   = "Damage.Physical.Slash";
    double knockbackSpeed = 0.0;
    double knockbackLift = 0.0;
 
    [[nodiscard]] Result<void> validate() const;
};
 
struct MeleeHitEvent {
    SubjectRef                               source;
    SubjectRef                               target;
    std::string                              hitboxId;
    std::string                              hurtboxId;
    std::string                              bodyPart;
    MeleePoint3                              contact;
    MeleePoint3                              normal;
    double                                   healthDamage = 0.0;
    double                                   poiseDamage  = 0.0;
    std::string                              damageType;
    Impulse3                                 knockback;
    std::optional<action::ActionExecutionId> actionExecution;
};
 
struct MeleeHitFrame {
    SimulationTick            tick = SimulationTick::zero();
    std::vector<MeleeHitEvent> hits;
};
 
class IMeleePoseSource {
public:
    virtual ~IMeleePoseSource() = default;
    [[nodiscard]] virtual Result<MeleePose> pose(SubjectRef subject, std::string_view hitboxId) const = 0;
};
 
class EVENGINE_API_BACKENDS MeleeHitRuntime {
public:
    void setPoseSource(IMeleePoseSource& source) noexcept { poses_ = &source; }
    void clearPoseSource() noexcept { poses_ = nullptr; }
 
    [[nodiscard]] Result<void> registerHitbox(MeleeHitboxDefinition definition);
    [[nodiscard]] Result<void> registerHurtbox(MeleeHurtboxDefinition definition);
    [[nodiscard]] Result<void> clearHurtboxes(SubjectRef subject);
    [[nodiscard]] Result<void> setHurtboxPose(SubjectRef subject, std::string_view hurtboxId, MeleePose pose);
 
    [[nodiscard]] Result<void> armHitbox(SubjectRef subject, std::string_view hitboxId,
                                         action::ActionExecutionId execution);
    [[nodiscard]] Result<void> disarmHitbox(SubjectRef subject, std::string_view hitboxId,
                                            action::ActionExecutionId execution);
 
    [[nodiscard]] Result<MeleeHitFrame> advance(SimulationTick tick);
 
    [[nodiscard]] Result<std::vector<DamageOutcome>> applyHits(
        DamageRuntime& damage, std::map<std::string, CombatState, std::less<>>& states,
        const std::vector<MeleeHitEvent>& hits,
        const std::map<std::string, double, std::less<>>& bodyPartMultipliers = {}) const;
 
    [[nodiscard]] std::size_t armedCount() const noexcept { return armed_.size(); }
    [[nodiscard]] std::size_t hurtboxCount() const noexcept { return hurtboxes_.size(); }
 
private:
    struct HurtboxState {
        MeleeHurtboxDefinition definition;
        MeleePose              pose;
        bool                   hasPose = false;
    };
    struct ArmedHitbox {
        SubjectRef                subject;
        std::string               hitboxId;
        action::ActionExecutionId execution;
        MeleePose                 previous;
        MeleePose                 current;
        bool                      hasPose = false;
    };
    using ArmedKey   = std::tuple<std::string, std::string, std::uint64_t>;
    using HitMemoryKey = std::tuple<std::uint64_t, std::string, std::string, std::string>;
 
    std::map<std::string, MeleeHitboxDefinition, std::less<>> hitboxes_;
    std::map<std::string, HurtboxState, std::less<>>          hurtboxes_;
    std::map<ArmedKey, ArmedHitbox>                           armed_;
    std::map<HitMemoryKey, bool>                              hitMemory_;
    IMeleePoseSource*                                         poses_   = nullptr;
    SimulationTick                                            lastTick_ = SimulationTick::zero();
};
 
}  // namespace eve::combat