HexMap.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "common/Result.h"
#include "hexmap/HexCell.h"
#include "hexmap/HexCoordinates.h"
#include "hexmap/HexMetrics.h"
#include "hexmap/HexNoise.h"
 
#include <cstdint>
#include <vector>
 
namespace eve::hexmap {
 
enum class HexSurface : std::int32_t {
    Terrain = 0,
    Water   = 1,
    River   = 2,
    Road    = 3,
    Fog     = 4,
    Wall    = 5,
    Feature = 6,
};
 
inline constexpr std::int32_t kHexSurfaceCount = 7;
 
inline constexpr std::int32_t kMaxHexGridDimension = 512;
 
struct HexSurfaceId {
    std::int32_t chunkIndex = 0;
    HexSurface   surface    = HexSurface::Terrain;
};
 
class EVENGINE_API_WORLD HexMap {
public:
    HexMap() = default;
 
    [[nodiscard]] Result<void> reset(std::int32_t cellCountX, std::int32_t cellCountZ, std::uint32_t seed);
 
    [[nodiscard]] bool empty() const noexcept { return cells_.empty(); }
    [[nodiscard]] std::int32_t cellCountX() const noexcept { return cellCountX_; }
    [[nodiscard]] std::int32_t cellCountZ() const noexcept { return cellCountZ_; }
    [[nodiscard]] std::int32_t chunkCountX() const noexcept { return chunkCountX_; }
    [[nodiscard]] std::int32_t chunkCountZ() const noexcept { return chunkCountZ_; }
    [[nodiscard]] std::int32_t chunkCount() const noexcept { return chunkCountX_ * chunkCountZ_; }
    [[nodiscard]] std::int32_t cellCount() const noexcept { return static_cast<std::int32_t>(cells_.size()); }
    [[nodiscard]] std::uint32_t seed() const noexcept { return noise_.seed(); }
    [[nodiscard]] std::uint64_t revision() const noexcept { return revision_; }
    [[nodiscard]] const HexNoise& noise() const noexcept { return noise_; }
 
    // --- topology -----------------------------------------------------------
 
    [[nodiscard]] bool contains(HexCoordinates coordinates) const noexcept {
        const std::int32_t column = coordinates.offsetX();
        return column >= 0 && column < cellCountX_ && coordinates.z >= 0 && coordinates.z < cellCountZ_;
    }
    [[nodiscard]] std::int32_t indexOf(HexCoordinates coordinates) const noexcept;
    [[nodiscard]] HexCoordinates coordinatesAt(std::int32_t index) const noexcept;
    [[nodiscard]] const HexCellData* cell(HexCoordinates coordinates) const noexcept;
    [[nodiscard]] const HexCellData* cellAt(std::int32_t index) const noexcept;
 
    [[nodiscard]] bool getNeighbor(HexCoordinates coordinates, HexDirection direction,
                                   HexCoordinates& out) const noexcept;
    [[nodiscard]] HexEdgeType edgeTypeTo(HexCoordinates a, HexCoordinates b) const noexcept;
 
    // --- chunking -----------------------------------------------------------
 
    [[nodiscard]] std::int32_t chunkIndexOf(HexCoordinates coordinates) const noexcept;
    [[nodiscard]] std::int32_t chunkColumnOf(std::int32_t chunkIndex) const noexcept;
    [[nodiscard]] std::int32_t chunkRowOf(std::int32_t chunkIndex) const noexcept;
    [[nodiscard]] HexCoordinates chunkCell(std::int32_t chunkIndex, std::int32_t column,
                                           std::int32_t row) const noexcept;
    [[nodiscard]] HexVec3 chunkCenter(std::int32_t chunkIndex) const noexcept;
    void markAllChunksDirty() noexcept;
    void markChunkDirtyAndNeighbors(std::int32_t chunkIndex) noexcept;
 
    [[nodiscard]] std::int32_t takeDirtyChunk() noexcept;
    [[nodiscard]] std::int32_t dirtyChunkCount() const noexcept {
        return static_cast<std::int32_t>(dirtyQueue_.size());
    }
 
    // --- geometry -----------------------------------------------------------
 
    [[nodiscard]] HexVec3 cellPosition(HexCoordinates coordinates) const noexcept;
    [[nodiscard]] HexVec3 cellGroundPosition(HexCoordinates coordinates) const noexcept {
        return HexCoordinates::toWorldPosition(coordinates);
    }
 
    [[nodiscard]] Result<HexCoordinates> pickCell(HexVec3 rayOrigin, HexVec3 rayDirection) const noexcept;
 
    // --- cell queries -------------------------------------------------------
 
    [[nodiscard]] std::int32_t elevation(HexCoordinates c) const noexcept;
    [[nodiscard]] std::int32_t waterLevel(HexCoordinates c) const noexcept;
    [[nodiscard]] std::int32_t terrainType(HexCoordinates c) const noexcept;
    [[nodiscard]] std::int32_t urbanLevel(HexCoordinates c) const noexcept;
    [[nodiscard]] std::int32_t farmLevel(HexCoordinates c) const noexcept;
    [[nodiscard]] std::int32_t plantLevel(HexCoordinates c) const noexcept;
    [[nodiscard]] std::int32_t specialIndex(HexCoordinates c) const noexcept;
    [[nodiscard]] bool         isUnderwater(HexCoordinates c) const noexcept;
    [[nodiscard]] bool         hasRiver(HexCoordinates c) const noexcept;
    [[nodiscard]] bool         hasRoad(HexCoordinates c) const noexcept;
    [[nodiscard]] bool         hasRiverThrough(HexCoordinates c, HexDirection d) const noexcept;
    [[nodiscard]] bool         isWalled(HexCoordinates c) const noexcept;
    [[nodiscard]] bool         isExplored(HexCoordinates c) const noexcept;
    [[nodiscard]] bool         isExplorable(HexCoordinates c) const noexcept;
    [[nodiscard]] HexValues    values(HexCoordinates c) const noexcept;
    [[nodiscard]] HexFlags     flags(HexCoordinates c) const noexcept;
 
    // --- cell authoring -----------------------------------------------------
 
    [[nodiscard]] Result<void> setElevation(HexCoordinates c, std::int32_t elevation);
    [[nodiscard]] Result<void> setWaterLevel(HexCoordinates c, std::int32_t waterLevel);
    [[nodiscard]] Result<void> setTerrainType(HexCoordinates c, std::int32_t terrainType);
    [[nodiscard]] Result<void> setUrbanLevel(HexCoordinates c, std::int32_t level);
    [[nodiscard]] Result<void> setFarmLevel(HexCoordinates c, std::int32_t level);
    [[nodiscard]] Result<void> setPlantLevel(HexCoordinates c, std::int32_t level);
    [[nodiscard]] Result<void> setSpecialIndex(HexCoordinates c, std::int32_t index);
    [[nodiscard]] Result<void> setWalled(HexCoordinates c, bool walled);
    [[nodiscard]] Result<void> setExplored(HexCoordinates c, bool explored);
    [[nodiscard]] Result<void> setExplorable(HexCoordinates c, bool explorable);
    [[nodiscard]] Result<void> setCellState(HexCoordinates c, HexValues values, HexFlags flags);
    [[nodiscard]] Result<void> setOutgoingRiver(HexCoordinates c, HexDirection direction);
    [[nodiscard]] Result<void> removeRiver(HexCoordinates c);
    [[nodiscard]] Result<void> addRoad(HexCoordinates c, HexDirection direction);
    [[nodiscard]] Result<void> removeRoads(HexCoordinates c);
 
    // --- brush authoring ----------------------------------------------------
 
    [[nodiscard]] Result<void> editElevation(HexCoordinates center, std::int32_t radius, std::int32_t delta);
    [[nodiscard]] Result<void> editWaterLevel(HexCoordinates center, std::int32_t radius, std::int32_t delta);
    [[nodiscard]] Result<void> editTerrainType(HexCoordinates center, std::int32_t radius, std::int32_t terrainType);
    [[nodiscard]] Result<void> editFeatureLevel(HexCoordinates center, std::int32_t radius, std::int32_t feature,
                                                std::int32_t delta);
 
    void collectBrush(HexCoordinates center, std::int32_t radius, std::vector<std::int32_t>& out) const;
 
private:
    void markChunkDirty(std::int32_t chunkIndex) noexcept;
    void refreshCellDependents(HexCoordinates coordinates) noexcept;
    HexCellData* mutableCell(HexCoordinates coordinates) noexcept;
    void         validateRivers(HexCoordinates coordinates) noexcept;
 
    std::int32_t              cellCountX_  = 0;
    std::int32_t              cellCountZ_  = 0;
    std::int32_t              chunkCountX_ = 0;
    std::int32_t              chunkCountZ_ = 0;
    std::uint64_t             revision_    = 0;
    HexNoise                  noise_{};
    std::vector<HexCellData>  cells_;
    std::vector<std::uint8_t> chunkDirty_;
    std::vector<std::int32_t> dirtyQueue_;
};
 
}  // namespace eve::hexmap