Add base overlay

src/dusk/world/chunk.c

@@ -181,23 +181,30 @@ void chunkLoad(chunk_t *chunk, const uint16_t x, const uint16_t y) {
 
   // Only load data if the chunk is within bounds.
   if(x >= WORLD_WIDTH || y >= WORLD_HEIGHT) {
-    memorySet(chunk->tiles, 0, sizeof(chunk->tiles));
+    memorySet(chunk->tilesBase, 0, sizeof(chunk->tilesBase));
+    memorySet(chunk->tilesBaseOverlay, 0, sizeof(chunk->tilesBaseOverlay));
     return;
   }
   
   // Is chunk data defined?
   const chunkdata_t *chunkData = WORLD_CHUNKS[y * WORLD_WIDTH + x];
   if(chunkData == NULL) {
-    memorySet(chunk->tiles, 0, sizeof(chunk->tiles));
+    memorySet(chunk->tilesBase, 0, sizeof(chunk->tilesBase));
+    memorySet(chunk->tilesBaseOverlay, 0, sizeof(chunk->tilesBaseOverlay));
     return;
   }
 
   // Load tile data into chunk
   printf("Loading chunk at (%u, %u)\n", x, y);
   memoryCopy(
-    chunk->tiles,
+    chunk->tilesBase,
     chunkData->layerBase,
-    sizeof(chunk->tiles)
+    sizeof(chunk->tilesBase)
+  );
+  memoryCopy(
+    chunk->tilesBaseOverlay,
+    chunkData->layerBaseOverlay,
+    sizeof(chunk->tilesBaseOverlay)
   );
 
   // Load chunk entities

src/dusk/world/chunk.h

@@ -19,7 +19,8 @@
 
 typedef struct {
   uint16_t x, y;
-  tile_t tiles[CHUNK_TILE_COUNT];
+  tile_t tilesBase[CHUNK_TILE_COUNT];
+  tile_t tilesBaseOverlay[CHUNK_TILE_COUNT];
   uint32_t entityIDs[CHUNK_ENTITY_COUNT_MAX];
   uint8_t entityCount;
 } chunk_t;

src/dusk/world/chunkdata.h

@@ -18,6 +18,6 @@ typedef struct {
 
 typedef struct {
   uint8_t layerBase[CHUNK_TILE_COUNT];
-  uint8_t layerOverlay[CHUNK_TILE_COUNT];
+  uint8_t layerBaseOverlay[CHUNK_TILE_COUNT];
   chunkentity_t entities[CHUNK_ENTITY_COUNT_MAX];
 } chunkdata_t;

src/duskraylib/display/draw/drawoverworld.c

@@ -48,8 +48,33 @@ void drawOverworldDraw(void) {
   uint8_t colorCount = sizeof(colors) / sizeof(Color);
 
   do {
+    // Base layer
     for(uint8_t i = 0; i < CHUNK_TILE_COUNT; i++) {
-      tile_t tile = chunk->tiles[i];
+      tile_t tile = chunk->tilesBase[i];
+      if(tile == 0) continue; // Skip empty tiles
+
+      uint32_t tilemapIndex = tile - 1; // Convert to zero-based index
+      uint32_t x = (uint32_t)chunk->x * CHUNK_WIDTH * TILE_WIDTH + (i % CHUNK_WIDTH) * TILE_WIDTH;
+      uint32_t y = (uint32_t)chunk->y * CHUNK_HEIGHT * TILE_HEIGHT + (i / CHUNK_WIDTH) * TILE_HEIGHT;
+      uint32_t tilemapX = (tilemapIndex % (RENDER_TILEMAP_TEXTURE.width / TILE_WIDTH)) * TILE_WIDTH;
+      uint32_t tilemapY = (tilemapIndex / (RENDER_TILEMAP_TEXTURE.width / TILE_WIDTH)) * TILE_HEIGHT;
+
+      DrawTextureRec(
+        RENDER_TILEMAP_TEXTURE,
+        (Rectangle){
+          tilemapX,
+          tilemapY,
+          TILE_WIDTH,
+          TILE_HEIGHT
+        },
+        (Vector2){ x, y },
+        WHITE
+      );
+    }
+
+    // Base overlay layer
+    for(uint8_t i = 0; i < CHUNK_TILE_COUNT; i++) {
+      tile_t tile = chunk->tilesBaseOverlay[i];
       if(tile == 0) continue; // Skip empty tiles
 
       uint32_t tilemapIndex = tile - 1; // Convert to zero-based index
@@ -69,17 +94,8 @@ void drawOverworldDraw(void) {
         (Vector2){ x, y },
         WHITE
       );
-
-      // DrawRectangle(x, y, TILE_WIDTH, TILE_HEIGHT, colors[tile % colorCount]);
     }
 
-    // DrawRectangle(
-    //   ((int32_t)chunk->x) * CHUNK_WIDTH * TILE_WIDTH,
-    //   ((int32_t)chunk->y) * CHUNK_HEIGHT * TILE_HEIGHT,
-    //   CHUNK_WIDTH * TILE_WIDTH,
-    //   CHUNK_HEIGHT * TILE_HEIGHT,
-    //   (chunk->tiles[0] == 0) ? RED : GREEN
-    // );
     chunk++;
   } while(chunk < CHUNK_MAP.chunks + CHUNK_MAP_COUNT);