CombatLocomotion.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "common/Result.h"
#include "common/SubjectRef.h"
#include "common/Time.h"
 
#include <map>
#include <optional>
#include <string>
#include <vector>
 
namespace eve::combat {
 
struct CombatVector2 {
    double x = 0.0;
    double z = 0.0;
};
 
struct CombatLocomotionDefinition {
    SubjectRef    subject;
    std::string   ownerId;
    CombatVector2 initialPosition;
    double        maximumSpeed = 0.0;
    double        acceleration = 0.0;
 
    [[nodiscard]] Result<void> validate() const;
};
 
struct CombatNavigationGoal {
    CombatVector2 position;
    double        acceptanceRadius = 0.0;
};
 
struct CombatLocomotionState {
    SubjectRef                          subject;
    std::string                         ownerId;
    CombatVector2                       position;
    CombatVector2                       velocity;
    CombatVector2                       facing{1.0, 0.0};
    CombatVector2                       moveDirection;
    double                              moveSpeedFraction = 0.0;
    double                              maximumSpeed = 0.0;
    double                              acceleration = 0.0;
    std::optional<CombatNavigationGoal> navigationGoal;
};
 
enum class CombatNavigationPhase : std::uint8_t { Moving, Arrived };
 
struct CombatNavigationSteering {
    CombatNavigationPhase phase = CombatNavigationPhase::Moving;
    CombatVector2         direction;
    double                speedFraction = 1.0;
};
 
class ICombatNavigationProvider {
public:
    virtual ~ICombatNavigationProvider() = default;
 
    [[nodiscard]] virtual Result<CombatNavigationSteering> steer(const CombatLocomotionState& state,
                                                                  const CombatNavigationGoal& goal,
                                                                  SimulationTick tick) = 0;
};
 
class EVENGINE_API_BACKENDS DirectCombatNavigationProvider final : public ICombatNavigationProvider {
public:
    [[nodiscard]] Result<CombatNavigationSteering> steer(const CombatLocomotionState& state,
                                                          const CombatNavigationGoal& goal,
                                                          SimulationTick tick) override;
};
 
enum class CombatLocomotionEventKind : std::uint8_t { Moved, Arrived };
 
struct CombatLocomotionEvent {
    SubjectRef                   subject;
    CombatLocomotionEventKind    kind = CombatLocomotionEventKind::Moved;
    CombatVector2                previousPosition;
    CombatVector2                position;
    SimulationTick               tick = SimulationTick::zero();
};
 
struct CombatLocomotionAdvance {
    SimulationTick                      tick = SimulationTick::zero();
    std::vector<CombatLocomotionEvent> events;
};
 
class EVENGINE_API_BACKENDS CombatLocomotionRuntime {
public:
    CombatLocomotionRuntime() = default;
    explicit CombatLocomotionRuntime(ICombatNavigationProvider& provider) : navigation_(&provider) {}
 
    void setNavigationProvider(ICombatNavigationProvider& provider) noexcept { navigation_ = &provider; }
    void clearNavigationProvider() noexcept { navigation_ = nullptr; }
    [[nodiscard]] Result<void> registerSubject(CombatLocomotionDefinition definition);
    [[nodiscard]] Result<void> unregisterSubject(SubjectRef subject);
    [[nodiscard]] Result<CombatLocomotionState> state(SubjectRef subject) const;
    [[nodiscard]] Result<void> setMoveIntent(SubjectRef subject, CombatVector2 direction,
                                              double speedFraction);
    [[nodiscard]] Result<void> navigateTo(SubjectRef subject, CombatNavigationGoal goal);
    [[nodiscard]] Result<void> stop(SubjectRef subject);
    [[nodiscard]] Result<CombatLocomotionAdvance> advance(const SimulationStep& step);
    [[nodiscard]] std::vector<CombatLocomotionState> states() const;
 
private:
    std::map<std::string, CombatLocomotionState, std::less<>> states_;
    ICombatNavigationProvider*                               navigation_ = nullptr;
    SimulationTick                                           lastTick_ = SimulationTick::zero();
};
 
}  // namespace eve::combat