Made a big mess of the codebase
This commit is contained in:
321
src/rpg/world/chunk.c
Normal file
321
src/rpg/world/chunk.c
Normal file
@@ -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;
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user