chunk.h

Go to the documentation of this file.

#pragma once
 
#include "block.h"
#include "coordinate.h"
#include <memory>
#include <vector>
 
namespace mcpp {
struct Chunk {
private:
  Coordinate _base_pt;
  uint16_t _x_len;
  uint16_t _y_len;
  uint16_t _z_len;
  std::unique_ptr<BlockType[]> _raw_data;
 
public:
  // Constructors and assignment
  Chunk(const Coordinate& loc1, const Coordinate& loc2, const std::vector<BlockType>& block_list);
  ~Chunk() = default;
 
  Chunk(const Chunk& other)
      : _base_pt(other._base_pt), _x_len(other._x_len), _y_len(other._y_len), _z_len(other._z_len) {
    size_t size = _x_len * _y_len * _z_len;
    _raw_data.reset(new BlockType[size]);
    std::copy(other._raw_data.get(), other._raw_data.get() + size, _raw_data.get());
  }
 
  Chunk(Chunk&& other) noexcept = default;
  Chunk& operator=(const Chunk& other);
  Chunk& operator=(Chunk&& other) = default;
 
  BlockType get_worldspace(const Coordinate& pos) const;
 
  BlockType get(int x, int y, int z) const;
 
  uint16_t x_len() const;
 
  uint16_t y_len() const;
 
  uint16_t z_len() const;
 
  Coordinate base_pt() const;
 
  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;
  };
 
  // Iterators
  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]); }
};
} // namespace mcpp