WeaponTypes.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "attributes/AttributeProjection.h"
#include "common/ECS.h"
#include "common/definitions/DefinitionRuntime.h"
 
#include <cstdint>
#include <memory>
#include <string>
#include <vector>
 
namespace eve::weapon {
 
enum class WeaponKind : uint8_t { Melee, Ranged, Magic, Missile, Custom };
 
EVENGINE_API_WORLD const char* weaponKindName(WeaponKind kind);
 
EVENGINE_API_WORLD WeaponKind weaponKindFromName(const std::string& name);
 
enum class ResourceKind : uint8_t { None, Ammo, Mana, Charges, Stamina };
 
struct AttackResource {
    ResourceKind kind    = ResourceKind::None;
    float        max     = 0.f;
    float        regen   = 0.f;  // >0 时每秒回复（法力 / 充能）
    float        cost    = 0.f;  // 每次触发消耗
    bool         infinite = false;  // 无消耗（近战默认）
};
 
enum class AttackStage : uint8_t { Idle, Windup, Active, Recover };
 
const char* attackStageName(AttackStage stage);
 
struct AttackStageSpec {
    float windupTime  = 0.f;  // 前摇（挥剑起手 / 施法抬手 / 导弹锁定）
    float activeTime  = 0.f;  // 生效期（命中帧 / 引导节拍 / 发射时刻）
    float recoverTime = 0.f;  // 后摇（收刀 / 施法硬直 / 再装填窗口）
};
 
enum class FireMode : uint8_t { Single, Burst, Auto };
 
const char* fireModeName(FireMode mode);
 
FireMode fireModeFromName(const std::string& name);
 
enum class WeaponEventType : uint8_t {
    Fire,
    ReloadStart,
    ReloadEnd,
    Empty,
    WindupStart,
    AttackEnd,
    AimIn,
    AimOut
};
 
const char* weaponEventTypeName(WeaponEventType type);
 
struct ProjectileSpec {
    std::string type    = "shell";
    float       speed   = 0.f;
    float       gravity = 0.f;
    float       aoe     = 0.f;
    int   pelletCount   = 1;
    float pelletSpread  = 0.f;
};
 
struct WeaponDefinition {
    std::string id;
    WeaponKind kind = WeaponKind::Ranged;
    std::string logic = "projectile";
    float       damage = 0.f;
    float       penetration = 0.f;
    float       range  = 0.f;
    float falloffStart = 0.f;
    float minimumDamageFactor = 1.f;
    float splashMinimumDamageFactor = 0.1f;
    float accuracy = 1.0f;
    float scatterRadius = 0.0f;
    float    spread   = 0.f;
    float spreadMin     = 0.f;  // 静止散布（度）
    float spreadMax     = 0.f;  // 连射上限散布（度）
    float spreadPerShot = 0.f;  // 每发增量（度）
    float spreadRecover = 0.f;  // 每秒回稳速度（度/秒）
    float recoilPitch = 0.f;    // 每发上抬（度）
    float recoilYaw   = 0.f;    // 每发水平（度）
    float recoilRecover = 0.f;  // 每秒回正速度（度/秒）
    std::string damageType;
    std::string element;
    bool targetsGround = true;
    bool targetsAir = true;
    bool friendlyFire = false;
    bool blockedByObstacles = false;
    std::vector<std::string> requiredTargetTags;
    std::vector<std::string> excludedTargetTags;
    std::vector<std::string> preferredTargetTags;
    float preferredTargetBonus = 1.0f;
    std::vector<FireMode> selectableModes;  // 空 = 固定 fireMode
    float zoomFov = 0.f;
    FireMode fireMode = FireMode::Single;
    float cooldown = 0.f;
    int   burstSize     = 1;
    float burstInterval = 0.f;
    AttackResource resource;
    AttackStageSpec stages;
    float arc = 0.f;
    int            magSize     = 1;
    int            reserveSize = 0;
    float          reloadTime  = 0.f;
    ProjectileSpec projectile;
    std::string effectMuzzle;
    std::string effectSound;
};
 
struct AttackRequest {
    float targetX = 0.f;
    float targetY = 0.f;
    float targetZ = 0.f;
    bool  hasTarget = false;
    ecs::EntityHandle targetHandle;
    float muzzleX = 0.f;
    float muzzleY = 0.f;
    float muzzleZ = 0.f;
    float yaw   = 0.f;
    float pitch = 0.f;
    int shooterId = 0;
    float arcAngle = 0.f;
    float aoeRadius = 0.f;
    float spread = 0.f;
    int pelletIndex = 0;
    int pelletCount = 1;
};
 
using FireRequest = AttackRequest;
 
struct WeaponEvent {
    WeaponEventType type = WeaponEventType::Fire;
    std::string     weaponId;
    std::string     defId;
    std::string     mountId;
    int             ammoLeft = 0;
    float x = 0.f;
    float y = 0.f;
    float z = 0.f;
    float arc = 0.f;
    float aoe = 0.f;
    float spread = 0.f;
    float recoilPitch = 0.f;
    float recoilYaw   = 0.f;
    int pellets = 1;
    std::string damageType;
    std::string element;
};
 
struct Resource {
    ResourceKind kind       = ResourceKind::None;
    float        value      = 0.f;  // 当前值（弹匣剩余 / 法力 / 充能 / 体力）
    float        max        = 0.f;
    float        regen      = 0.f;
    float        cost       = 0.f;
    bool         infinite   = false;
    int          reserve    = 0;
    bool         reloading  = false;
    float        reloadProgress = 0.f;
};
 
class EVENGINE_API_WORLD WeaponEntity : public ecs::Entity {
public:
    ENTITY(WeaponEntity, ecs::Entity)
 
    
    void release() override { ecs::DestroyEntity(this); }
 
    struct Identity {
        std::string id;
        std::string defId;
        int         ownerId = 0;
    };
 
    struct Definition {
        const WeaponDefinition* def = nullptr;
        std::shared_ptr<const WeaponDefinition> owned;
    };
 
    struct DefinitionBinding {
        eve::definition::InstanceIdentity identity;
        eve::definition::ReloadPolicy     reloadPolicy = eve::definition::ReloadPolicy::RebuildInstance;
        bool                              active       = true;
    };
 
    struct State {
        Resource  resource;
        float     cooldown = 0.f;  // 热武器额外冷却
        int       burstRemaining = 0;
        float     burstTimer     = 0.f;
        bool      jammed         = false;
        AttackStage stage         = AttackStage::Idle;
        float     stageTimer     = 0.f;
        AttackRequest lastRequest;
        const AttackStageSpec* stages = nullptr;
        float currentSpread = 0.f;
        float recoilPitch = 0.f;
        float recoilYaw   = 0.f;
        FireMode selector = FireMode::Single;
        bool aiming = false;
        class AmmoPoolEntity* ammoPool = nullptr;
    };
 
    struct Attributes {
        eve::attributes::AttributeProjection values;
    };
 
    struct Aim {
        float yaw          = 0.f;
        float pitch        = 0.f;
        float desiredYaw   = 0.f;
        float desiredPitch = 0.f;
        float turnSpeed    = 0.f;
    };
 
    COMPONENT(Identity, identity)
    COMPONENT(Definition, definition)
    COMPONENT(DefinitionBinding, definitionBinding)
    COMPONENT(State, state)
    COMPONENT(Attributes, attributes)
    COMPONENT(Aim, aim)
 
    
    static WeaponEntity* createWeapon();
};
 
class WeaponMountEntity : public ecs::Entity {
public:
    ENTITY(WeaponMountEntity, ecs::Entity)
 
    
    void release() override { ecs::DestroyEntity(this); }
 
    struct Identity {
        std::string id;
        std::string nodePath;
        std::string type = "turret";
    };
 
    struct Limits {
        float yawMin   = -180.f;
        float yawMax   = 180.f;
        float pitchMin = -45.f;
        float pitchMax = 45.f;
        float rotSpeed = 0.f;
        float firingArc = 0.f;
    };
 
    struct State {
        WeaponEntity* weapon    = nullptr;
        float         yaw       = 0.f;
        float         pitch     = 0.f;
        bool          destroyed = false;
    };
 
    COMPONENT(Identity, identity)
    COMPONENT(Limits, limits)
    COMPONENT(State, state)
 
    
    static WeaponMountEntity* createMount();
};
 
class WeaponRigEntity : public ecs::Entity {
public:
    ENTITY(WeaponRigEntity, ecs::Entity)
 
    
    void release() override { ecs::DestroyEntity(this); }
 
    struct Identity {
        std::string id;
        std::string nodePath;
        std::string wield = "right_hand";
    };
 
    struct Held {
        float posX = 0.f;
        float posY = 0.f;
        float posZ = 0.f;
        float rotX = 0.f;
        float rotY = 0.f;
        float rotZ = 0.f;
    };
 
    struct State {
        WeaponEntity* weapon = nullptr;
    };
 
    COMPONENT(Identity, identity)
    COMPONENT(Held, held)
    COMPONENT(State, state)
 
    
    static WeaponRigEntity* createRig();
};
 
class AmmoPoolEntity : public ecs::Entity {
public:
    ENTITY(AmmoPoolEntity, ecs::Entity)
 
    
    void release() override { ecs::DestroyEntity(this); }
 
    struct Identity {
        std::string id;
        std::string ammoType;
    };
 
    struct State {
        int count = 0;
        int max   = -1;
    };
 
    COMPONENT(Identity, identity)
    COMPONENT(State, state)
 
    
    static AmmoPoolEntity* createPool();
};
 
}  // namespace eve::weapon