Add inventory.

archive/rpg/overworld/map.c

@@ -0,0 +1,269 @@
+/**
+ * Copyright (c) 2025 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "map.h"
+#include "util/memory.h"
+#include "assert/assert.h"
+#include "asset/asset.h"
+#include "rpg/entity/entity.h"
+#include "util/string.h"
+#include "script/scriptcontext.h"
+
+map_t MAP;
+
+errorret_t mapInit() {
+  memoryZero(&MAP, sizeof(map_t));
+  errorOk();
+}
+
+bool_t mapIsLoaded() {
+  return MAP.filePath[0] != '\0';
+}
+
+errorret_t mapLoad(const char_t *path, const chunkpos_t position) {
+  assertStrLenMin(path, 1, "Map file path cannot be empty");
+  assertStrLenMax(path, MAP_FILE_PATH_MAX - 1, "Map file path too long");
+
+  if(stringCompare(MAP.filePath, path) == 0) {
+    // Same map, no need to reload
+    errorOk();
+  }
+
+  chunkindex_t i;
+  
+  // Unload all loaded chunks
+  if(mapIsLoaded()) {
+    for(i = 0; i < MAP_CHUNK_COUNT; i++) {
+      mapChunkUnload(&MAP.chunks[i]);
+    }
+  }
+
+  // Store the map file path
+  stringCopy(MAP.filePath, path, MAP_FILE_PATH_MAX);
+
+  // Determine directory path (it is dirname)
+  stringCopy(MAP.dirPath, path, MAP_FILE_PATH_MAX);
+  char_t *last = stringFindLastChar(MAP.dirPath, '/');
+  if(last == NULL) errorThrow("Invalid map file path");
+
+  // Store filename, sans extension
+  stringCopy(MAP.fileName, last + 1, MAP_FILE_PATH_MAX);
+  *last = '\0'; // Terminate to get directory path
+
+  last = stringFindLastChar(MAP.fileName, '.');
+  if(last == NULL) errorThrow("Map file name has no extension");
+  *last = '\0'; // Terminate to remove extension
+
+  // Reset map position
+  MAP.chunkPosition = position;
+
+  // Perform "initial load"
+  i = 0;
+  for(chunkunit_t z = 0; z < MAP_CHUNK_DEPTH; z++) {
+    for(chunkunit_t y = 0; y < MAP_CHUNK_HEIGHT; y++) {
+      for(chunkunit_t x = 0; x < MAP_CHUNK_WIDTH; x++) {
+        chunk_t *chunk = &MAP.chunks[i];
+        chunk->position.x = x + position.x;
+        chunk->position.y = y + position.y;
+        chunk->position.z = z + position.z;
+        MAP.chunkOrder[i] = chunk;
+        errorChain(mapChunkLoad(chunk));
+        i++;
+      }
+    }
+  }
+
+  // Execute map script.
+  char_t scriptPath[MAP_FILE_PATH_MAX + 16];
+  stringFormat(
+    scriptPath, sizeof(scriptPath), "%s/%s.dsf",
+    MAP.dirPath, MAP.fileName
+  );
+  if(assetFileExists(scriptPath)) {
+    scriptcontext_t ctx;
+    errorChain(scriptContextInit(&ctx));
+    errorChain(scriptContextExecFile(&ctx, scriptPath));
+    scriptContextDispose(&ctx);
+  }
+
+  errorOk();
+}
+
+errorret_t mapPositionSet(const chunkpos_t newPos) {
+  if(!mapIsLoaded()) errorThrow("No map loaded");
+
+  const chunkpos_t curPos = MAP.chunkPosition;
+  if(chunkPositionIsEqual(curPos, newPos)) {
+    errorOk();
+  }
+
+  // Determine which chunks remain loaded
+  chunkindex_t chunksRemaining[MAP_CHUNK_COUNT] = {0};
+  chunkindex_t chunksFreed[MAP_CHUNK_COUNT] = {0};
+
+  uint32_t remainingCount = 0;
+  uint32_t freedCount = 0;
+
+  for(chunkindex_t i = 0; i < MAP_CHUNK_COUNT; i++) {
+    // Will this chunk remain loaded?
+    chunk_t *chunk = &MAP.chunks[i];
+    if(
+      chunk->position.x >= newPos.x &&
+      chunk->position.x < newPos.x + MAP_CHUNK_WIDTH &&
+
+      chunk->position.y >= newPos.y &&
+      chunk->position.y < newPos.y + MAP_CHUNK_HEIGHT &&
+
+      chunk->position.z >= newPos.z &&
+      chunk->position.z < newPos.z + MAP_CHUNK_DEPTH
+    ) {
+      // Stays loaded
+      chunksRemaining[remainingCount++] = i;
+      continue;
+    }
+
+    // Not remaining loaded
+    chunksFreed[freedCount++] = i;
+  }
+
+  // Unload the freed chunks
+  for(chunkindex_t i = 0; i < freedCount; i++) {
+    chunk_t *chunk = &MAP.chunks[chunksFreed[i]];
+    mapChunkUnload(chunk);
+  }
+
+  // This can probably be optimized later, for now we check each chunk and see
+  // if it needs loading or not, and update the chunk order
+  chunkindex_t orderIndex = 0;
+  for(chunkunit_t zOff = 0; zOff < MAP_CHUNK_DEPTH; zOff++) {
+    for(chunkunit_t yOff = 0; yOff < MAP_CHUNK_HEIGHT; yOff++) {
+      for(chunkunit_t xOff = 0; xOff < MAP_CHUNK_WIDTH; xOff++) {
+        const chunkpos_t newChunkPos = {
+          newPos.x + xOff, newPos.y + yOff, newPos.z + zOff
+        };
+        
+        // Is this chunk already loaded (was not unloaded earlier)?
+        chunkindex_t chunkIndex = -1;
+        for(chunkindex_t i = 0; i < remainingCount; i++) {
+          chunk_t *chunk = &MAP.chunks[chunksRemaining[i]];
+          if(!chunkPositionIsEqual(chunk->position, newChunkPos)) continue;
+          chunkIndex = chunksRemaining[i];
+          break;
+        }
+
+        // Need to load this chunk
+        if(chunkIndex == -1) {
+          // Find a freed chunk to reuse
+          chunkIndex = chunksFreed[--freedCount];
+          chunk_t *chunk = &MAP.chunks[chunkIndex];
+          chunk->position = newChunkPos;
+          errorChain(mapChunkLoad(chunk));
+        }
+
+        MAP.chunkOrder[orderIndex++] = &MAP.chunks[chunkIndex];
+      }
+    }
+  }
+
+  // Update map position
+  MAP.chunkPosition = newPos;
+
+  errorOk();
+}
+
+void mapUpdate() {
+  
+}
+
+void mapDispose() {
+  for(chunkindex_t i = 0; i < MAP_CHUNK_COUNT; i++) {
+    mapChunkUnload(&MAP.chunks[i]);
+  }
+}
+
+void mapChunkUnload(chunk_t* chunk) {
+  for(uint8_t i = 0; i < CHUNK_ENTITY_COUNT_MAX; i++) {
+    if(chunk->entities[i] == 0xFF) break;
+    entity_t *entity = &ENTITIES[chunk->entities[i]];
+    entity->type = ENTITY_TYPE_NULL;
+  }
+
+  for(uint8_t i = 0; i < chunk->meshCount; i++) {
+    if(chunk->meshes[i].vertexCount == 0) continue;
+    meshDispose(&chunk->meshes[i]);
+  }
+}
+
+errorret_t mapChunkLoad(chunk_t* chunk) {
+  if(!mapIsLoaded()) errorThrow("No map loaded");
+
+  char_t buffer[64];
+
+  // TODO: Can probably move this to asset load logic?
+  chunk->meshCount = 0;
+  memoryZero(chunk->meshes, sizeof(chunk->meshes));
+  memorySet(chunk->entities, 0xFF, sizeof(chunk->entities));
+
+  // Get chunk filepath.
+  snprintf(buffer, sizeof(buffer), "%s/chunks/%d_%d_%d.dcf",
+    MAP.dirPath,
+    chunk->position.x,
+    chunk->position.y,
+    chunk->position.z
+  );
+
+  // Chunk available?
+  if(!assetFileExists(buffer)) {
+    memoryZero(chunk->tiles, sizeof(chunk->tiles));
+    errorOk();
+  }
+
+  // Load.
+  errorChain(assetLoad(buffer, chunk));
+  errorOk();
+}
+
+chunkindex_t mapGetChunkIndexAt(const chunkpos_t position) {
+  if(!mapIsLoaded()) return -1;
+
+  chunkpos_t relPos = {
+    position.x - MAP.chunkPosition.x,
+    position.y - MAP.chunkPosition.y,
+    position.z - MAP.chunkPosition.z
+  };
+
+  if(
+    relPos.x < 0 || relPos.y < 0 || relPos.z < 0 ||
+    relPos.x >= MAP_CHUNK_WIDTH ||
+    relPos.y >= MAP_CHUNK_HEIGHT ||
+    relPos.z >= MAP_CHUNK_DEPTH
+  ) {
+    return -1;
+  }
+
+  return chunkPosToIndex(&relPos);
+}
+
+chunk_t* mapGetChunk(const uint8_t index) {
+  if(index >= MAP_CHUNK_COUNT) return NULL;
+  if(!mapIsLoaded()) return NULL;
+  return MAP.chunkOrder[index];
+}
+
+tile_t mapGetTile(const worldpos_t position) {
+  if(!mapIsLoaded()) return TILE_SHAPE_NULL;
+
+  chunkpos_t chunkPos;
+  worldPosToChunkPos(&position, &chunkPos);
+  chunkindex_t chunkIndex = mapGetChunkIndexAt(chunkPos);
+  if(chunkIndex == -1) return TILE_SHAPE_NULL;
+
+  chunk_t *chunk = mapGetChunk(chunkIndex);
+  assertNotNull(chunk, "Chunk pointer cannot be NULL");
+  chunktileindex_t tileIndex = worldPosToChunkTileIndex(&position);
+  return chunk->tiles[tileIndex];
+}