util.h

Go to the documentation of this file.

#pragma once
 
#include "block.h"
#include <cstddef>
#include <iterator>
#include <ostream>
#include <vector>
 
namespace mcpp {
struct Coordinate {
    constexpr Coordinate(int x, int y, int z) : x(x), y(y), z(z) {}
 
    constexpr Coordinate() : x(0), y(0), z(0) {}
 
    constexpr Coordinate(double x, double y, double z)
        : x(static_cast<int>(x)), y(static_cast<int>(y)),
          z(static_cast<int>(z)) {}
 
    Coordinate operator+(const Coordinate& obj) const;
 
    bool operator==(const Coordinate& obj) const;
 
    bool operator!=(const Coordinate& obj) const;
 
    Coordinate operator-(const Coordinate& obj) const;
 
    [[nodiscard]] Coordinate clone() const;
 
    friend std::ostream& operator<<(std::ostream& out, const Coordinate& coord);
 
    int x;
    int y;
    int z;
};
 
struct Chunk {
    struct Iterator {
        using iterator_category = std::forward_iterator_tag;
        using difference_type = std::ptrdiff_t;
        using value_type = BlockType;
        using pointer = BlockType*;
        using reference = BlockType&;
 
        Iterator(pointer ptr) : m_ptr(ptr) {}
 
        reference operator*() const { return *m_ptr; }
 
        pointer operator->() { return m_ptr; }
 
        Iterator& operator++() {
            m_ptr++;
            return *this;
        }
 
        Iterator operator++(int) {
            Iterator tmp = *this;
            ++(*this);
            return tmp;
        }
 
        friend bool operator==(const Iterator& a, const Iterator& b) {
            return a.m_ptr == b.m_ptr;
        };
 
        friend bool operator!=(const Iterator& a, const Iterator& b) {
            return a.m_ptr != b.m_ptr;
        };
 
      private:
        pointer m_ptr;
    };
 
    struct ConstIterator {
        using iterator_category = std::forward_iterator_tag;
        using difference_type = std::ptrdiff_t;
        using value_type = BlockType;
        using pointer = const BlockType*;
        using reference = const BlockType&;
 
        ConstIterator(pointer ptr) : m_ptr(ptr) {}
 
        reference operator*() const { return *m_ptr; }
 
        pointer operator->() { return m_ptr; }
 
        ConstIterator& operator++() {
            m_ptr++;
            return *this;
        }
 
        ConstIterator operator++(int) {
            ConstIterator tmp = *this;
            ++(*this);
            return tmp;
        }
 
        friend bool operator==(const ConstIterator& a, const ConstIterator& b) {
            return a.m_ptr == b.m_ptr;
        };
 
        friend bool operator!=(const ConstIterator& a, const ConstIterator& b) {
            return a.m_ptr != b.m_ptr;
        };
 
      private:
        pointer m_ptr;
    };
 
    Iterator begin() { return Iterator(&raw_data[0]); }
    Iterator end() { return Iterator(&raw_data[_x_len * _y_len * _z_len]); }
    ConstIterator begin() const { return ConstIterator(&raw_data[0]); }
    ConstIterator end() const {
        return ConstIterator(&raw_data[_x_len * _y_len * _z_len]);
    }
 
    Chunk(const Coordinate& loc1, const Coordinate& loc2,
          const std::vector<BlockType>& block_list);
 
    ~Chunk();
 
    Chunk& operator=(const Chunk& other) noexcept;
 
    BlockType get_worldspace(const Coordinate& pos) const;
 
    BlockType get(int x, int y, int z) const;
 
    int x_len() const;
 
    int y_len() const;
 
    int z_len() const;
 
    Coordinate base_pt() const;
 
  private:
    Coordinate _base_pt;
    int _y_len;
    int _x_len;
    int _z_len;
    BlockType* raw_data;
};
 
struct HeightMap {
    struct Iterator {
        using iterator_category = std::forward_iterator_tag;
        using difference_type = std::ptrdiff_t;
        using value_type = int;
        using pointer = int*;
        using reference = int&;
 
        Iterator(pointer ptr) : m_ptr(ptr) {}
 
        reference operator*() const { return *m_ptr; }
 
        pointer operator->() { return m_ptr; }
 
        Iterator& operator++() {
            m_ptr++;
            return *this;
        }
 
        Iterator operator++(int) {
            Iterator tmp = *this;
            ++(*this);
            return tmp;
        }
 
        friend bool operator==(const Iterator& a, const Iterator& b) {
            return a.m_ptr == b.m_ptr;
        };
 
        friend bool operator!=(const Iterator& a, const Iterator& b) {
            return a.m_ptr != b.m_ptr;
        };
 
      private:
        pointer m_ptr;
    };
 
    struct ConstIterator {
        using iterator_category = std::forward_iterator_tag;
        using difference_type = std::ptrdiff_t;
        using value_type = int;
        using pointer = const int*;
        using reference = const int&;
 
        ConstIterator(pointer ptr) : m_ptr(ptr) {}
 
        reference operator*() const { return *m_ptr; }
 
        pointer operator->() { return m_ptr; }
 
        ConstIterator& operator++() {
            m_ptr++;
            return *this;
        }
 
        ConstIterator operator++(int) {
            ConstIterator tmp = *this;
            ++(*this);
            return tmp;
        }
 
        friend bool operator==(const ConstIterator& a, const ConstIterator& b) {
            return a.m_ptr == b.m_ptr;
        };
 
        friend bool operator!=(const ConstIterator& a, const ConstIterator& b) {
            return a.m_ptr != b.m_ptr;
        };
 
      private:
        pointer m_ptr;
    };
 
    Iterator begin() { return Iterator(&raw_heights[0]); }
    Iterator end() { return Iterator(&raw_heights[_x_len * _z_len]); }
    ConstIterator begin() const { return ConstIterator(&raw_heights[0]); }
    ConstIterator end() const {
        return ConstIterator(&raw_heights[_x_len * _z_len]);
    }
 
    HeightMap(const Coordinate& loc1, const Coordinate& loc2,
              const std::vector<int>& heights);
 
    ~HeightMap();
 
    HeightMap& operator=(const HeightMap& other) noexcept;
 
    int get(int x, int z) const;
 
    int get_worldspace(const Coordinate& loc) const;
 
    void fill_coord(Coordinate& out) const;
 
    int x_len() const;
 
    int z_len() const;
 
    Coordinate base_pt() const;
 
  private:
    Coordinate _base_pt;
    int _x_len;
    int _z_len;
    int* raw_heights;
};
 
} // namespace mcpp