Targeting.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "common/Capability.h"
#include "common/Identity.h"
#include "common/Result.h"
#include "common/SubjectRef.h"
#include "sensing/Sensing.h"
 
#include <cstddef>
#include <cstdint>
#include <functional>
#include <limits>
#include <map>
#include <optional>
#include <ostream>
#include <span>
#include <string>
#include <utility>
#include <variant>
#include <vector>
 
namespace eve::sensing {
 
enum class CoordinateSpace : std::uint8_t {
    World2D,
    World3D,
    Grid2D,
    Grid3D,
};
 
[[nodiscard]] EVENGINE_API_PLATFORM std::string_view coordinateSpaceName(CoordinateSpace space) noexcept;
 
inline std::ostream& operator<<(std::ostream& stream, CoordinateSpace space) {
    return stream << coordinateSpaceName(space);
}
 
enum class TargetDomain : std::uint8_t {
    Any,
    Self,
    Ally,
    Enemy,
    Neutral,
};
 
enum class LineOfSightMode : std::uint8_t {
    NotRequired,
    Required,
};
 
using SubjectRef = ::eve::SubjectRef;
 
class EVENGINE_API_PLATFORM ZoneRef {
public:
    ZoneRef() = default;
 
    [[nodiscard]] static std::optional<ZoneRef> fromLogicalId(LogicalId id);
 
    [[nodiscard]] bool isValid() const noexcept { return id_.isValid(); }
 
    [[nodiscard]] const LogicalId& logicalId() const noexcept { return id_; }
 
    friend bool operator==(const ZoneRef&, const ZoneRef&) noexcept = default;
 
private:
    explicit ZoneRef(LogicalId id) : id_(std::move(id)) {}
 
    LogicalId id_;
};
 
class EVENGINE_API_PLATFORM WorldPoint {
public:
    WorldPoint() = default;
 
    [[nodiscard]] static Result<WorldPoint> world2D(float x, float y);
 
    [[nodiscard]] static Result<WorldPoint> world3D(float x, float y, float z);
 
    [[nodiscard]] CoordinateSpace space() const noexcept { return space_; }
    [[nodiscard]] float x() const noexcept { return x_; }
    [[nodiscard]] float y() const noexcept { return y_; }
    [[nodiscard]] float z() const noexcept { return z_; }
    [[nodiscard]] bool isValid() const noexcept { return valid_; }
 
    friend bool operator==(const WorldPoint&, const WorldPoint&) noexcept = default;
 
private:
    WorldPoint(CoordinateSpace space, float x, float y, float z) noexcept
        : space_(space), x_(x), y_(y), z_(z), valid_(true) {}
 
    CoordinateSpace space_ = CoordinateSpace::World2D;
    float           x_     = 0.f;
    float           y_     = 0.f;
    float           z_     = 0.f;
    bool            valid_ = false;
};
 
class EVENGINE_API_PLATFORM GridPoint {
public:
    GridPoint() = default;
 
    [[nodiscard]] static GridPoint grid2D(std::int32_t x, std::int32_t y) noexcept;
    [[nodiscard]] static GridPoint grid3D(std::int32_t x, std::int32_t y, std::int32_t z) noexcept;
 
    [[nodiscard]] CoordinateSpace space() const noexcept { return space_; }
    [[nodiscard]] std::int32_t x() const noexcept { return x_; }
    [[nodiscard]] std::int32_t y() const noexcept { return y_; }
    [[nodiscard]] std::int32_t z() const noexcept { return z_; }
    [[nodiscard]] bool isValid() const noexcept { return valid_; }
 
    friend bool operator==(const GridPoint&, const GridPoint&) noexcept = default;
 
private:
    GridPoint(CoordinateSpace space, std::int32_t x, std::int32_t y, std::int32_t z) noexcept
        : space_(space), x_(x), y_(y), z_(z), valid_(true) {}
 
    CoordinateSpace space_ = CoordinateSpace::Grid2D;
    std::int32_t    x_     = 0;
    std::int32_t    y_     = 0;
    std::int32_t    z_     = 0;
    bool            valid_ = false;
};
 
using TargetLocation = std::variant<WorldPoint, GridPoint>;
 
class EVENGINE_API_PLATFORM WorldArea {
public:
    enum class Shape : std::uint8_t { Circle2D, Box2D, Sphere3D, Box3D, Cone2D };
 
    WorldArea() = default;
    [[nodiscard]] static Result<WorldArea> circle2D(WorldPoint center, float radius);
    [[nodiscard]] static Result<WorldArea> box2D(WorldPoint minimum, WorldPoint maximum);
    [[nodiscard]] static Result<WorldArea> sphere3D(WorldPoint center, float radius);
    [[nodiscard]] static Result<WorldArea> box3D(WorldPoint minimum, WorldPoint maximum);
    [[nodiscard]] static Result<WorldArea> cone2D(WorldPoint apex, float dirX, float dirY, float halfAngleRadians,
                                                  float range);
 
    [[nodiscard]] Shape shape() const noexcept { return shape_; }
    [[nodiscard]] CoordinateSpace space() const noexcept { return space_; }
    [[nodiscard]] bool isValid() const noexcept { return valid_; }
    [[nodiscard]] WorldPoint first() const noexcept { return first_; }
    [[nodiscard]] WorldPoint second() const noexcept { return second_; }
    [[nodiscard]] float radius() const noexcept { return radius_; }
    [[nodiscard]] bool contains(WorldPoint point) const noexcept;
 
private:
    WorldArea(Shape shape, WorldPoint first, WorldPoint second, float radius, float halfAngle = 0.f) noexcept
        : shape_(shape),
          space_(first.space()),
          first_(first),
          second_(second),
          radius_(radius),
          halfAngle_(halfAngle),
          valid_(true) {}
 
    Shape           shape_     = Shape::Circle2D;
    CoordinateSpace space_     = CoordinateSpace::World2D;
    WorldPoint      first_;
    WorldPoint      second_;
    float           radius_    = 0.f;
    float           halfAngle_ = 0.f;
    bool            valid_     = false;
};
 
class EVENGINE_API_PLATFORM GridArea {
public:
    enum class Shape : std::uint8_t { Box2D, Box3D };
 
    GridArea() = default;
    [[nodiscard]] static Result<GridArea> box2D(GridPoint minimum, GridPoint maximum);
    [[nodiscard]] static Result<GridArea> box3D(GridPoint minimum, GridPoint maximum);
 
    [[nodiscard]] Shape shape() const noexcept { return shape_; }
    [[nodiscard]] CoordinateSpace space() const noexcept { return space_; }
    [[nodiscard]] bool isValid() const noexcept { return valid_; }
    [[nodiscard]] GridPoint minimum() const noexcept { return minimum_; }
    [[nodiscard]] GridPoint maximum() const noexcept { return maximum_; }
    [[nodiscard]] bool contains(GridPoint point) const noexcept;
 
private:
    GridArea(Shape shape, GridPoint minimum, GridPoint maximum) noexcept
        : shape_(shape), space_(minimum.space()), minimum_(minimum), maximum_(maximum), valid_(true) {}
 
    Shape           shape_ = Shape::Box2D;
    CoordinateSpace space_ = CoordinateSpace::Grid2D;
    GridPoint       minimum_;
    GridPoint       maximum_;
    bool            valid_ = false;
};
 
struct TargetingSpec {
    CoordinateSpace space = CoordinateSpace::World2D;
    TargetDomain domain = TargetDomain::Any;
    std::uint32_t minCount = 0;
    std::uint32_t maxCount = std::numeric_limits<std::uint32_t>::max();
    CountPolicy countPolicy = CountPolicy::FailIfOutOfRange;
    float minRange = 0.f;
    float maxRange = std::numeric_limits<float>::infinity();
    std::vector<std::string> requiredTags;
    std::vector<std::string> excludedTags;
    std::optional<ZoneRef> zone;
    std::optional<WorldArea> worldArea;
    std::optional<GridArea> gridArea;
    LineOfSightMode lineOfSight = LineOfSightMode::NotRequired;
 
    [[nodiscard]] Result<void> validate() const;
};
 
struct TargetingQuery {
    SubjectRef origin;
    TargetLocation originLocation;
    TargetingSpec spec;
 
    [[nodiscard]] Result<void> validate() const;
};
 
struct TargetCandidate {
    SubjectRef subject;
    TargetLocation location;
    TargetDomain domain = TargetDomain::Neutral;
    std::vector<std::string> tags;
    std::vector<ZoneRef> zones;
};
 
class EVENGINE_API_PLATFORM TargetSet {
public:
    [[nodiscard]] Result<void> addSubject(SubjectRef subject);
    [[nodiscard]] Result<void> setPrimary(SubjectRef subject);
    [[nodiscard]] Result<void> setPoint(TargetLocation point);
    [[nodiscard]] Result<void> setArea(WorldArea area);
    [[nodiscard]] Result<void> setArea(GridArea area);
 
    [[nodiscard]] std::span<const SubjectRef> subjects() const noexcept { return subjects_; }
    [[nodiscard]] const std::optional<SubjectRef>& primary() const noexcept { return primary_; }
    [[nodiscard]] const std::optional<TargetLocation>& point() const noexcept { return point_; }
    [[nodiscard]] const std::optional<WorldArea>& worldArea() const noexcept { return worldArea_; }
    [[nodiscard]] const std::optional<GridArea>& gridArea() const noexcept { return gridArea_; }
 
private:
    std::vector<SubjectRef>       subjects_;
    std::optional<SubjectRef>     primary_;
    std::optional<TargetLocation> point_;
    std::optional<WorldArea>      worldArea_;
    std::optional<GridArea>       gridArea_;
};
 
struct LineOfSightResult {
    bool visible = false;
    std::optional<SubjectRef> blocker;
};
 
class ILineOfSightQuery {
public:
    static constexpr const char* capabilityName = "eve.sensing.ILineOfSightQuery";
    virtual ~ILineOfSightQuery()                = default;
 
    [[nodiscard]] virtual Result<LineOfSightResult> query(const TargetLocation& from,
                                                          const TargetLocation& to) const = 0;
};
 
class ISensingCandidateProvider {
public:
    static constexpr const char* capabilityName = "eve.sensing.ISensingCandidateProvider";
    virtual ~ISensingCandidateProvider()        = default;
 
    [[nodiscard]] virtual Result<std::vector<TargetCandidate>> query(const TargetingQuery& query) const = 0;
};
 
class EVENGINE_API_PLATFORM SensingCandidateProvider final : public ISensingCandidateProvider {
public:
    SensingCandidateProvider()           = default;
    ~SensingCandidateProvider() override = default;
 
    [[nodiscard]] Result<void> upsert(TargetCandidate candidate);
    [[nodiscard]] Result<void> remove(SubjectRef subject);
    [[nodiscard]] std::size_t size() const noexcept { return candidates_.size(); }
 
    [[nodiscard]] Result<std::vector<TargetCandidate>> query(const TargetingQuery& query) const override;
 
private:
    std::map<std::string, TargetCandidate> candidates_;
};
 
using FactionRelationFn =
    std::function<Result<TargetDomain>(std::string_view originFaction, std::string_view candidateFaction)>;
 
class EVENGINE_API_PLATFORM SensingWorldCandidateProvider final : public ISensingCandidateProvider {
public:
    explicit SensingWorldCandidateProvider(SensingWorld& world) noexcept : world_(&world) {}
    ~SensingWorldCandidateProvider() override = default;
 
    void setFactionRelation(FactionRelationFn relation) { relation_ = std::move(relation); }
 
    [[nodiscard]] Result<std::vector<TargetCandidate>> query(const TargetingQuery& query) const override;
 
private:
    SensingWorld*     world_ = nullptr;
    FactionRelationFn relation_;
};
 
class EVENGINE_API_PLATFORM TargetingResolver {
public:
    [[nodiscard]] Result<TargetSet> resolve(const TargetingQuery& query) const;
};
 
}  // namespace eve::sensing