CombatCarrier.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "common/ECS.h"
#include "common/Identity.h"
#include "common/Result.h"
#include "common/Time.h"
#include "weapon/ProjectileRuntime.h"
 
#include <cstdint>
#include <optional>
#include <string>
#include <vector>
 
namespace eve::weapon {
 
enum class CarrierMotionOpKind : std::uint8_t {
    SteerHoming,       
    SteerAvoidBody,    
    ApplyGravity,      
    Accelerate,        
    CurveSway,         
    CurveHelix,        
    IntegrateLinear    
};
 
enum class CarrierTriggerKind : std::uint8_t {
    OnExpire,     
    OnFuse,       
    OnInterval,   
    OnHit,        
    OnProximity   
};
 
enum class CarrierImpactKind : std::uint8_t {
    EmitHit,    
    Splash,     
    Pierce,     
    Bounce,     
    Release,    
    SpawnChild  
};
 
struct CarrierMotionOp {
    CarrierMotionOpKind kind               = CarrierMotionOpKind::IntegrateLinear;
    double              gravity            = 0.0;
    double              maxTurnRateDegrees = 0.0;
    double              acceleration       = 0.0;
    double avoidLookAhead = 0.0;
    double avoidStrength = 1.0;
    double avoidRadiusPadding = 0.0;
    double curveAmplitude = 0.0;
    double curveFrequencyHz = 0.0;
};
 
struct CarrierTrigger {
    CarrierTriggerKind kind            = CarrierTriggerKind::OnExpire;
    Duration           fuse            = Duration::zero();
    Duration           interval        = Duration::zero();
    double             proximityRadius = 0.0;
};
 
struct CarrierImpact {
    CarrierImpactKind kind          = CarrierImpactKind::Release;
    CarrierTriggerKind on           = CarrierTriggerKind::OnExpire;
    double            damage        = 0.0;
    double            splashRadius  = 0.0;
    int               pierceCount   = 0;   
    int               bounceCount   = 0;   
    double            restitution   = 1.0; 
    LogicalId         childRecipeId;
    std::string       damageType;
    std::string       element;
};
 
struct CarrierRecipe {
    LogicalId                     id;
    Duration                      lifetime = Duration::zero();
    double                        speed    = 0.0;
    std::vector<CarrierMotionOp>  motionOps;
    std::vector<CarrierTrigger>   triggers;
    std::vector<CarrierImpact>    impacts;
 
    [[nodiscard]] Result<void> validate() const;
};
 
struct CarrierHandle {
    std::uint32_t slot       = 0;
    std::uint32_t generation = 0;
 
    friend bool operator==(const CarrierHandle&, const CarrierHandle&) = default;
};
 
struct CarrierSpawnRequest {
    ProjectilePoint                  position;
    ProjectileVector                 direction;
    std::optional<ecs::EntityHandle> target;
    ecs::EntityHandle                source{};
};
 
enum class CarrierVolleyPattern : std::uint8_t {
    Fan, 
    Ring 
};
 
struct CarrierVolleySpec {
    int                  count         = 1;
    CarrierVolleyPattern pattern       = CarrierVolleyPattern::Fan;
    double               spreadDegrees = 0.0; 
};
 
struct CarrierMotion {
    ProjectilePoint  position;
    ProjectileVector velocity;
};
 
struct CarrierState {
    CarrierHandle                    handle;
    LogicalId                        recipeId;
    CarrierMotion                    motion;
    Duration                         age;
    Duration                         lifetime;
    int                              pierceRemaining = 0;
    int                              bounceRemaining = 0;
    std::optional<ecs::EntityHandle> target;
    ecs::EntityHandle                source{};
};
 
struct CarrierEvent {
    CarrierHandle     carrier;
    LogicalId         recipeId;
    CarrierTriggerKind trigger = CarrierTriggerKind::OnExpire;
    CarrierImpactKind impact  = CarrierImpactKind::EmitHit;
    ProjectilePoint   position;
    ProjectileVector  normal{};
    ecs::EntityHandle source{};
    ecs::EntityHandle target{};
    double            damage       = 0.0;
    double            splashRadius = 0.0;
    std::string       damageType;
    std::string       element;
};
 
struct CarrierChildSpawn {
    LogicalId                        recipeId;
    CarrierSpawnRequest              request;
    CarrierHandle                    parent;
};
 
struct CarrierFrame {
    std::vector<CarrierHandle>     advanced;
    std::vector<CarrierHandle>     released;
    std::vector<CarrierEvent>      events;
    std::vector<CarrierChildSpawn> childSpawns;
};
 
struct CarrierSlotSnapshot {
    std::uint32_t                generation = 0;
    std::optional<CarrierState>  state;
};
 
struct CarrierRuntimeSnapshot {
    std::vector<CarrierSlotSnapshot> slots;
};
 
class ICarrierHitProbe {
public:
    virtual ~ICarrierHitProbe() = default;
 
    struct Contact {
        ecs::EntityHandle target{};
        ProjectilePoint   point{};
        ProjectileVector  normal{0.0, 1.0, 0.0};
    };
 
    [[nodiscard]] virtual Result<std::vector<Contact>> query(CarrierHandle handle,
                                                             const CarrierMotion& previous,
                                                             const CarrierMotion& current) const = 0;
};
 
struct CarrierBodyDefenseSample {
    ProjectilePoint  center{};
    double           radius           = 0.0;
    ProjectileVector facing{0.0, 0.0, 1.0};
    double           frontConeDegrees = 180.0;
};
 
class ICarrierBodyDefenseProvider {
public:
    virtual ~ICarrierBodyDefenseProvider() = default;
 
    [[nodiscard]] virtual Result<std::vector<CarrierBodyDefenseSample>> sample(
        CarrierHandle handle, ecs::EntityHandle target, const CarrierMotion& motion) const = 0;
};
 
[[nodiscard]] EVENGINE_API_WORLD Result<CarrierRecipe> carrierRecipeFromProjectile(
    const ProjectileDefinition& definition, double damage = 0.0);
 
class EVENGINE_API_WORLD CombatCarrierRuntime {
public:
    CombatCarrierRuntime();
 
    [[nodiscard]] Result<void> configurePool(std::uint32_t capacity);
 
    [[nodiscard]] Result<void> registerRecipe(const CarrierRecipe& recipe);
 
    [[nodiscard]] std::optional<CarrierRecipe> findRecipe(const LogicalId& id) const;
 
    [[nodiscard]] Result<CarrierHandle> spawn(const LogicalId& recipeId, const CarrierSpawnRequest& request);
 
    [[nodiscard]] Result<CarrierHandle> spawn(const CarrierRecipe& recipe, const CarrierSpawnRequest& request);
 
    [[nodiscard]] Result<std::vector<CarrierHandle>> spawnVolley(const LogicalId&           recipeId,
                                                                 const CarrierSpawnRequest& request,
                                                                 const CarrierVolleySpec&   volley);
    [[nodiscard]] Result<std::vector<CarrierHandle>> spawnVolley(const CarrierRecipe&       recipe,
                                                                 const CarrierSpawnRequest& request,
                                                                 const CarrierVolleySpec&   volley);
 
    [[nodiscard]] Result<CarrierFrame> update(Duration                           delta,
                                              const IProjectileTargetProvider*    targets = nullptr,
                                              const ICarrierHitProbe*            hits    = nullptr,
                                              const ICarrierBodyDefenseProvider* bodies  = nullptr);
 
    [[nodiscard]] Result<void> release(CarrierHandle handle);
 
    [[nodiscard]] std::optional<CarrierState> find(CarrierHandle handle) const;
 
    [[nodiscard]] std::vector<CarrierState> states() const;
 
    [[nodiscard]] CarrierRuntimeSnapshot snapshot() const;
 
    [[nodiscard]] Result<void> restore(const CarrierRuntimeSnapshot& snapshot);
 
    [[nodiscard]] std::size_t activeCount() const noexcept { return activeCount_; }
 
    [[nodiscard]] std::size_t capacity() const noexcept { return slots_.size(); }
 
private:
    struct Slot {
        std::uint32_t               generation = 0;
        std::optional<CarrierState> state;
    };
 
    struct LiveRecipe {
        CarrierRecipe recipe;
        int           initialPierce  = 0;
        int           initialBounce  = 0;
        bool          needsHoming    = false;
        bool          needsHit       = false;
        bool          needsProximity = false;
        bool          needsBodyAvoid = false;
    };
 
    [[nodiscard]] Result<CarrierHandle> spawnPrepared(const LiveRecipe&          live,
                                                      const CarrierSpawnRequest& request);
    [[nodiscard]] static Result<LiveRecipe> prepareRecipe(const CarrierRecipe& recipe);
    [[nodiscard]] static Result<void> validateSpawn(const CarrierRecipe&        recipe,
                                                    const CarrierSpawnRequest&  request);
 
    std::vector<Slot>              slots_;
    std::vector<LiveRecipe>        recipes_;
    std::size_t                    activeCount_ = 0;
};
 
}  // namespace eve::weapon