Basic tile code ready.

src/dawnrpg/component/entity/Entity.cpp

@@ -94,6 +94,15 @@ struct EntityStepResult Entity::move(
 
   // Get the tile at the destination, check for height if we are on stairs, etc.
   // If the tile is not walkable, return early.
+  auto chunk = map->getChunkAtTile(newPosition);
+  auto tilePos = newPosition.toTilePosition();
+  auto tileAt = chunk->getTileAt(tilePos);
+  if(tileAt.isSolid()) {
+    result.type = EntityStepResultType::SolidTileInWay;
+    result.tileInWayChunk = chunk;
+    result.tileInWayPosition = tilePos;
+    return result;
+  }
 
   // Move the entity to the new tile.
   this->lastTilePosition = this->tilePosition;

src/dawnrpg/component/entity/Entity.hpp

@@ -19,6 +19,7 @@ namespace Dawn {
     Turn,
     Step,
     EntityInWay,
+    SolidTileInWay
   };
 
   struct EntityStepResult {
@@ -26,6 +27,9 @@ namespace Dawn {
 
     // I'd love to unionize this but it seems that it's not ideal rn.
     std::shared_ptr<Entity> entityInWay;
+
+    std::shared_ptr<Chunk> tileInWayChunk;
+    struct TilePosition tileInWayPosition;
   };
 
   class Entity : public SceneComponent {

src/dawnrpg/component/entity/EntityDirection.cpp

@@ -27,8 +27,8 @@ struct EntityTilePosition entityDirectionGetRelativeTilePosition(
 ) {
   struct EntityTilePosition result = pos;
   switch(dir) {
-    case EntityDirection::Up: result.y += distance; break;
-    case EntityDirection::Down: result.y -= distance; break;
+    case EntityDirection::Up: result.z -= distance; break;
+    case EntityDirection::Down: result.z += distance; break;
     case EntityDirection::Left: result.x -= distance; break;
     case EntityDirection::Right: result.x += distance; break;
     default:

src/dawnrpg/component/entity/EntityTilePosition.cpp

@@ -7,10 +7,26 @@
 
 using namespace Dawn;
 
-const glm::vec3 EntityTilePosition::toWorldSpace() {
+const glm::vec3 EntityTilePosition::toWorldSpace() const {
   return glm::vec3(
     this->x,
     this->y,
     this->z
   );
 }
+
+const struct ChunkPosition EntityTilePosition::toChunkPosition() const {
+  return {
+    (int32_t)(this->x / CHUNK_WIDTH),
+    (int32_t)(this->y / CHUNK_HEIGHT),
+    (int32_t)(this->z / CHUNK_DEPTH)
+  };
+}
+
+const struct TilePosition EntityTilePosition::toTilePosition() const {
+  return {
+    (uint8_t)(this->x % CHUNK_WIDTH),
+    (uint8_t)(this->y % CHUNK_HEIGHT),
+    (uint8_t)(this->z % CHUNK_DEPTH)
+  };
+}

src/dawnrpg/component/entity/EntityTilePosition.hpp

@@ -4,7 +4,7 @@
 // https://opensource.org/licenses/MIT
 
 #pragma once
-#include "dawnlibs.hpp"
+#include "component/world/Chunk.hpp"
 
 namespace Dawn {
   struct EntityTilePosition {
@@ -25,6 +25,20 @@ namespace Dawn {
      * 
      * @return This tile position in world space.
      */
-    const glm::vec3 toWorldSpace();
+    const glm::vec3 toWorldSpace() const;
+
+    /**
+     * Converts the tile position to a chunk position.
+     * 
+     * @return This tile position in chunk space.
+     */
+    const struct ChunkPosition toChunkPosition() const;
+
+    /**
+     * Converts the tile position to a chunk tile position.
+     * 
+     * @return This tile position in chunk tile space.
+     */
+    const struct TilePosition toTilePosition() const;
   };
 }

src/dawnrpg/component/world/CMakeLists.txt

@@ -8,4 +8,5 @@ target_sources(${DAWN_TARGET_NAME}
     World.cpp
     Map.cpp
     Chunk.cpp
+    Tile.cpp
 )

src/dawnrpg/component/world/Chunk.cpp

@@ -11,6 +11,10 @@ Chunk::Chunk() {
 
 }
 
+struct Tile Chunk::getTileAt(const struct TilePosition &pos) {
+  return this->tiles[pos.x][pos.y][pos.z];
+}
+
 Chunk::~Chunk() {
 
 }

src/dawnrpg/component/world/Chunk.hpp

@@ -4,7 +4,7 @@
 // https://opensource.org/licenses/MIT
 
 #pragma once
-#include "dawnlibs.hpp"
+#include "Tile.hpp"
 
 #define CHUNK_WIDTH 32
 #define CHUNK_HEIGHT 32
@@ -25,21 +25,21 @@ namespace Dawn {
     }
   };
   
-  enum class TileID : uint16_t {
-    Null = 0,
-    Test = 1
-  };
-
-  struct Tile {
-    enum TileID id;
-  };
-  
   class Chunk {
     public:
       struct ChunkPosition position;
       struct Tile tiles[CHUNK_WIDTH][CHUNK_HEIGHT][CHUNK_DEPTH];
       
       Chunk();
+
+      /**
+       * Gets the tile at the given position.
+       * 
+       * @param pos The position of the tile to get.
+       * @return The tile at the given position.
+       */
+      struct Tile getTileAt(const struct TilePosition &pos);
+
       ~Chunk();
   };
 }

src/dawnrpg/component/world/Map.cpp

@@ -119,3 +119,14 @@ std::shared_ptr<Chunk> Map::getChunkAt(const struct ChunkPosition &pos) {
   assertTrue(i >= 0 && i < this->mapChunkCount, "Chunk index out of bounds.");
   return this->chunkOrder[i];
 }
+
+std::shared_ptr<Chunk> Map::getChunkAtTile(const EntityTilePosition &pos) {
+  auto chunkPos = pos.toChunkPosition();
+  return this->getChunkAt(chunkPos);
+}
+
+struct Tile Map::getTileAt(const EntityTilePosition &pos) {
+  auto chunk = this->getChunkAtTile(pos);
+  auto tilePos = pos.toTilePosition();
+  return chunk->getTileAt(tilePos);
+}

src/dawnrpg/component/world/Map.hpp

@@ -84,6 +84,22 @@ namespace Dawn {
        */
       std::shared_ptr<Chunk> getChunkAt(const struct ChunkPosition &pos);
 
+      /**
+       * Gets the chunk at the given tile position.
+       * 
+       * @param pos The tile position of the chunk to get.
+       * @return The chunk at the given tile position.
+       */
+      std::shared_ptr<Chunk> getChunkAtTile(const EntityTilePosition &pos);
+
+      /**
+       * Gets the tile at the given position.
+       * 
+       * @param pos The position of the tile to get.
+       * @return The tile at the given position.
+       */
+      struct Tile getTileAt(const EntityTilePosition &pos);
+
       friend class Entity;
   };
 }

src/dawnrpg/component/world/Tile.cpp

@@ -0,0 +1,12 @@
+// Copyright (c) 2024 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "Tile.hpp"
+
+using namespace Dawn;
+
+bool_t Tile::isSolid() {
+  return false;
+}

src/dawnrpg/component/world/Tile.hpp

@@ -0,0 +1,34 @@
+// Copyright (c) 2024 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "dawnlibs.hpp"
+
+namespace Dawn {
+  enum class TileID : uint16_t {
+    Null = 0,
+    Test = 1
+  };
+
+  union TileData {
+    int64_t raw;
+  };
+
+  struct Tile {
+    enum TileID id;
+    union TileData data;
+
+    /**
+     * Returns whether or not this tile is solid.
+     * 
+     * @return Whether or not this tile is solid.
+     */
+    bool_t isSolid();
+  };
+
+  struct TilePosition {
+    uint8_t x, y, z;
+  };
+}