Tiles

src/rpg/entity/entity.c

@@ -76,17 +76,19 @@ void entityWalk(entity_t *entity, const entitydir_t direction) {
   }
 
   // Get tile under foot
-  chunkpos_t chunkPos;
+  tile_t tile = mapGetTile(newPos);
-  worldPosToChunkPos(&newPos, &chunkPos);
+  if(tile == TILE_NULL && newPos.z > 0) {
-  chunkindex_t chunkIndex = mapGetChunkIndexAt(chunkPos);
+    // Check one level down for walkable tile (stairs down)
-  tile_t tile = TILE_NULL;
+    worldpos_t belowPos = newPos;
-  if(chunkIndex != -1) {
+    belowPos.z -= 1;
-    chunk_t *chunk = mapGetChunk(chunkIndex);
+    tile = mapGetTile(belowPos);
-    assertNotNull(chunk, "Chunk pointer cannot be NULL");
+    
-    chunktileindex_t tileIndex = woprldPosToChunkTileIndex(&newPos);
+    if(tile != TILE_NULL) newPos.z -= 1;
-    tile = chunk->tiles[tileIndex];
   }
 
+  // Tile walkable?
+  if(!tileIsWalkable(tile)) return;
+
   // Entity in way?
   entity_t *other = ENTITIES;
   do {
@@ -99,6 +101,8 @@ void entityWalk(entity_t *entity, const entitydir_t direction) {
   entity->position = newPos;
   entity->animation = ENTITY_ANIM_WALK;
   entity->animTime = ENTITY_ANIM_WALK_DURATION;// TODO: Running vs walking
+
+  // We are comitting, we can run effects here.
 }
 
 entity_t * entityGetAt(const worldpos_t position) {

src/rpg/world/CMakeLists.txt

@@ -9,4 +9,5 @@ target_sources(${DUSK_TARGET_NAME}
     chunk.c
     map.c
     worldpos.c
+    tile.c
 )

src/rpg/world/map.c

@@ -7,6 +7,7 @@
 
 #include "map.h"
 #include "util/memory.h"
+#include "assert/assert.h"
 
 map_t MAP;
 
@@ -126,16 +127,13 @@ void mapChunkLoad(chunk_t* chunk) {
   );
   memoryZero(chunk->tiles, sizeof(tile_t) * CHUNK_TILE_COUNT);
 
-  uint8_t x, y, z;
+  // 3x3 test walkable area
-  x = 1;
+  for(int y = 0; y <= 3; y++) {
-  y = 2;
+    for(int x = 0; x <= 3; x++) {
-  z = 0;
+      chunktileindex_t tileIndex = (y * CHUNK_WIDTH) + x;
-  
+      chunk->tiles[tileIndex] = TILE_WALKABLE;
-  chunk->tiles[
+    }
-    (z * CHUNK_WIDTH * CHUNK_HEIGHT) +
+  }
-    (y * CHUNK_WIDTH) +
-    x
-  ] = (tile_t){ .id = 1 };
 }
 
 chunkindex_t mapGetChunkIndexAt(const chunkpos_t position) {
@@ -160,4 +158,16 @@ chunkindex_t mapGetChunkIndexAt(const chunkpos_t position) {
 chunk_t* mapGetChunk(const uint8_t index) {
   if(index >= MAP_CHUNK_COUNT) return NULL;
   return &MAP.chunks[index];
+}
+
+tile_t mapGetTile(const worldpos_t position) {
+  chunkpos_t chunkPos;
+  worldPosToChunkPos(&position, &chunkPos);
+  chunkindex_t chunkIndex = mapGetChunkIndexAt(chunkPos);
+  if(chunkIndex == -1) return TILE_NULL;
+
+  chunk_t *chunk = mapGetChunk(chunkIndex);
+  assertNotNull(chunk, "Chunk pointer cannot be NULL");
+  chunktileindex_t tileIndex = woprldPosToChunkTileIndex(&position);
+  return chunk->tiles[tileIndex];
 }

src/rpg/world/map.h

@@ -61,4 +61,12 @@ chunkindex_t mapGetChunkIndexAt(const chunkpos_t position);
  * @param chunkIndex The index of the chunk.
  * @return A pointer to the chunk.
  */
-chunk_t * mapGetChunk(const uint8_t chunkIndex);
+chunk_t * mapGetChunk(const uint8_t chunkIndex);
+
+/**
+ * Gets the tile at the given world position.
+ * 
+ * @param position The world position.
+ * @return The tile at that position, or TILE_NULL if the chunk is unloaded.
+ */
+tile_t mapGetTile(const worldpos_t position);

src/rpg/world/tile.c

@@ -0,0 +1,12 @@
+/**
+ * Copyright (c) 2025 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "tile.h"
+
+bool_t tileIsWalkable(const tile_t tile) {
+  return tile == TILE_WALKABLE;
+}

src/rpg/world/tile.h

@@ -9,8 +9,15 @@
 #include "dusk.h"
 
 
-typedef struct tile_s {
+typedef uint8_t tile_t;
-  uint8_t id;
-} tile_t;
 
-#define TILE_NULL ((tile_t){ .id = 0 })
+#define TILE_NULL 0
+#define TILE_WALKABLE 1
+
+/**
+ * Returns whether or not the given tile is walkable.
+ * 
+ * @param tile The tile to check.
+ * @return bool_t True if walkable, false if not.
+ */
+bool_t tileIsWalkable(const tile_t tile);