Navigation.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "common/Result.h"
#include "common/RuntimeHandle.h"
#include "npc_ai/NpcAi.h"
 
#include <array>
#include <cstddef>
#include <cstdint>
#include <map>
#include <memory>
#include <string>
#include <tuple>
#include <vector>
 
namespace eve::npc_ai {
 
struct NavigationTicketTag {};
using NavigationTicket = RuntimeHandle<NavigationTicketTag>;
 
enum class NavigationPhase : std::uint8_t { Pending, Moving, Arrived, Unreachable, Cancelled };
 
struct NavigationRequest {
    AgentHandle           agent;
    std::array<double, 3> start{};
    std::array<double, 3> destination{};
    double                agentRadius      = 0.5;
    double                acceptanceRadius = 0.25;
    std::string           filter;
    std::uint64_t         requestedTick = 0;
};
 
struct NavigationProgress {
    NavigationPhase       phase = NavigationPhase::Pending;
    std::array<double, 3> desiredVelocity{};
    double                remainingDistance = 0.0;
};
 
class INavigationProvider {
public:
    virtual ~INavigationProvider() = default;
    [[nodiscard]] virtual Result<NavigationTicket> begin(const NavigationRequest& request) = 0;
    [[nodiscard]] virtual Result<NavigationProgress> poll(NavigationTicket ticket, std::uint64_t simulationTick) = 0;
    virtual void abandon(NavigationTicket ticket) noexcept = 0;
};
 
class INavigationRequestFactory {
public:
    virtual ~INavigationRequestFactory() = default;
    [[nodiscard]] virtual Result<NavigationRequest> create(const TaskContext& context, const TaskSpec& task) const = 0;
};
 
class EVENGINE_API_PLATFORM NavigationTaskService final : public ITaskService {
public:
    [[nodiscard]] static Result<std::unique_ptr<NavigationTaskService>> create(
        std::unique_ptr<INavigationProvider> provider, std::unique_ptr<INavigationRequestFactory> requestFactory);
    ~NavigationTaskService() override;
 
    NavigationTaskService(const NavigationTaskService&)            = delete;
    NavigationTaskService& operator=(const NavigationTaskService&) = delete;
 
    [[nodiscard]] Result<void> start(const TaskContext& context, const TaskSpec& spec,
                                     std::string& inOutMemoryJson) override;
    [[nodiscard]] Result<TaskStatus> tick(const TaskContext& context, const TaskSpec& spec,
                                          std::string& inOutMemoryJson) override;
    void stop(const TaskContext& context, const TaskSpec& spec, StopReason reason,
              std::string_view memoryJson) noexcept override;
    [[nodiscard]] std::size_t outstandingCount() const noexcept { return active_.size(); }
 
private:
    struct TaskKey {
        AgentHandle agent;
        std::string state;
        std::string task;
        friend bool operator<(const TaskKey& left, const TaskKey& right) noexcept {
            return std::tuple{left.agent, left.state, left.task} < std::tuple{right.agent, right.state, right.task};
        }
    };
 
    NavigationTaskService(std::unique_ptr<INavigationProvider>       provider,
                          std::unique_ptr<INavigationRequestFactory> requestFactory);
    [[nodiscard]] static TaskKey key(const TaskContext& context, const TaskSpec& spec);
 
    std::unique_ptr<INavigationProvider>       provider_;
    std::unique_ptr<INavigationRequestFactory> requestFactory_;
    std::map<TaskKey, NavigationTicket>        active_;
};
 
}  // namespace eve::npc_ai