Some more chunk work.

src/dawnrpg/component/world/Chunk.hpp

@@ -15,6 +15,14 @@ namespace Dawn {
     int32_t x;
     int32_t y;
     int32_t z;
+    
+    ChunkPosition operator-(const ChunkPosition &other) const {
+      return {
+        this->x - other.x,
+        this->y - other.y,
+        this->z - other.z
+      };
+    }
   };
 
   enum class TileID : uint16_t {
@@ -30,6 +38,7 @@ namespace Dawn {
     public:
       struct ChunkPosition position;
       struct Tile tiles[CHUNK_WIDTH][CHUNK_HEIGHT][CHUNK_DEPTH];
+      
       Chunk();
       ~Chunk();
   };

src/dawnrpg/component/world/Map.cpp

@@ -29,10 +29,10 @@ void Map::entityNotifyDispose(std::shared_ptr<SceneItem> item) {
 }
 
 void Map::onInit() {
+  this->setSize(1, 1, 1);
 }
 
 void Map::onDispose() {
-  this->chunkOrder.clear();
 }
 
 void Map::setSize(
@@ -40,24 +40,30 @@ void Map::setSize(
   const uint8_t height,
   const uint8_t depth
 ) {
+  this->chunkOrder.clear();
+
   this->mapChunkWidth = width;
   this->mapChunkHeight = height;
   this->mapChunkDepth = depth;
-  this->chunks = std::make_unique<Chunk[]>(width * height * depth);
+  this->mapChunkCount = width * height * depth;
+  this->chunks = std::make_unique<std::shared_ptr<Chunk>[]>(
+    this->mapChunkCount
+  );
 
   this->chunkTopLeft.x = 0;
   this->chunkTopLeft.y = 0;
   this->chunkTopLeft.z = 0;
-
+  
-  this->chunkOrder.clear();
+  // Load initial chunks
-  for(uint8_t z = 0; z < depth; z++) {
+  for(auto z = 0; z < depth; z++) {
-    for(uint8_t y = 0; y < height; y++) {
+    for(auto y = 0; y < height; y++) {
-      for(uint8_t x = 0; x < width; x++) {
+      for(auto x = 0; x < width; x++) {
-        this->chunkOrder.push_back(&this->chunks[
+        auto chunk = std::make_shared<Chunk>();
-          (z * height * width) +
+        chunk->position.x = x;
-          (y * width) +
+        chunk->position.y = y;
-          x
+        chunk->position.z = z;
-        ]);
+        this->chunks[x + y * width + z * width * height] = chunk;
+        this->chunkOrder.push_back(chunk);
       }
     }
   }
@@ -89,4 +95,27 @@ std::shared_ptr<Entity> Map::getEntityAt(const EntityTilePosition &pos) {
     return ent;
   }
   return nullptr;
+}
+
+std::shared_ptr<Chunk> Map::getChunkAt(const struct ChunkPosition &pos) {
+  assertTrue(pos.x >= this->chunkTopLeft.x, "Chunk X out of bounds.");
+  assertTrue(pos.y >= this->chunkTopLeft.y, "Chunk Y out of bounds.");
+  assertTrue(pos.z >= this->chunkTopLeft.z, "Chunk Z out of bounds.");
+
+  // First, offset position from top left
+  auto offset = pos - this->chunkTopLeft;
+
+  assertTrue(offset.x < this->mapChunkWidth, "Chunk X out of bounds.");
+  assertTrue(offset.y < this->mapChunkHeight, "Chunk Y out of bounds.");
+  assertTrue(offset.z < this->mapChunkDepth, "Chunk Z out of bounds.");
+  
+  // Convert to index
+  auto i = (
+    offset.x +
+    offset.y * this->mapChunkWidth +
+    offset.z * this->mapChunkWidth * this->mapChunkHeight
+  );
+
+  assertTrue(i >= 0 && i < this->mapChunkCount, "Chunk index out of bounds.");
+  return this->chunkOrder[i];
 }

src/dawnrpg/component/world/Map.hpp

@@ -15,8 +15,9 @@ namespace Dawn {
       std::unordered_map<enum EntityID, std::weak_ptr<Entity>> entities;
 
       uint8_t mapChunkWidth, mapChunkHeight, mapChunkDepth;
-      std::unique_ptr<Chunk[]> chunks;
+      int32_t mapChunkCount;
-      std::vector<Chunk*> chunkOrder;
+      std::unique_ptr<std::shared_ptr<Chunk>[]> chunks;
+      std::vector<std::shared_ptr<Chunk>> chunkOrder;
       struct ChunkPosition chunkTopLeft;
   
       /**
@@ -75,6 +76,14 @@ namespace Dawn {
        */
       std::shared_ptr<Entity> getEntityAt(const EntityTilePosition &pos);
 
+      /**
+       * Gets the chunk at the given position.
+       * 
+       * @param pos The position of the chunk to get.
+       * @return The chunk at the given position.
+       */
+      std::shared_ptr<Chunk> getChunkAt(const struct ChunkPosition &pos);
+
       friend class Entity;
   };
 }

src/dawnrpg/scenes/WorldScene.cpp

@@ -44,6 +44,12 @@ void Dawn::worldScene(Scene &s) {
   
   auto world = createWorldPrefab(s);
   auto map = createMapPrefab(world.world);
+  map.map->setSize(3, 3, 3);
+
+  auto chunk = map.map->getChunkAt({ 0, 0, 0 });
+  chunk = map.map->getChunkAt({ 1, 0, 0 });
+  chunk = map.map->getChunkAt({ 0, 1, 0 });
+  chunk = map.map->getChunkAt({ 0, 0, 1 });
 
   auto player = createPlayerPrefab(map.map);
   player.player->camera = camera;