ProjectileRuntime.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "common/ECS.h"
#include "common/Identity.h"
#include "common/Result.h"
#include "common/Time.h"
 
#include <cstdint>
#include <optional>
#include <vector>
 
namespace eve::weapon {
 
enum class ProjectileMode : std::uint8_t { Linear, Ballistic, Homing };
 
struct ProjectilePoint {
    double x = 0.0;
    double y = 0.0;
    double z = 0.0;
 
    friend bool operator==(const ProjectilePoint&, const ProjectilePoint&) = default;
};
 
struct ProjectileVector {
    double x = 0.0;
    double y = 0.0;
    double z = 0.0;
 
    friend bool operator==(const ProjectileVector&, const ProjectileVector&) = default;
};
 
struct ProjectileHandle {
    std::uint32_t slot       = 0;
    std::uint32_t generation = 0;
 
    friend bool operator==(const ProjectileHandle&, const ProjectileHandle&) = default;
};
 
struct ProjectileDefinition {
    LogicalId      id;
    ProjectileMode mode               = ProjectileMode::Linear;
    double         speed              = 0.0;
    double         gravity            = 0.0;
    double         maxTurnRateDegrees = 0.0;
    Duration       lifetime           = Duration::zero();
 
    [[nodiscard]] Result<void> validate() const;
};
 
struct ProjectileSpawnRequest {
    ProjectilePoint                  position;
    ProjectileVector                 direction;
    std::optional<ecs::EntityHandle> target;
};
 
struct ProjectileState {
    ProjectileHandle                 handle;
    LogicalId                        definitionId;
    ProjectileMode                   mode = ProjectileMode::Linear;
    ProjectilePoint                  position;
    ProjectileVector                 velocity;
    double                           gravity            = 0.0;
    double                           maxTurnRateDegrees = 0.0;
    Duration                         age;
    Duration                         lifetime;
    std::optional<ecs::EntityHandle> target;
};
 
struct ProjectileUpdate {
    std::vector<ProjectileHandle> advanced;
    std::vector<ProjectileHandle> released;
};
 
struct ProjectileSlotSnapshot {
    std::uint32_t generation = 0;
    std::optional<ProjectileState> state;
};
 
struct ProjectileRuntimeSnapshot {
    std::vector<ProjectileSlotSnapshot> slots;
};
 
class IProjectileTargetProvider {
public:
    virtual ~IProjectileTargetProvider() = default;
    [[nodiscard]] virtual Result<ProjectilePoint> position(ecs::EntityHandle target) const = 0;
};
 
class EVENGINE_API_WORLD ProjectileRuntime {
public:
    ProjectileRuntime();
 
    [[nodiscard]] Result<void> configurePool(std::uint32_t capacity);
    [[nodiscard]] Result<ProjectileHandle> spawn(const ProjectileDefinition&   definition,
                                                 const ProjectileSpawnRequest& request);
    [[nodiscard]] Result<ProjectileUpdate> update(Duration delta, const IProjectileTargetProvider* targets = nullptr);
    [[nodiscard]] Result<void> release(ProjectileHandle handle);
    [[nodiscard]] std::optional<ProjectileState> find(ProjectileHandle handle) const;
    [[nodiscard]] std::vector<ProjectileState> states() const;
    [[nodiscard]] ProjectileRuntimeSnapshot snapshot() const;
    [[nodiscard]] Result<void> restore(const ProjectileRuntimeSnapshot& 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<ProjectileState> state;
    };
 
    [[nodiscard]] static Result<void> validateSpawn(const ProjectileDefinition&   definition,
                                                    const ProjectileSpawnRequest& request);
 
    std::vector<Slot> slots_;
    std::size_t       activeCount_ = 0;
};
 
}  // namespace eve::weapon