ClimbingServices.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
#include "climbing/ClimbingInput.h"
#include "common/StrongUint64.h"
 
#include <span>
#include <string>
#include <string_view>
 
namespace eve::climbing {
 
namespace detail {
struct ClimbingServiceSubjectTag {};
struct ClimbingStaminaReservationTag {};
}  // namespace detail
 
using ClimbingServiceSubject = eve::detail::StrongUint64<detail::ClimbingServiceSubjectTag>;
using ClimbingStaminaReservation = eve::detail::StrongUint64<detail::ClimbingStaminaReservationTag>;
 
enum class ClimbingOptionalServiceState : std::uint8_t { Disabled, ProviderAbsent, Applied };
 
class IClimbingStaminaAuthority {
public:
    static constexpr const char* capabilityName = "eve.climbing.stamina-authority.v1";
    virtual ~IClimbingStaminaAuthority() = default;
 
    [[nodiscard]] virtual std::string_view adapterId() const noexcept = 0;
 
    [[nodiscard]] virtual eve::Result<ClimbingStaminaReservation> prepare(
        ClimbingServiceSubject subject, float cost, eve::SimulationTick tick) = 0;
    virtual void commitPrepared(ClimbingStaminaReservation reservation,
                                ClimbingExecutionId executionId) noexcept = 0;
    virtual void cancelPrepared(ClimbingStaminaReservation reservation) noexcept = 0;
};
 
enum class ClimbingConditionDecision : std::uint8_t { Allowed, Denied };
 
class IClimbingConditionAuthority {
public:
    static constexpr const char* capabilityName = "eve.climbing.condition-authority.v1";
    virtual ~IClimbingConditionAuthority() = default;
    [[nodiscard]] virtual eve::Result<ClimbingConditionDecision> evaluate(
        ClimbingServiceSubject subject, std::span<const std::string> requiredTags,
        eve::SimulationTick tick) = 0;
};
 
class IClimbingEventSink {
public:
    static constexpr const char* capabilityName = "eve.climbing.event-sink.v1";
    virtual ~IClimbingEventSink() = default;
    [[nodiscard]] virtual eve::Result<void> publish(ClimbingServiceSubject subject,
                                                     std::span<const ClimbingEvent> events) = 0;
};
 
class IClimbingPoseAdapter {
public:
    static constexpr const char* capabilityName = "eve.climbing.pose-adapter.v1";
    virtual ~IClimbingPoseAdapter() = default;
    [[nodiscard]] virtual eve::Result<void> apply(ClimbingServiceSubject subject,
                                                   const ClimbingAdvance& advance) = 0;
};
 
struct ClimbingServiceStart {
    ClimbingStart                 start;
    ClimbingOptionalServiceState stamina = ClimbingOptionalServiceState::Disabled;
};
 
class EVENGINE_API_DOMAINS ClimbingServiceSelectionSystem {
public:
    [[nodiscard]] static eve::Result<ClimbingServiceStart> tryStart(
        ClimbingRuntime& runtime, physics::World3D& world, const ClimbingPose& pose, ClimbingIntent& intent,
        ClimbingCommand command, eve::SimulationTick tick, eve::SimulationTick lastGroundedTick,
        ClimbingServiceSubject subject);
};
 
[[nodiscard]] EVENGINE_API_DOMAINS eve::Result<ClimbingOptionalServiceState> dispatchClimbingEvents(
    ClimbingServiceSubject subject, std::span<const ClimbingEvent> events);
 
[[nodiscard]] EVENGINE_API_DOMAINS eve::Result<ClimbingOptionalServiceState> applyClimbingPose(
    ClimbingServiceSubject subject, const ClimbingAdvance& advance);
 
}  // namespace eve::climbing