KlemenPl/PixelDefense
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Overhaul tilemap, add building ownership layer

Browse Source
This commit is contained in:
Klemen Plestenjak
2023-11-09 15:46:35 +01:00
parent dd96b23d32
commit f32c19dc3d
15 changed files with 324 additions and 103 deletions
Download Patch File Download Diff File Expand all files Collapse all files

141
engine/breeze/map/map.c
View File

@@ -1,5 +1,6 @@
#include "map.h"
#include "../core/logger.h"
#include "../core/memory.h"
#include "../math/vec2i.h"
@@ -8,6 +9,15 @@
BzTileMap BZ_TILEMAP_INVALID = {.isValid = false};
bool bzTileLayerClear(BzTileLayer *layer, BzTile *data, i32 dataCount) {
return true;
}
bool bzTileObjectsClear(BzTileObjectGroup *objectGroup, BzTileObject *objects, i32 objectCount) {
return true;
}
BzTileLayerFunc BZ_TILE_LAYER_CLEAR = bzTileLayerClear;
BzTileObjectsFunc BZ_TILE_OBJECTS_CLEAR = bzTileObjectsClear;
int16_t bzTileLayerGetTile(BzTileLayer *layer, i32 x, i32 y) {
return layer->data[layer->width * y + x];
@@ -19,9 +29,9 @@ static void handleTileLayer(BzTileLayer *layer, cute_tiled_layer_t *cuteLayer) {
layer->data = NULL;
if (layer->dataCount > 0) {
layer->data = bzAlloc(layer->dataCount * sizeof(*layer->data));
layer->minData = layer->maxData = (i16) cuteLayer->data[0];
layer->minData = layer->maxData = (BzTile) cuteLayer->data[0];
for (i32 i = 0; i < layer->dataCount; i++) {
layer->data[i] = (i16) cuteLayer->data[i];
layer->data[i] = (BzTile) cuteLayer->data[i];
if (layer->data[i] < layer->minData)
layer->minData = layer->data[i];
else if (layer->data[i] > layer->maxData)
@@ -41,7 +51,7 @@ static void handleTileLayer(BzTileLayer *layer, cute_tiled_layer_t *cuteLayer) {
// tileset.c
BzTileShape bzCuteObjectToTileShape(cute_tiled_object_t *object);
static void handleTileObjectLayer(BzTileObjectLayer *layer, cute_tiled_layer_t *cuteLayer,
static void handleTileObjectLayer(BzTileObjectGroup *layer, cute_tiled_layer_t *cuteLayer,
BzStringHashFunc hashFunc) {
// Count objects
layer->objectCount = 0;
@@ -61,12 +71,9 @@ static void handleTileObjectLayer(BzTileObjectLayer *layer, cute_tiled_layer_t *
}
static void createColliders(BzTileMap *map) {
map->collidersCount = map->width * map->height;
map->colliderMap = bzAlloc(map->collidersCount * sizeof(*map->colliderMap));
for (i32 i = 0; i < map->collidersCount; i++) {
map->colliderMap[i] = (BzTileCollider) {{BZ_TILE_SHAPE_NONE}};
}
static void updateColliders(BzTileMap *map, i32 startX, i32 startY, i32 endX, i32 endY) {
BZ_ASSERT(startX >= 0 && endX <= map->width &&
startY >= 0 && endY <= map->height);
// Top-most layer takes priority
for (i32 i = map->layerCount - 1; i >= 0; i--) {
@@ -74,8 +81,8 @@ static void createColliders(BzTileMap *map) {
if (!layer->data) continue;
if (layer->tilesetIdx == -1) continue;
BzTileset *tileset = map->tilesets + layer->tilesetIdx;
for (i32 y = 0; y < map->height; y++) {
for (i32 x = 0; x < map->width; x++) {
for (i32 y = startY; y < endY; y++) {
for (i32 x = startX; x < endX; x++) {
i32 tile = bzTileLayerGetTile(layer, x, y);
BzTileShape tilesetShape = bzTilesetGetTileCollider(tileset, tile);
if (tilesetShape.type == BZ_TILE_SHAPE_NONE ||
@@ -99,6 +106,16 @@ static void createColliders(BzTileMap *map) {
}
}
static void createColliders(BzTileMap *map) {
map->collidersCount = map->width * map->height;
map->colliderMap = bzAlloc(map->collidersCount * sizeof(*map->colliderMap));
for (i32 i = 0; i < map->collidersCount; i++) {
map->colliderMap[i] = (BzTileCollider) {{BZ_TILE_SHAPE_NONE}};
}
updateColliders(map, 0, 0, map->width, map->height);
}
BzTileMap bzTileMapCreate(const BzTileMapDesc *desc) {
BzTileMap map = {};
// Auto detect tileset count.
@@ -123,13 +140,13 @@ BzTileMap bzTileMapCreate(const BzTileMapDesc *desc) {
cute_tiled_layer_t *cuteLayer = cuteMap->layers;
while (cuteLayer) {
BZ_ASSERT(map.layerCount < BZ_MAX_MAP_LAYERS);
BZ_ASSERT(map.objectLayerCount < BZ_MAX_MAP_LAYERS);
BZ_ASSERT(map.objectGroupCount < BZ_MAX_MAP_LAYERS);
// Find slot
i32 slot = -1;
for (i32 i = 0; i < BZ_MAX_MAP_LAYERS; i++) {
const BzTileLayerDesc *layerDesc = desc->layers + i;
const BzTileObjectsDesc *objectsDesc = desc->objectLayers + i;
const BzTileObjectsDesc *objectsDesc = desc->objectGroups + i;
if (layerDesc->name && strcmp(layerDesc->name, cuteLayer->name.ptr) == 0 ||
objectsDesc->name && strcmp(objectsDesc->name, cuteLayer->name.ptr) == 0) {
slot = i;
@@ -139,33 +156,25 @@ BzTileMap bzTileMapCreate(const BzTileMapDesc *desc) {
}
}
if (slot == -1) {
bzLogWarning("Dangling layer: %s", cuteLayer->name.ptr);
cuteLayer = cuteLayer->next;
continue;
}
if (cuteLayer->data) {
BzTileLayer *layer = map.layers + slot;
const BzTileLayerDesc *layerDesc = desc->layers + slot;
layer->desc = desc->layers[slot];
handleTileLayer(layer, cuteLayer);
if (layerDesc->handler && !layerDesc->handler(layer)) {
bzFree(layer->data);
layer->data = NULL;
layer->dataCount = 0;
}
layer->hasOwnership = true;
map.layerCount++;
} else {
BzTileObjectLayer *objectLayer = map.objectLayers + slot;
const BzTileObjectsDesc *objectLayerDesc = desc->objectLayers + slot;
BzStringHashFunc *hashFunc = objectLayerDesc->hashFunc;
if (!hashFunc)
hashFunc = bzStringDefaultHash;
handleTileObjectLayer(objectLayer, cuteLayer, hashFunc);
if (objectLayerDesc->handler && !objectLayerDesc->handler(objectLayer)) {
bzFree(objectLayer->objects);
objectLayer->objects = NULL;
objectLayer->objectCount = 0;
}
map.objectLayerCount++;
BzTileObjectGroup *objectGroup = map.objectGroups + slot;
objectGroup->desc = desc->objectGroups[slot];
if (!objectGroup->desc.hashFunc)
objectGroup->desc.hashFunc = bzStringDefaultHash;
handleTileObjectLayer(objectGroup, cuteLayer, objectGroup->desc.hashFunc);
map.objectGroupCount++;
}
cuteLayer = cuteLayer->next;
@@ -197,7 +206,6 @@ BzTileMap bzTileMapCreate(const BzTileMapDesc *desc) {
}
}
}
cute_tiled_free_map(cuteMap);
createColliders(&map);
@@ -206,28 +214,62 @@ BzTileMap bzTileMapCreate(const BzTileMapDesc *desc) {
return map;
}
void bzTileMapDestroy(BzTileMap *tilemap) {
for (i32 i = 0; i < tilemap->layerCount; i++) {
BzTileLayer *layer = tilemap->layers + i;
if (layer->data) {
void bzTileMapDestroy(BzTileMap *map) {
for (i32 i = 0; i < map->layerCount; i++) {
BzTileLayer *layer = map->layers + i;
if (layer->hasOwnership && layer->data) {
bzFree(layer->data);
layer->data = NULL;
layer->dataCount = 0;
}
}
for (i32 i = 0; i < tilemap->objectLayerCount; i++) {
BzTileObjectLayer *objectLayer = tilemap->objectLayers + i;
if (objectLayer->objects) {
for (i32 i = 0; i < map->objectGroupCount; i++) {
BzTileObjectGroup *objectLayer = map->objectGroups + i;
if (objectLayer->hasOwnership && objectLayer->objects) {
bzFree(objectLayer->objects);
objectLayer->objects = NULL;
objectLayer->objectCount = 0;
}
}
bzFree(tilemap->colliderMap);
tilemap->collidersCount = 0;
bzFree(map->colliderMap);
map->collidersCount = 0;
*tilemap = BZ_TILEMAP_INVALID;
*map = BZ_TILEMAP_INVALID;
}
void bzTileMapOverrideLayer(BzTileMap *map, i32 slotID, BzTileLayerFunc func) {
BZ_ASSERT(slotID >= 0 && slotID < map->layerCount);
BzTileLayer *layer = map->layers + slotID;
i32 dataCount = layer->dataCount;
BzTile *data = layer->data;
if (func(layer, data, dataCount)) {
if (!layer->hasOwnership) return;
bzFree(layer->data);
if (layer->data == data) {
layer->data = NULL;
layer->dataCount = 0;
}
layer->hasOwnership = false;
} else {
BZ_ASSERT(data == layer->data && dataCount == layer->dataCount);
}
}
void bzTileMapOverrideObjectGroup(BzTileMap *map, i32 slotID, BzTileObjectsFunc func) {
BZ_ASSERT(slotID >= 0 && slotID < map->objectGroupCount);
BzTileObjectGroup *objectGroup = map->objectGroups + slotID;
BzTileObject *objects = objectGroup->objects;
i32 objectCount = objectGroup->objectCount;
if (func(objectGroup, objects, objectCount)) {
bzFree(objectGroup->objects);
if (objectGroup->objects == objects) {
objectGroup->objects = NULL;
objectGroup->objectCount = 0;
}
objectGroup->hasOwnership = false;
} else {
BZ_ASSERT(objects == objectGroup->objects && objectCount == objectGroup->objectCount);
}
}
@@ -238,7 +280,7 @@ static void drawLayer(BzTileLayer *layer, BzTileset *tileset) {
for (i32 y = 0; y < layer->height; y++) {
for (i32 x = 0; x < layer->width; x++) {
i16 tile = bzTileLayerGetTile(layer, x, y);
BzTile tile = bzTileLayerGetTile(layer, x, y);
if (tile - tileset->startID != -1) {
Rectangle rec = bzTilesetGetTileRegion(tileset, tile);
DrawTextureRec(tileset->tiles, rec, drawPos, WHITE);
@@ -251,7 +293,7 @@ static void drawLayer(BzTileLayer *layer, BzTileset *tileset) {
}
static void drawObjectLayer(BzTileObjectLayer *objectLayer) {
static void drawObjectLayer(BzTileObjectGroup *objectLayer) {
Color color = ORANGE;
for (int i = 0; i < objectLayer->objectCount; i++) {
BzTileShape shape = objectLayer->objects[i].shape;
@@ -282,8 +324,8 @@ void bzTileMapDraw(BzTileMap *map) {
drawLayer(map->layers + i, tileset);
}
for (i32 i = 0; i < map->objectLayerCount; i++) {
BzTileObjectLayer *objectLayer = map->objectLayers + i;
for (i32 i = 0; i < map->objectGroupCount; i++) {
BzTileObjectGroup *objectLayer = map->objectGroups + i;
if (!objectLayer->objects) continue;
drawObjectLayer(objectLayer);
}
@@ -324,6 +366,13 @@ void bzTileMapDrawColliders(BzTileMap *map) {
}
}
void bzTileMapUpdateCollider(BzTileMap *map, i32 x, i32 y) {
i32 idx = y * map->width + x;
BZ_ASSERT(idx >= 0 && idx < map->collidersCount);
map->colliderMap[idx] = (BzTileCollider){};
updateColliders(map, x, y, x + 1, y + 1);
}
BzTileCollider bzTileMapGetCollider(BzTileMap *map, i32 x, i32 y) {
i32 idx = y * map->width + x;
if (idx < 0 || idx >= map->collidersCount) {