Made a big mess of the codebase

src/rpg/world/CMakeLists.txt

@@ -0,0 +1,11 @@
+# Copyright (c) 2025 Dominic Masters
+# 
+# This software is released under the MIT License.
+# https://opensource.org/licenses/MIT
+
+# Sources
+target_sources(${DUSK_TARGET_NAME}
+  PRIVATE
+    chunk.c
+    overworld.c
+)

src/rpg/world/chunk.c

@@ -0,0 +1,321 @@
+/**
+ * Copyright (c) 2025 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "chunk.h"
+#include "util/memory.h"
+#include "assert/assert.h"
+#include "world/world.h"
+
+void renderChunkUpdated(chunk_t *chunk);
+
+chunkmap_t CHUNK_MAP;
+
+void chunkMapInit() {
+  memoryZero(&CHUNK_MAP, sizeof(chunkmap_t));
+
+  // Load default chunks, YX order.
+  uint16_t i = 0;
+  chunk_t *chunk;
+  for(uint8_t y = 0; y < CHUNK_MAP_HEIGHT; y++) {
+    for(uint8_t x = 0; x < CHUNK_MAP_WIDTH; x++) {
+      assertTrue(i < CHUNK_MAP_COUNT, "Chunk index out of bounds");
+
+      chunk = CHUNK_MAP.chunks + i;
+      CHUNK_MAP.chunkOrder[i] = chunk;
+
+      chunkLoad(chunk, x, y);
+      assertTrue(
+        chunk->x == x && chunk->y == y,
+        "Chunk coordinates do not match expected values"
+      );
+
+      i++;
+    }
+  }
+}
+
+void chunkMapShift(const int16_t x, const int16_t y) {
+  if(x == 0 && y == 0) assertUnreachable("ChunkMapShift called with no shift");
+
+  chunk_t *newChunkOrder[CHUNK_MAP_COUNT];
+  chunk_t *unloadedChunks[CHUNK_MAP_COUNT];
+  chunk_t *chunk;
+  uint8_t i, j;
+  uint16_t
+    /** New Map Coordinates */
+    newX, newY,
+    newChunkX, newChunkY
+  ;
+
+  // Calculate the new map coordinates
+  newX = CHUNK_MAP.topLeftX + x;
+  newY = CHUNK_MAP.topLeftY + y;
+
+  // Zero the new chunk order
+  memoryZero(newChunkOrder, sizeof(newChunkOrder));
+
+  // For each chunk...
+  j = 0;
+  chunk = CHUNK_MAP.chunks;
+  do {
+    // Is this chunk still going to be within the map bounds?
+    if(
+      chunk->x < newX || chunk->y < newY ||
+      chunk->x >= newX + CHUNK_MAP_WIDTH ||
+      chunk->y >= newY + CHUNK_MAP_HEIGHT
+    ) {
+      // No, it's not, let's unload it and make it available for reuse.
+      chunkUnload(chunk);
+      assertTrue(
+        j < CHUNK_MAP_COUNT,
+        "Unloaded chunk index out of bounds"
+      );
+      unloadedChunks[j++] = chunk;
+      chunk++;
+      continue;
+    }
+
+    // Yes it is still valid, determine the new index that it will be at
+    i = (chunk->y - newY) * CHUNK_MAP_WIDTH + (chunk->x - newX);
+    assertTrue(
+      i < CHUNK_MAP_COUNT,
+      "Chunk index out of bounds after shifting"
+    );
+    assertNull(
+      newChunkOrder[i],
+      "New chunk order index is already occupied"
+    );
+
+    // Set the new chunk order
+    newChunkOrder[i] = chunk;
+    chunk++;
+  } while(chunk < CHUNK_MAP.chunks + CHUNK_MAP_COUNT);
+
+  // Now check the new chunk order list for missing chunks.
+  i = 0;
+  do {
+    assertTrue(
+      i < CHUNK_MAP_COUNT,
+      "New chunk order index out of bounds after shifting"
+    );
+
+    // Is this chunk loaded still?
+    chunk = newChunkOrder[i];
+    if(chunk != NULL) {
+      i++;
+      continue;
+    }
+    
+    // Determine the new chunk coordinates.
+    newChunkX = i % CHUNK_MAP_WIDTH + newX;
+    newChunkY = i / CHUNK_MAP_WIDTH + newY;
+    assertTrue(
+      newChunkX >= newX && newChunkX < newX + CHUNK_MAP_WIDTH,
+      "New chunk X coordinate out of bounds after shifting"
+    );
+    assertTrue(
+      newChunkY >= newY && newChunkY < newY + CHUNK_MAP_HEIGHT,
+      "New chunk Y coordinate out of bounds after shifting"
+    );
+
+    // Pop a chunk from the unloaded chunks list.
+    assertTrue(j > 0, "No unloaded chunks available to reuse");
+    chunk = unloadedChunks[--j];
+    assertNotNull(chunk, "Unloaded chunk pointer is null");
+
+    // Load the chunk at the new coordinates.
+    chunkLoad(chunk, newChunkX, newChunkY);
+    assertTrue(
+      chunk->x == newChunkX && chunk->y == newChunkY,
+      "Chunk coordinates do not match expected values after shifting"
+    );
+
+    // Set it in order.
+    newChunkOrder[i] = chunk;
+    i++;
+  } while(i < CHUNK_MAP_COUNT);
+
+  // Update Absolutes.
+  CHUNK_MAP.topLeftX = newX;
+  CHUNK_MAP.topLeftY = newY;
+
+  // Update the chunk order.
+  memoryCopy(
+    CHUNK_MAP.chunkOrder,
+    newChunkOrder,
+    sizeof(CHUNK_MAP.chunkOrder)
+  );
+}
+
+void chunkMapSetPosition(const uint16_t x, const uint16_t y) {
+  if(x == CHUNK_MAP.topLeftX && y == CHUNK_MAP.topLeftY) {
+    return;
+  }
+  
+  int16_t shiftX = x - CHUNK_MAP.topLeftX;
+  int16_t shiftY = y - CHUNK_MAP.topLeftY;
+
+  // Are we shifting the entire map?
+  if(
+    shiftX >= CHUNK_MAP_WIDTH || shiftX < -CHUNK_MAP_WIDTH ||
+    shiftY >= CHUNK_MAP_HEIGHT || shiftY < -CHUNK_MAP_HEIGHT
+  ) {
+    printf("Shifting chunk map to new position (%u, %u)\n", x, y);
+  }
+
+  // Shift the chunk map by the specified offsets.
+  chunkMapShift(shiftX, shiftY);
+}
+
+chunk_t * chunkGetChunkAt(const uint16_t chunkX, const uint16_t chunkY) {
+  assertTrue(
+    chunkX < WORLD_WIDTH && chunkY < WORLD_HEIGHT,
+    "Chunk coordinates out of bounds"
+  );
+  
+  chunk_t *chunk = CHUNK_MAP.chunks;
+  do {
+    if(chunk->x == chunkX && chunk->y == chunkY) return chunk;
+    chunk++;
+  } while(chunk < CHUNK_MAP.chunks + CHUNK_MAP_COUNT);
+  return NULL;
+}
+
+void chunkLoad(chunk_t *chunk, const uint16_t x, const uint16_t y) {
+  assertNotNull(chunk, "Chunk pointer is null");
+
+  // Zero out the chunk data.
+  memoryZero(chunk, sizeof(chunk_t));
+
+  // Set the chunk coordinates.
+  chunk->x = x;
+  chunk->y = y;
+
+  // Only load data if the chunk is within bounds.
+  if(x >= WORLD_WIDTH || y >= WORLD_HEIGHT) {
+    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->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->tilesBase,
+    chunkData->layerBase,
+    sizeof(chunk->tilesBase)
+  );
+  memoryCopy(
+    chunk->tilesBaseOverlay,
+    chunkData->layerBaseOverlay,
+    sizeof(chunk->tilesBaseOverlay)
+  );
+
+  // Load chunk entities
+  const entity_t *data;
+  entity_t *entity;
+  data = chunkData->entities;
+  while(data < chunkData->entities + CHUNK_ENTITY_COUNT_MAX) {
+    if(data->type == ENTITY_TYPE_NULL) break;
+
+    // Store that this chunk owns this entity ID.
+    chunk->entityIDs[chunk->entityCount++] = data->id;
+
+    // Check entity isn't loaded (still).
+    entity = ENTITIES;
+    do {
+      if(entity->type != ENTITY_TYPE_NULL && entity->id == data->id) break;
+      entity++;
+    } while(entity < ENTITIES + ENTITY_COUNT_MAX);
+
+    if(entity != ENTITIES + ENTITY_COUNT_MAX) {
+      // Entity is already loaded, skip it.
+      printf("Entity ID %u already loaded, skipping...\n", data->id);
+      data++;
+      continue;
+    }
+
+    // Find an empty entity slot.
+    entity = ENTITIES;
+    while(true) {
+      assertTrue(
+        entity < ENTITIES + ENTITY_COUNT_MAX,
+        "Out of available entities"
+      );
+
+      if(entity->type == ENTITY_TYPE_NULL) break;
+      entity++;
+    };
+
+    // Load this entity.
+    entityLoad(entity, data);
+    data++;
+  }
+
+  // Allow the rendering platform to know this chunk is loaded.
+  renderChunkUpdated(chunk);
+}
+
+void chunkUnload(chunk_t *chunk) {
+  uint8_t i;
+  entity_t *entity;
+  uint32_t id;
+  assertNotNull(chunk, "Chunk pointer is null");
+
+  // Iterate over each entity this chunk owns.
+  i = 0;
+  while(i < chunk->entityCount) {
+    id = chunk->entityIDs[i++];
+
+    // Now, do we need to unload this entity?
+    bool_t shouldUnload = false;
+
+    // Now, find the entity loaded with this ID. It should be impossible for 
+    // this entity to be unloaded (but may change in future).
+    entity = ENTITIES;
+    do {
+      if(entity->type != ENTITY_TYPE_NULL && entity->id == id) break;
+      entity++;
+    } while(entity < ENTITIES + ENTITY_COUNT_MAX);
+
+    assertTrue(
+      entity < ENTITIES + ENTITY_COUNT_MAX,
+      "Entity ID not found in ENTITIES array, cannot unload"
+    );
+
+    // If the entity is still within our chunk bounds, it's getting unloaded
+    if(
+      floorf(entity->x) >= chunk->x * CHUNK_WIDTH * TILE_WIDTH_HEIGHT &&
+      ceilf(entity->x) < (chunk->x + 1) * CHUNK_WIDTH * TILE_WIDTH_HEIGHT &&
+      floorf(entity->y) >= chunk->y * CHUNK_HEIGHT * TILE_WIDTH_HEIGHT &&
+      ceilf(entity->y) < (chunk->y + 1) * CHUNK_HEIGHT * TILE_WIDTH_HEIGHT
+    ) {
+      shouldUnload = true;
+    } else {
+      assertUnreachable(
+        "Entity has left its chunk bounds, we should not be unloading it but "
+        "I have yet to implement that properly. It will need to self-manage "
+        "its own unloading somehow, and also not be in a null chunk "
+        "when it does so."
+      );
+    }
+
+    // This entity is still in use, leave it loaded.
+    if(!shouldUnload) continue;
+
+    // NULL the entity type, effectively unloading it.
+    entity->type = ENTITY_TYPE_NULL;
+  }
+}

src/rpg/world/chunk.h

@@ -0,0 +1,84 @@
+/**
+ * Copyright (c) 2025 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "tile.h"
+#include "display/render.h"
+
+#define CHUNK_WIDTH 8
+#define CHUNK_HEIGHT 8
+#define CHUNK_TILE_COUNT (CHUNK_WIDTH * CHUNK_HEIGHT)
+#define CHUNK_ENTITY_COUNT_MAX 8
+
+#define CHUNK_MAP_WIDTH (((RENDER_WIDTH / TILE_WIDTH_HEIGHT)/CHUNK_WIDTH)+2)
+#define CHUNK_MAP_HEIGHT (((RENDER_HEIGHT / TILE_WIDTH_HEIGHT)/CHUNK_HEIGHT)+2)
+#define CHUNK_MAP_COUNT (CHUNK_MAP_WIDTH * CHUNK_MAP_HEIGHT)
+
+typedef struct {
+  uint16_t x, y;
+  tile_t tilesBase[CHUNK_TILE_COUNT];
+  tile_t tilesBaseOverlay[CHUNK_TILE_COUNT];
+  uint32_t entityIDs[CHUNK_ENTITY_COUNT_MAX];
+  uint8_t entityCount;
+} chunk_t;
+
+typedef struct {
+  chunk_t chunks[CHUNK_MAP_COUNT];
+  chunk_t *chunkOrder[CHUNK_MAP_COUNT];
+
+  uint16_t topLeftX;
+  uint16_t topLeftY;
+} chunkmap_t;
+
+extern chunkmap_t CHUNK_MAP;
+
+/**
+ * Initializes the chunk map.
+ */
+void chunkMapInit();
+
+/**
+ * Shifts the chunk map by the specified x and y offsets.
+ * 
+ * @param x The x offset to shift the chunk map.
+ * @param y The y offset to shift the chunk map.
+ */
+void chunkMapShift(const int16_t x, const int16_t y);
+
+/**
+ * Sets the position of the chunk map to the specified coordinates.
+ * 
+ * @param x The x coordinate of the top-left chunk.
+ * @param y The y coordinate of the top-left chunk.
+ */
+void chunkMapSetPosition(const uint16_t x, const uint16_t y);
+
+/**
+ * Gets the chunk at the specified chunk coordinates.
+ * 
+ * @param chunkX The x coordinate of the chunk.
+ * @param chunkY The y coordinate of the chunk.
+ * @return A pointer to the chunk at the specified chunk coordinates, or NULL if
+ *         no chunk exists at those coordinates.
+ */
+chunk_t * chunkGetChunkAt(const uint16_t chunkX, const uint16_t chunkY);
+
+/**
+ * Loads a chunk at the specified coordinates.
+ * 
+ * @param chunk The chunk to load.
+ * @param x The x coordinate of the chunk.
+ * @param y The y coordinate of the chunk.
+ */
+void chunkLoad(chunk_t *chunk, const uint16_t x, const uint16_t y);
+
+/**
+ * Unloads a chunk (that is currently loaded).
+ * 
+ * @param chunk The chunk to unload.
+ */
+void chunkUnload(chunk_t *chunk);

src/rpg/world/chunkdata.h

@@ -0,0 +1,16 @@
+/**
+ * Copyright (c) 2025 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "chunk.h"
+#include "entity/entity.h"
+
+typedef struct {
+  uint8_t layerBase[CHUNK_TILE_COUNT];
+  uint8_t layerBaseOverlay[CHUNK_TILE_COUNT];
+  entity_t entities[CHUNK_ENTITY_COUNT_MAX];
+} chunkdata_t;

src/rpg/world/overworld.c

@@ -0,0 +1,72 @@
+/**
+ * Copyright (c) 2025 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "overworld.h"
+#include "chunk.h"
+#include "display/render.h"
+#include "assert/assert.h"
+#include "entity/entity.h"
+
+uint32_t OVERWORLD_CAMERA_X;
+uint32_t OVERWORLD_CAMERA_Y;
+overworldcameratype_t OVERWORLD_CAMERA_TYPE;
+
+void overworldInit(void) {
+  playerInit();
+  chunkMapInit();
+
+  OVERWORLD_CAMERA_X = 0;
+  OVERWORLD_CAMERA_Y = 0;
+  OVERWORLD_CAMERA_TYPE = OVERWORLD_CAMERA_TYPE_CENTERED_POSITION;
+}
+
+void overworldUpdate() {
+  entity_t *entity;
+
+  assertTrue(
+    OVERWORLD_CAMERA_X < OVERWORLD_CAMERA_LIMIT_X,
+    "Camera position limit (just because I haven't tested properly)"
+  );
+  assertTrue(
+    OVERWORLD_CAMERA_Y < OVERWORLD_CAMERA_LIMIT_Y,
+    "Camera position limit (just because I haven't tested properly)"
+  );
+  
+  entity = ENTITIES;
+  do {
+    entityUpdate(entity++);
+  } while(entity->type != ENTITY_TYPE_NULL);
+
+  // Testing, follow player
+  entity = &ENTITIES[0]; // Player entity
+  assertTrue(
+    entity->type == ENTITY_TYPE_PLAYER,
+    "First entity must be player"
+  );
+  OVERWORLD_CAMERA_X = entity->x * TILE_WIDTH_HEIGHT + entity->subX;
+  OVERWORLD_CAMERA_Y = entity->y * TILE_WIDTH_HEIGHT + entity->subY;
+
+  uint16_t x, y;
+  uint16_t halfWidth, halfHeight;
+  halfWidth = ((CHUNK_MAP_WIDTH - 1) * CHUNK_WIDTH * TILE_WIDTH_HEIGHT) / 2;
+  halfHeight = ((CHUNK_MAP_HEIGHT - 1) * CHUNK_HEIGHT * TILE_WIDTH_HEIGHT) / 2;
+
+  // Calculate the chunk map position based on the camera position.
+  if(OVERWORLD_CAMERA_X < halfWidth) {
+    x = 0;
+  } else {
+    x = (OVERWORLD_CAMERA_X - halfWidth) / (CHUNK_WIDTH*TILE_WIDTH_HEIGHT);
+  }
+
+  if(OVERWORLD_CAMERA_Y < halfHeight) {
+    y = 0;
+  } else {
+    y = (OVERWORLD_CAMERA_Y - halfHeight) / (CHUNK_HEIGHT*TILE_WIDTH_HEIGHT);
+  }
+
+  chunkMapSetPosition(x, y);
+}

src/rpg/world/overworld.h

@@ -0,0 +1,30 @@
+/**
+ * Copyright (c) 2025 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "dusk.h"
+
+typedef enum {
+  OVERWORLD_CAMERA_TYPE_CENTERED_POSITION,
+} overworldcameratype_t;
+
+extern uint32_t OVERWORLD_CAMERA_X;
+extern uint32_t OVERWORLD_CAMERA_Y;
+extern overworldcameratype_t OVERWORLD_CAMERA_TYPE;
+
+#define OVERWORLD_CAMERA_LIMIT_X (UINT32_MAX / 4)
+#define OVERWORLD_CAMERA_LIMIT_Y (UINT32_MAX / 4)
+
+/**
+ * Initializes the overworld.
+ */
+void overworldInit(void);
+
+/**
+ * Updates the overworld.
+ */
+void overworldUpdate(void);

src/rpg/world/tile.h

@@ -0,0 +1,26 @@
+/**
+ * Copyright (c) 2025 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "dusk.h"
+
+#define TILE_WIDTH_HEIGHT 16
+
+typedef uint8_t tile_t;
+
+typedef enum {
+  TILE_SOLID_NONE = 0,
+  TILE_SOLID_FULL = 1,
+  TILE_SOLID_TRIANGLE_TOP_RIGHT = 2,
+  TILE_SOLID_TRIANGLE_TOP_LEFT = 3,
+  TILE_SOLID_TRIANGLE_BOTTOM_RIGHT = 4,
+  TILE_SOLID_TRIANGLE_BOTTOM_LEFT = 5,
+} tilesolidtype_t;
+
+typedef struct {
+  tilesolidtype_t solidType;
+} tilemetadata_t;