Merge pull request #31 from rozukke/feature/chunk-data-structure

Add Chunk datastructure for more convenient access to `getBlocks`

Author: rozukke

include/mcpp/mcpp.h

@@ -25,18 +25,6 @@ class MinecraftConnection {
     /// Handle to the socket connection.
     std::unique_ptr<SocketConnection> conn;
 
-    /**
-     * @brief Helper function to convert flat block array to 3D.
-     *
-     * @param loc1 The first coordinate.
-     * @param loc2 The second coordinate.
-     * @param inVector The input flat block array.
-     * @return A 3D vector representing the blocks.
-     */
-    static std::vector<std::vector<std::vector<BlockType>>>
-    unflattenBlocksArray(const Coordinate& loc1, const Coordinate& loc2,
-                         const std::vector<BlockType>& inVector);
-
   public:
     /**
      * @brief Represents the main endpoint for interaction with the minecraft
@@ -132,10 +120,9 @@ class MinecraftConnection {
      *
      * @param loc1 1st corner of the cuboid
      * @param loc2 2nd corner of the cuboid
-     * @return 3D vector of BlockType in the specified cuboid.
+     * @return Chunk containing the blocks in the specified area.
      */
-    std::vector<std::vector<std::vector<BlockType>>>
-    getBlocks(const Coordinate& loc1, const Coordinate& loc2);
+    Chunk getBlocks(const Coordinate& loc1, const Coordinate& loc2);
 
     /**
      * @brief Returns the height of the specific provided x and y coordinate

include/mcpp/util.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include "block.h"
 #include <ostream>
 #include <vector>
 
@@ -12,8 +13,7 @@ namespace mcpp {
  * Represented using integers since sub-unit coordinates are not of particular
  * relevance. Allows for operations such as addition between coordinates.
  */
-class Coordinate {
-  public:
+struct Coordinate {
     /**
      * @brief Constructs a Coordinate object with integer values.
      *
@@ -87,6 +87,46 @@ class Coordinate {
     int z;
 };
 
+/**
+ * Stores a 3D cuboid of BlockTypes while preserving their relative location to
+ * the base point they were gathered at and each other.
+ */
+struct Chunk {
+    /**
+     * Initialized by copying from a flat vector of blocks
+     */
+    Chunk(const Coordinate& loc1, const Coordinate& loc2,
+          const std::vector<BlockType>& block_list);
+
+    ~Chunk();
+
+    /**
+     * Accesses the Minecraft block at absolute position pos and returns its
+     * BlockType if it is in the included area.
+     * @param pos: Abolute position in the Minecraft world to query BlockType
+     * for
+     * @return BlockType at specified location
+     */
+    BlockType get_worldspace(const Coordinate& pos);
+
+    /**
+     * Local equivalent of get_worldspace, equivalent to a 3D array access of
+     * the internal data.
+     * @param x: x element of array access
+     * @param y: y element of array access
+     * @param z: z element of array access
+     * @return BlockType at specified location
+     */
+    BlockType get(int x, int y, int z);
+
+  private:
+    Coordinate base_pt;
+    BlockType* raw_data;
+    int y_len;
+    int x_len;
+    int z_len;
+};
+
 /**
  * Represents a 2D area of the world with the y coordinates of the highest
  * non-air blocks at each (x,z)
@@ -125,4 +165,4 @@ struct HeightMap {
     int* raw_heights;
 };
 
-} // namespace mcpp
+} // namespace mcpp

src/mcpp.cpp

@@ -81,8 +81,8 @@ BlockType MinecraftConnection::getBlock(const Coordinate& loc) {
     return {parsedInts[0], parsedInts[1]};
 }
 
-std::vector<std::vector<std::vector<BlockType>>>
-MinecraftConnection::getBlocks(const Coordinate& loc1, const Coordinate& loc2) {
+Chunk MinecraftConnection::getBlocks(const Coordinate& loc1,
+                                     const Coordinate& loc2) {
     std::string returnValue =
         conn->sendReceiveCommand("world.getBlocksWithData", loc1.x, loc1.y,
                                  loc1.z, loc2.x, loc2.y, loc2.z);
@@ -108,7 +108,8 @@ MinecraftConnection::getBlocks(const Coordinate& loc1, const Coordinate& loc2) {
             break;
         }
     }
-    return unflattenBlocksArray(loc1, loc2, result);
+
+    return Chunk{loc1, loc2, result};
 }
 
 int MinecraftConnection::getHeight(int x, int z) {
@@ -128,29 +129,4 @@ const HeightMap MinecraftConnection::getHeights(const Coordinate& loc1,
     return HeightMap(loc1, loc2, returnVector);
 }
 
-std::vector<std::vector<std::vector<BlockType>>>
-MinecraftConnection::unflattenBlocksArray(
-    const Coordinate& loc1, const Coordinate& loc2,
-    const std::vector<BlockType>& inVector) {
-    // Initialise empty vector of correct size and shape
-    int y_len = abs(loc2.y - loc1.y) + 1;
-    int x_len = abs(loc2.x - loc1.x) + 1;
-    int z_len = abs(loc2.z - loc1.z) + 1;
-    std::vector<std::vector<std::vector<BlockType>>> returnVector(
-        y_len, std::vector<std::vector<BlockType>>(
-                   x_len, std::vector<BlockType>(z_len, BlockType(0))));
-
-    int index = 0;
-    for (int y = 0; y < y_len; y++) {
-        for (int x = 0; x < x_len; x++) {
-            for (int z = 0; z < z_len; z++) {
-                returnVector[y][x][z] = inVector[index];
-                index++;
-            }
-        }
-    }
-
-    return returnVector;
-}
-
 } // namespace mcpp

src/util.cpp

@@ -1,7 +1,7 @@
 #include "../include/mcpp/util.h"
-#include <cstdlib>
 #include <stdexcept>
 #include <string>
+#include <vector>
 
 namespace mcpp {
 
@@ -45,11 +45,55 @@ Coordinate Coordinate::clone() const {
     return Coordinate(this->x, this->y, this->z);
 }
 
+std::string to_string(const Coordinate& coord) {
+    using std::to_string;
+    return "(" + to_string(coord.x) + "," + to_string(coord.y) + "," +
+           to_string(coord.z) + ")";
+}
+
 std::ostream& operator<<(std::ostream& out, const Coordinate& coord) {
-    out << "(" << coord.x << ", " << coord.y << ", " << coord.z << ")";
+    out << to_string(coord);
     return out;
 }
 
+Chunk::Chunk(const Coordinate& loc1, const Coordinate& loc2,
+             const std::vector<BlockType>& block_list) {
+    Coordinate min{std::min(loc1.x, loc2.x), std::min(loc1.y, loc2.y),
+                   std::min(loc1.z, loc2.z)};
+    this->base_pt = min.clone();
+
+    Coordinate dim = loc1 - loc2;
+    x_len = std::abs(dim.x) + 1;
+    y_len = std::abs(dim.y) + 1;
+    z_len = std::abs(dim.z) + 1;
+
+    this->raw_data = new BlockType[block_list.size()];
+    std::copy(block_list.begin(), block_list.end(), raw_data);
+}
+
+Chunk::~Chunk() { delete[] raw_data; }
+
+BlockType Chunk::get(int x, int y, int z) {
+    if ((x < 0 || y < 0 || z < 0) ||
+        (x > x_len - 1 || y > y_len - 1 || z > z_len - 1)) {
+        throw std::out_of_range("Out of bounds Chunk access at " +
+                                to_string(Coordinate(x, y, z)));
+    }
+    return raw_data[z + z_len * (x + y_len * y)];
+}
+
+BlockType Chunk::get_worldspace(const Coordinate& pos) {
+    Coordinate array_pos = pos - base_pt;
+    if ((array_pos.x < 0 || array_pos.y < 0 || array_pos.z < 0) ||
+        (array_pos.x > x_len - 1 || array_pos.y > y_len - 1 ||
+         array_pos.z > z_len - 1)) {
+        throw std::out_of_range("Out of bounds Chunk access at " +
+                                to_string(array_pos) + " (world coordinate " +
+                                to_string(pos) + " )");
+    }
+    return raw_data[array_pos.z + z_len * (array_pos.x + y_len * array_pos.y)];
+}
+
 HeightMap::HeightMap(const Coordinate& loc1, const Coordinate& loc2,
                      const std::vector<int>& heights) {
     base_pt = Coordinate{

test/local_tests.cpp

@@ -73,7 +73,7 @@ TEST_CASE("Test Coordinate class") {
         Coordinate testCoord(1, 2, 3);
         std::stringstream ss;
         ss << testCoord;
-        CHECK_EQ(ss.str(), "(1, 2, 3)");
+        CHECK_EQ(ss.str(), "(1,2,3)");
     }
 }
 

test/minecraft_tests.cpp

@@ -119,32 +119,52 @@ TEST_CASE("Test the main mcpp class") {
         mc.setBlock(heightTestLoc, Blocks::AIR);
     }
 
-    // Used for cuboid functions
-    Coordinate testLoc2(96, 96, 96);
-
-    SUBCASE("setBlocks") { mc.setBlocks(test_loc, testLoc2, Blocks::STONE); }
-
-    SUBCASE("getBlocks") {
-        mc.setBlocks(test_loc, testLoc2, Blocks::DIRT);
-
-        auto expected = std::vector<std::vector<std::vector<BlockType>>>(
-            5, std::vector<std::vector<BlockType>>(
-                   5, std::vector<BlockType>(5, Blocks::DIRT)));
-
-        std::vector returnVector = mc.getBlocks(test_loc, testLoc2);
-        CHECK_EQ(returnVector, expected);
+    SUBCASE("setBlocks") {
+        Coordinate loc1{100, 100, 100};
+        Coordinate loc2{110, 110, 110};
+        mc.setBlocks(loc1, loc2, Blocks::STONE);
     }
+}
 
-    SUBCASE("getBlocks with mod") {
-        mc.setBlocks(test_loc, testLoc2, Blocks::GRANITE);
-
-        auto expected = std::vector<std::vector<std::vector<BlockType>>>(
-            5, std::vector<std::vector<BlockType>>(
-                   5, std::vector<BlockType>(5, Blocks::GRANITE)));
+TEST_CASE("getBlocks and Chunk operations") {
+    // Setup
+    Coordinate test_loc(100, 100, 100);
+    Coordinate loc1{100, 100, 100};
+    Coordinate loc2{110, 110, 110};
+
+    // Reset blocks that existed before
+    mc.setBlocks(loc1, loc2, Blocks::AIR);
+    mc.setBlocks(loc1, loc2, Blocks::BRICKS);
+    mc.setBlock(loc1, Blocks::GOLD_BLOCK);
+    mc.setBlock(loc2, Blocks::DIAMOND_BLOCK);
+    mc.setBlock(loc1 + Coordinate{1, 2, 3}, Blocks::IRON_BLOCK);
+    Chunk res = mc.getBlocks(loc1, loc2);
+
+    SUBCASE("Block accessing returns correct block using get()") {
+        CHECK_EQ(res.get(0, 0, 0), Blocks::GOLD_BLOCK);
+        CHECK_EQ(res.get(1, 1, 1), Blocks::BRICKS);
+        CHECK_EQ(res.get(1, 2, 3), Blocks::IRON_BLOCK);
+        CHECK_EQ(res.get(10, 10, 10), Blocks::DIAMOND_BLOCK);
+    }
 
-        std::vector returnVector = mc.getBlocks(test_loc, testLoc2);
+    SUBCASE("Block accessing returns correct block using get_worldspace()") {
+        CHECK_EQ(res.get_worldspace(loc1), Blocks::GOLD_BLOCK);
+        CHECK_EQ(res.get_worldspace(loc1 + Coordinate{1, 1, 1}),
+                 Blocks::BRICKS);
+        CHECK_EQ(res.get_worldspace(loc1 + Coordinate{1, 2, 3}),
+                 Blocks::IRON_BLOCK);
+        CHECK_EQ(res.get_worldspace(loc2), Blocks::DIAMOND_BLOCK);
+    }
 
-        CHECK_EQ(returnVector, expected);
+    SUBCASE("Access out of bounds correctly throws") {
+        CHECK_THROWS(res.get(11, 0, 0));
+        CHECK_THROWS(res.get(0, 11, 0));
+        CHECK_THROWS(res.get(0, 0, 11));
+        CHECK_THROWS(res.get(-1, 0, 0));
+        CHECK_THROWS(res.get(0, -1, 0));
+        CHECK_THROWS(res.get(0, 0, -1));
+        CHECK_THROWS(res.get_worldspace(loc1 + Coordinate{-1, -1, -1}));
+        CHECK_THROWS(res.get_worldspace(loc1 + Coordinate{11, 11, 11}));
     }
 
     mc.setBlock(test_loc, BlockType(0));