HexCoordinates.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "hexmap/HexMetrics.h"
 
#include <cmath>
#include <cstdint>
 
namespace eve::hexmap {
 
struct EVENGINE_API_WORLD HexCoordinates {
    std::int32_t x = 0;
    std::int32_t z = 0;
 
    constexpr HexCoordinates() noexcept = default;
    constexpr HexCoordinates(std::int32_t xValue, std::int32_t zValue) noexcept : x(xValue), z(zValue) {}
 
    [[nodiscard]] constexpr std::int32_t y() const noexcept { return -x - z; }
 
    [[nodiscard]] constexpr bool operator==(const HexCoordinates& other) const noexcept {
        return x == other.x && z == other.z;
    }
    [[nodiscard]] constexpr bool operator!=(const HexCoordinates& other) const noexcept { return !(*this == other); }
 
    [[nodiscard]] constexpr HexCoordinates step(HexDirection direction, std::int32_t distance = 1) const noexcept {
        switch (direction) {
            case HexDirection::NE: return HexCoordinates{x, z + distance};
            case HexDirection::E: return HexCoordinates{x + distance, z};
            case HexDirection::SE: return HexCoordinates{x + distance, z - distance};
            case HexDirection::SW: return HexCoordinates{x, z - distance};
            case HexDirection::W: return HexCoordinates{x - distance, z};
            case HexDirection::NW: return HexCoordinates{x - distance, z + distance};
        }
        return *this;
    }
 
    [[nodiscard]] constexpr std::int32_t distanceTo(const HexCoordinates& other) const noexcept {
        const std::int32_t dx   = x - other.x;
        const std::int32_t dy   = y() - other.y();
        const std::int32_t dz   = z - other.z;
        const auto         absi = [](std::int32_t v) { return v < 0 ? -v : v; };
        return (absi(dx) + absi(dy) + absi(dz)) / 2;
    }
 
    [[nodiscard]] constexpr float hexX() const noexcept {
        const std::int32_t half = floorDiv2(z);
        return static_cast<float>(x + half) + ((z & 1) == 0 ? 0.f : 0.5f);
    }
 
    [[nodiscard]] constexpr float hexZ() const noexcept { return static_cast<float>(z) * HexMetrics::kOuterToInner; }
 
    [[nodiscard]] constexpr std::int32_t chunkColumn() const noexcept {
        return (x + floorDiv2(z)) / HexMetrics::kChunkSizeX;
    }
 
    [[nodiscard]] constexpr std::int32_t chunkRow() const noexcept { return z / HexMetrics::kChunkSizeZ; }
 
    [[nodiscard]] static constexpr HexCoordinates fromOffset(std::int32_t offsetX, std::int32_t offsetZ) noexcept {
        return HexCoordinates{offsetX - floorDiv2(offsetZ), offsetZ};
    }
 
    [[nodiscard]] constexpr std::int32_t offsetX() const noexcept { return x + floorDiv2(z); }
 
    [[nodiscard]] constexpr std::int32_t offsetZ() const noexcept { return z; }
 
    [[nodiscard]] static HexVec3 toWorldPosition(HexCoordinates coordinates) noexcept {
        const float diameter = HexMetrics::innerDiameter();
        const float fx       = static_cast<float>(coordinates.x) + 0.5f * static_cast<float>(coordinates.z);
        return HexVec3{fx * diameter, 0.f, static_cast<float>(coordinates.z) * HexMetrics::rowSpacing()};
    }
 
    [[nodiscard]] static HexCoordinates fromWorldPosition(HexVec3 position) noexcept;
 
private:
    [[nodiscard]] static constexpr std::int32_t floorDiv2(std::int32_t value) noexcept {
        return value >= 0 ? value / 2 : -(((-value) + 1) / 2);
    }
};
 
}  // namespace eve::hexmap