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 {
    explicit Coordinate(int x = 0, int y = 0, int z = 0);
 
    Coordinate(double x, double y, double 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;
    };
 
    Iterator begin() { return Iterator(&raw_data[0]); }
    Iterator end() { return Iterator(&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);
 
    BlockType get(int x, int y, int z);
 
    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;
    };
 
    Iterator begin() { return Iterator(&raw_heights[0]); }
    Iterator end() { return Iterator(&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);
 
    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