HexSearch.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "common/Result.h"
#include "hexmap/HexMap.h"
 
#include <cstdint>
#include <functional>
#include <vector>
 
namespace eve::hexmap {
 
struct HexSearchData {
    std::int32_t distance = 0;
    std::int32_t pathFrom = -1;
    std::int32_t heuristic = 0;
    std::int32_t searchPhase = 0;
    std::int32_t nextWithSamePriority = -1;
 
    [[nodiscard]] std::int32_t priority() const noexcept { return distance + heuristic; }
};
 
enum class HexSearchPop : std::int32_t {
    Cell = 0,
    Empty = 1,
};
 
class EVENGINE_API_WORLD HexSearchContext {
public:
    HexSearchContext() = default;
 
    void resize(std::int32_t cellCount);
 
    [[nodiscard]] std::int32_t cellCount() const noexcept { return static_cast<std::int32_t>(data_.size()); }
 
    [[nodiscard]] HexSearchData& data(std::int32_t cellIndex) noexcept;
    [[nodiscard]] const HexSearchData& data(std::int32_t cellIndex) const noexcept;
 
    [[nodiscard]] std::int32_t beginPhase() noexcept;
 
    [[nodiscard]] std::int32_t phase() const noexcept { return phase_; }
 
    void enqueue(std::int32_t cellIndex) noexcept;
 
    [[nodiscard]] HexSearchPop dequeue(std::int32_t& outCellIndex) noexcept;
 
    void change(std::int32_t cellIndex, std::int32_t oldPriority) noexcept;
 
private:
    void unlink(std::int32_t cellIndex, std::int32_t bucket) noexcept;
 
    std::vector<HexSearchData> data_;
    std::vector<std::int32_t>  buckets_;
    std::int32_t               minimum_ = 0;
    std::int32_t               phase_   = 0;
    HexSearchData              sink_{};
};
 
struct HexMoveRules {
    std::int32_t speed = 24;
    std::int32_t visionRange = 3;
};
 
using HexOccupancyQuery = std::function<bool(HexCoordinates)>;
 
[[nodiscard]] EVENGINE_API_WORLD bool isValidDestination(const HexMap& map, HexCoordinates coordinates,
                                                         const HexOccupancyQuery& occupied = {});
 
[[nodiscard]] EVENGINE_API_WORLD std::int32_t moveCost(const HexMap& map, HexCoordinates from, HexCoordinates to,
                                                       HexDirection direction, const HexOccupancyQuery& occupied = {});
 
struct HexPath {
    std::vector<std::int32_t> cells;
    std::vector<std::int32_t> turns;
 
    [[nodiscard]] bool empty() const noexcept { return cells.empty(); }
    [[nodiscard]] std::size_t size() const noexcept { return cells.size(); }
};
 
[[nodiscard]] EVENGINE_API_WORLD Result<HexPath> findPath(const HexMap& map, HexSearchContext& scratch,
                                                          HexCoordinates from, HexCoordinates to,
                                                          const HexMoveRules&      rules,
                                                          const HexOccupancyQuery& occupied = {});
 
[[nodiscard]] Result<void> collectVisibleCells(const HexMap& map, HexSearchContext& scratch, HexCoordinates from,
                                               std::int32_t range, std::vector<std::int32_t>& out);
 
}  // namespace eve::hexmap