VehicleTypes.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "attributes/AttributeProjection.h"
#include "common/ECS.h"
#include "common/Revision.h"
#include "common/definitions/DefinitionRuntime.h"
 
#include <cstdint>
#include <memory>
#include <ostream>
#include <string>
#include <vector>
 
// 只持有指针，不需要完整类型；physics 开启时才包含对应头文件。
namespace eve::physics {
class Body;
class Body3D;
}  // namespace eve::physics
 
namespace eve::weapon {
class WeaponMountEntity;
}  // namespace eve::weapon
 
namespace eve::vehicle {
 
class VehicleOrderQueueAdapter;
class VehiclePhysicsBinding;
 
enum class VehicleOrderType : uint8_t { Move, AttackMove, Attack, Stop, Hold };
 
EVENGINE_API_DOMAINS const char* vehicleOrderTypeName(VehicleOrderType type);
 
inline std::ostream& operator<<(std::ostream& stream, VehicleOrderType type) {
    return stream << vehicleOrderTypeName(type);
}
 
struct VehicleOrder {
    VehicleOrderType type         = VehicleOrderType::Move;
    float            x            = 0.f;
    float            y            = 0.f;
    int              targetId     = 0;
    float            arriveRadius = 12.f;
};
 
struct VehicleInput {
    float throttle  = 0.f;  // -1..1
    float steer     = 0.f;  // -1..1
    float brake     = 0.f;  // 0..1
    bool  handbrake = false;
    bool  fire      = false;  // 武器座开火请求
    float aimYaw    = 0.f;    // 武器座瞄准（度）
    float aimPitch  = 0.f;
};
 
struct ArmorZone {
    std::string name;
    float       mult = 1.f;
    std::string node;
};
 
struct MountDef {
    std::string name;
    std::string weapon;  // weapon 模板 id
    std::string type      = "turret";
    float       yawMin    = -180.f;
    float       yawMax    = 180.f;
    float       pitchMin  = -45.f;
    float       pitchMax  = 45.f;
    float       rotSpeed  = 0.f;
    float       firingArc = 0.f;
    std::string aimMode   = "auto";  // "auto" | "manual"
};
 
struct SuspensionWheel {
    float x          = 0.f;
    float y          = 0.f;
    float z          = 0.f;
    float radius     = 0.3f;
    float restLength = 0.4f;  // 悬架静止长度
    float stiffness  = 60.f;  // 弹簧刚度
    float damping    = 8.f;   // 阻尼
    bool  drive      = true;
    bool  steer      = true;
};
 
struct SuspensionConfig {
    float maxTravel = 0.3f;
    float driveForce = 2000.f;
    float                        lateralGrip = 12.f;
    std::vector<SuspensionWheel> wheels;
};
 
struct SeatDef {
    std::string name       = "passenger";
    std::string driver     = "player";  // IVehicleDriver 注册名
    std::string cameraMode = "third";   // "first" | "third" | "orbit"
    int         mountIndex = -1;        // 该座位控制的挂点下标（-1 = 无武器）
};
 
struct VehicleDefinition {
    std::string id;
    std::string category = "vehicle";
    std::string              mobility  = "kinematic";
    float                    maxSpeed  = 120.f;  // 像素/秒
    float                    accel     = 80.f;   // 像素/秒²
    float                    turnRate  = 90.f;   // 度/秒
    float                    radius    = 16.f;   // 选择/碰撞半径
    float                    maxHealth = 100.f;
    std::vector<ArmorZone>   armorZones;
    std::vector<MountDef>    mounts;
    SuspensionConfig         suspension;
    std::vector<SeatDef>     seats;
    std::vector<std::string> tags;
};
 
enum class VehicleEventType : uint8_t { OrderCompleted, Damaged, Destroyed };
 
const char* vehicleEventTypeName(VehicleEventType type);
 
struct VehicleEvent {
    VehicleEventType type = VehicleEventType::OrderCompleted;
    std::string      vehicleId;
    std::string      defId;
    std::string      orderType;
    float            x = 0.f;
    float            y = 0.f;
};
 
class EVENGINE_API_DOMAINS VehicleEntity : public ecs::Entity {
public:
    ENTITY(VehicleEntity, ecs::Entity)
 
    
    void release() override { ecs::DestroyEntity(this); }
 
    struct Identity {
        std::string id;
        std::string defId;
        std::string faction;
    };
 
    struct Definition {
        const VehicleDefinition* def = nullptr;
        std::shared_ptr<const VehicleDefinition> owned;
    };
 
    struct DefinitionBinding {
        eve::definition::InstanceIdentity identity;
        eve::definition::ReloadPolicy     reloadPolicy = eve::definition::ReloadPolicy::RebuildInstance;
        bool                              active       = true;
    };
 
    struct Input {
        float throttle  = 0.f;
        float steer     = 0.f;
        float brake     = 0.f;
        bool  handbrake = false;
        bool  fire      = false;
        float aimYaw    = 0.f;
        float aimPitch  = 0.f;
    };
 
    struct Motion {
        float x       = 0.f;
        float y       = 0.f;
        float heading = 0.f;  // 度，0 = +X
        float speed   = 0.f;  // 像素/秒
        bool  arrived = false;
    };
 
    struct Health {
        float hp    = 0.f;
        float maxHp = 0.f;
    };
 
    struct Attributes {
        eve::attributes::AttributeProjection values;
    };
 
    struct EVENGINE_API_DOMAINS Orders {
        std::vector<VehicleOrder> queue;
        int                       current = -1;
 
        std::unique_ptr<VehicleOrderQueueAdapter> adapter;
 
        Orders();
        ~Orders();
        Orders(const Orders& other);
        Orders& operator=(const Orders& other);
        Orders(Orders&&) noexcept;
        Orders& operator=(Orders&&) noexcept;
    };
 
    struct MountSlot {
        eve::weapon::WeaponMountEntity* mount   = nullptr;
        std::string                     aimMode = "auto";  // "auto" | "manual"
    };
 
    struct Mounts {
        std::vector<MountSlot> list;
    };
 
    struct PhysicsBody {
        std::shared_ptr<VehiclePhysicsBinding> binding;
        std::string                            space;  // "2d" | "3d" | ""
    };
 
    struct SuspensionState {
        struct WheelState {
            float prevCompression = 0.f;
            bool  grounded        = false;
        };
        std::vector<WheelState> wheels;
    };
 
    struct SeatSlot {
        std::string name;
        std::string driver     = "player";
        std::string cameraMode = "third";
        int         mountIndex = -1;
        int         occupant   = 0;  // 玩家/实体 id，0 = 空
        bool        occupied   = false;
    };
 
    struct Seats {
        std::vector<SeatSlot> list;
        eve::Revision revision = eve::Revision::zero();
    };
 
    struct Flags {
        bool destroyed = false;
    };
 
    COMPONENT(Identity, identity)
    COMPONENT(Definition, definition)
    COMPONENT(DefinitionBinding, definitionBinding)
    COMPONENT(Input, input)
    COMPONENT(Motion, motion)
    COMPONENT(Health, health)
    COMPONENT(Attributes, attributes)
    COMPONENT(Orders, orders)
    COMPONENT(Mounts, mounts)
    COMPONENT(PhysicsBody, physicsBody)
    COMPONENT(SuspensionState, suspension)
    COMPONENT(Seats, seats)
    COMPONENT(Flags, stateFlags)
 
    
    static VehicleEntity* createVehicle();
};
 
class IVehicleDamageModifier {
public:
    static constexpr const char* capabilityName = "IVehicleDamageModifier";
 
    virtual ~IVehicleDamageModifier() = default;
 
    virtual float modifyDamage(VehicleEntity& v, float amount, const std::string& zone, int sourceId) = 0;
};
 
}  // namespace eve::vehicle