Separate object layers, asign layers to proper slots

engine/CMakeLists.txt

@@ -3,6 +3,8 @@ project(Breeze C)
 
 set(CMAKE_C_STANDARD 11)
 
+add_compile_definitions(DEBUG_MODE)
+
 set(BUILD_EXAMPLES false)
 add_subdirectory(libs/raylib-4.5.0)
 
@@ -38,6 +40,7 @@ set(BreezeHeaders
 
         breeze/math/vec2i.h
 
+        breeze/utils/string.h
         breeze/utils/tokenizer.h
 
         breeze/world/map.h

engine/breeze.h

@@ -6,6 +6,7 @@
 
 #include "breeze/math/vec2i.h"
 
+#include "breeze/utils/string.h"
 #include "breeze/utils/tokenizer.h"
 
 #include "breeze/world/map.h"

engine/breeze/utils/string.h

@@ -0,0 +1,20 @@
+#ifndef BREEZE_STRING_H
+#define BREEZE_STRING_H
+
+#include "../defines.h"
+
+typedef u32 BzStringHashFunc(const char *str);
+
+// djb2 hash algorithm
+// From: https://stackoverflow.com/questions/7666509/hash-function-for-string
+//       http://www.cse.yorku.ca/~oz/hash.html
+static u32 bzStringDefaultHash(const char *str) {
+    u32 hash = 5381;
+    int c;
+    while ((c = (int) *str++)) {
+        hash = ((hash << 5) + hash) + c; /* hash + 33 + c */
+    }
+    return hash;
+}
+
+#endif //BREEZE_STRING_H

engine/breeze/world/map.c

@@ -4,6 +4,7 @@
 #include "../math/vec2i.h"
 
 #include <cute_tiled.h>
+#include <string.h>
 
 BzTileMap BZ_TILEMAP_INVALID = {.isValid = false};
 
@@ -12,38 +13,8 @@ int16_t bzTileLayerGetTile(BzTileLayer *layer, i32 x, i32 y) {
     return layer->data[layer->width * y + x];
 }
 
-BzTileMap bzTileMapCreate(const BzTileMapDesc *desc) {
+static void handleTileLayer(BzTileLayer *layer, cute_tiled_layer_t *cuteLayer) {
-    BzTileMap map = {};
-    i32 tilesetCount = desc->tilesetCount;
-    if (tilesetCount == 0) {
-        // Auto detect tileset count.
-        for (i32 i = 0; i < BZ_MAX_MAP_TILESETS; i++) {
-            if (!desc->tilesets[i].isValid)
-                break;
-            tilesetCount++;
-        }
-    }
-    map.tilesetCount = tilesetCount;
-    for (i32 i = 0; i < map.tilesetCount; i++) {
-        map.tilesets[i] = desc->tilesets[i];
-    }
-
-    cute_tiled_map_t *cuteMap = cute_tiled_load_map_from_file(desc->path, NULL);
-
-    map.backgroundColor = GetColor(cuteMap->backgroundcolor);
-
-    map.width = cuteMap->width;
-    map.height = cuteMap->height;
-    map.tileWidth = cuteMap->tilewidth;
-    map.tileHeight = cuteMap->tileheight;
-
-    cute_tiled_layer_t *cuteLayer = cuteMap->layers;
-    while (cuteLayer) {
-        BZ_ASSERT(map.layerCount < BZ_MAX_MAP_LAYERS);
-
-        BzTileLayer *layer = map.layers + map.layerCount;
     layer->id = cuteLayer->id;
-
     layer->dataCount = cuteLayer->data_count;
     layer->data = NULL;
     if (layer->dataCount > 0) {
@@ -65,13 +36,107 @@ BzTileMap bzTileMapCreate(const BzTileMapDesc *desc) {
     layer->offsetY = cuteLayer->offsety;
     layer->opacity = cuteLayer->opacity;
 
+}
+
+// tileset.c
+BzTileShape bzCuteObjectToTileShape(cute_tiled_object_t *object);
+
+static void handleTileObjectLayer(BzTileObjectLayer *layer, cute_tiled_layer_t *cuteLayer,
+                                  BzStringHashFunc hashFunc) {
+    // Count objects
+    layer->objectCount = 0;
+    cute_tiled_object_t *object = cuteLayer->objects;
+    while (object) {
+        layer->objectCount++;
+        object = object->next;
+    }
+
+    layer->objects = bzAlloc(layer->objectCount * sizeof(*layer->objects));
+    object = cuteLayer->objects;
+    for (i32 i = 0; i < layer->objectCount; i++) {
+        layer->objects[i].id = hashFunc(object->name.ptr);
+        layer->objects[i].shape = bzCuteObjectToTileShape(object);
+        object = object->next;
+    }
+
+}
+
+static i32 findSlot(const char *name, const BzTileLayerDesc desc[BZ_MAX_MAP_LAYERS]) {
+    for (i32 i = 0; i < BZ_MAX_MAP_LAYERS; i++) {
+        if (!desc[i].name) break;
+        if (strcmp(name, desc[i].name) == 0) return i;
+    }
+
+    return -1;
+}
+
+BzTileMap bzTileMapCreate(const BzTileMapDesc *desc) {
+    BzTileMap map = {};
+    // Auto detect tileset count.
+    for (i32 i = 0; i < BZ_MAX_MAP_TILESETS; i++) {
+        if (!desc->tilesets[i].isValid)
+            break;
+        map.tilesetCount++;
+    }
+    for (i32 i = 0; i < map.tilesetCount; i++) {
+        map.tilesets[i] = desc->tilesets[i];
+    }
+
+    cute_tiled_map_t *cuteMap = cute_tiled_load_map_from_file(desc->path, NULL);
+
+    map.backgroundColor = GetColor(cuteMap->backgroundcolor);
+
+    map.width = cuteMap->width;
+    map.height = cuteMap->height;
+    map.tileWidth = cuteMap->tilewidth;
+    map.tileHeight = cuteMap->tileheight;
+
+    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);
+
+        // 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;
+            if (layerDesc->name && strcmp(layerDesc->name, cuteLayer->name.ptr) == 0 ||
+                objectsDesc->name && strcmp(objectsDesc->name, cuteLayer->name.ptr) == 0) {
+                slot = i;
+                break;
+            } else if (!layerDesc->name && !objectsDesc->name) {
+                break;
+            }
+        }
+        if (slot == -1) {
+            cuteLayer = cuteLayer->next;
+            continue;
+        }
+
+        if (cuteLayer->data) {
+            BzTileLayer *layer = map.layers + slot;
+            const BzTileLayerDesc *layerDesc = desc->layers + slot;
+            handleTileLayer(layer, cuteLayer);
+            if (layerDesc->handler) layerDesc->handler(layer);
             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);
+            map.objectLayerCount++;
+        }
+
         cuteLayer = cuteLayer->next;
     }
 
     cute_tiled_tileset_t *cuteTileset = cuteMap->tilesets;
-    tilesetCount = 0;
+    int tilesetCount = 0;
-    while ((cuteTileset = cuteTileset->next)) tilesetCount++;
+    for (; cuteTileset; cuteTileset = cuteTileset->next) tilesetCount++;
     BZ_ASSERT(tilesetCount == map.tilesetCount);
 
     cuteTileset = cuteMap->tilesets;
@@ -155,8 +220,8 @@ bool bzTileMapCanPlace(BzTileMap *map, i32 tileX, i32 tileY, i32 sizeX, i32 size
                 BzTileset *tileset = map->tilesets + layer->tilesetIdx;
 
                 i16 tile = bzTileLayerGetTile(layer, x, y);
-                BzTileCollider collider = bzTilesetGetTileCollider(tileset, tile);
+                BzTileShape collider = bzTilesetGetTileCollider(tileset, tile);
-                if (collider.type != BZ_TILE_COLLIDER_NONE)
+                if (collider.type != BZ_TILE_SHAPE_NONE)
                     return false;
             }
         }

engine/breeze/world/map.h

@@ -2,8 +2,9 @@
 #define BREEZE_MAP_H
 
 #include "tileset.h"
+#include "../utils/string.h"
 
-#define BZ_MAX_MAP_LAYERS 16
+#define BZ_MAX_MAP_LAYERS 8
 #define BZ_MAX_MAP_TILESETS 8
 
 
@@ -25,11 +26,36 @@ typedef struct BzTileLayer {
     i32 tilesetIdx;
 } BzTileLayer;
 
+typedef struct BzTileObject {
+    u32 id;
+    BzTileShape shape;
+} BzTileObject;
+
+typedef struct BzTileObjectLayer {
+    BzTileObject *objects;
+    i32 objectCount;
+} BzTileObjectLayer;
+
+// Return true, if it should be added to map
+typedef bool BzTileLayerHandler(BzTileLayer *layer);
+typedef bool BzTileObjectsHandler(BzTileObjectLayer *objectLayer);
+
+typedef struct BzTileLayerDesc {
+    const char *name; // Matches map layer names
+    BzTileLayerHandler *handler;
+} BzTileLayerDesc;
+typedef struct BzTileObjectsDesc {
+    const char *name; // Matches map layer names
+    BzTileObjectsHandler *handler;
+    BzStringHashFunc *hashFunc;
+} BzTileObjectsDesc;
 
 typedef struct BzTileMapDesc {
     const char *path;
     BzTileset tilesets[BZ_MAX_MAP_TILESETS];
-    i32 tilesetCount;
+
+    BzTileLayerDesc layers[BZ_MAX_MAP_LAYERS];
+    BzTileObjectsDesc objectLayers[BZ_MAX_MAP_LAYERS];
 } BzTileMapDesc;
 
 typedef struct BzTileMap {
@@ -43,6 +69,9 @@ typedef struct BzTileMap {
     BzTileLayer layers[BZ_MAX_MAP_LAYERS];
     i32 layerCount;
 
+    BzTileObjectLayer objectLayers[BZ_MAX_MAP_LAYERS];
+    i32 objectLayerCount;
+
     BzTileset tilesets[BZ_MAX_MAP_TILESETS];
     i32 tilesetCount;
 

engine/breeze/world/tileset.c

@@ -6,6 +6,25 @@
 
 BzTileset BZ_TILESET_INVALID = {.isValid = false};
 
+BzTileShape bzCuteObjectToTileShape(cute_tiled_object_t *object) {
+    BzTileShape shape = {BZ_TILE_SHAPE_NONE};
+    if (object->ellipse)
+        shape.type = BZ_TILE_SHAPE_ELLIPSE;
+    else if (object->point)
+        shape.type = BZ_TILE_SHAPE_POINT;
+    else if (!object->vertices)
+        shape.type = BZ_TILE_SHAPE_RECT;
+    else
+        return shape;
+
+    shape.x = object->x;
+    shape.y = object->y;
+    shape.sizeX = object->width;
+    shape.sizeY = object->height;
+
+    return shape;
+}
+
 BzTileset bzTilesetCreate(const BzTilesetDesc *desc) {
     BzTileset tileset = {};
     cute_tiled_tileset_t *cuteTileset = cute_tiled_load_external_tileset(desc->path, NULL);
@@ -24,7 +43,7 @@ BzTileset bzTilesetCreate(const BzTilesetDesc *desc) {
     tileset.tileCount = tileset.width * tileset.tileHeight;
     tileset.tileColliders = bzAlloc(tileset.tileCount * sizeof(*tileset.tileColliders));
     for (i32 i = 0; i < tileset.tileCount; i++) {
-        tileset.tileColliders[i] = (BzTileCollider) {BZ_TILE_COLLIDER_NONE};
+        tileset.tileColliders[i] = (BzTileShape) {BZ_TILE_SHAPE_NONE};
     }
 
     cute_tiled_tile_descriptor_t *cuteTile = cuteTileset->tiles;
@@ -34,14 +53,7 @@ BzTileset bzTilesetCreate(const BzTilesetDesc *desc) {
         // NOTE: Only supporting single collider (integer values)
         if (cuteObject) {
 
-            BzTileCollider collider = {BZ_TILE_COLLIDER_RECT};
+            BzTileShape collider = bzCuteObjectToTileShape(cuteObject);
-            if (cuteObject->ellipse)
-                collider.type = BZ_TILE_COLLIDER_ELLIPSE;
-            collider.x = (i8) cuteObject->x;
-            collider.y = (i8) cuteObject->y;
-            collider.sizeX = (i8) cuteObject->width;
-            collider.sizeY = (i8) cuteObject->height;
-
             tileset.tileColliders[cuteTile->tile_index] = collider;
         }
     }
@@ -68,11 +80,11 @@ Rectangle bzTilesetGetTileRegion(BzTileset *tileset, int tileID) {
     return (Rectangle) {posX * tileset->tileWidth, posY * tileset->tileHeight,
                         tileset->tileWidth, tileset->tileHeight};
 }
-BzTileCollider bzTilesetGetTileCollider(BzTileset *tileset, int tileID) {
+BzTileShape bzTilesetGetTileCollider(BzTileset *tileset, int tileID) {
     tileID = tileID - tileset->startID;
 
     if (tileID < 0 || tileID >= tileset->tileCount) {
-        return (BzTileCollider) {.type = BZ_TILE_COLLIDER_NONE};
+        return (BzTileShape) {.type = BZ_TILE_SHAPE_NONE};
     }
 
     return tileset->tileColliders[tileID];

engine/breeze/world/tileset.h

@@ -10,24 +10,26 @@ typedef struct BzTilesetDesc {
     const char *texturePath;
 } BzTilesetDesc;
 
-typedef enum BzTileColliderType {
+typedef enum BzTileShapeType {
-    BZ_TILE_COLLIDER_NONE,
+    BZ_TILE_SHAPE_NONE,
-    BZ_TILE_COLLIDER_RECT,
+    BZ_TILE_SHAPE_POINT,
-    BZ_TILE_COLLIDER_ELLIPSE
+    BZ_TILE_SHAPE_RECT,
-} BzTileColliderType;
+    BZ_TILE_SHAPE_ELLIPSE,
+    //BZ_TILE_SHAPE_POLYGON
+} BzTileShapeType;
 
-typedef struct BzTileCollider {
+typedef struct BzTileShape {
-    BzTileColliderType type;
+    BzTileShapeType type;
-    u8 x;
+    f32 x;
-    u8 y;
+    f32 y;
-    u8 sizeX;
+    f32 sizeX;
-    u8 sizeY;
+    f32 sizeY;
-} BzTileCollider;
+} BzTileShape;
 
 typedef struct BzTileset {
     Texture2D tiles;
     i32 tileCount;
-    BzTileCollider *tileColliders;
+    BzTileShape *tileColliders;
     i32 startID;
     i32 tileWidth;
     i32 tileHeight;
@@ -43,7 +45,7 @@ extern BzTileset BZ_TILESET_INVALID;
 BzTileset bzTilesetCreate(const BzTilesetDesc *desc);
 
 Rectangle bzTilesetGetTileRegion(BzTileset *tileset, int tileID);
-BzTileCollider bzTilesetGetTileCollider(BzTileset *tileset, int tileID);
+BzTileShape bzTilesetGetTileCollider(BzTileset *tileset, int tileID);
 
 void bzTilesetDestroy(BzTileset *tileset);
 

game/main.c

@@ -15,7 +15,28 @@ typedef struct Game {
 
 static Game GAME = {};
 
+bool handleGameObjects(BzTileObjectLayer *objectLayer) {
+    for (i32 i = 0; i < objectLayer->objectCount; i++) {
+        BzTileObject object = objectLayer->objects[i];
+        if (bzStringDefaultHash("camera") == object.id) {
+            printf("Got camera\n");
+            GAME.camera.target.x = object.shape.x;
+            GAME.camera.target.y = object.shape.y;
+        }
+    }
+    return false;
+}
+
 bool init(Game *game) {
+    int screenWidth = 1280;
+    int screenHeight = 720;
+
+    game->camera = (Camera2D){ 0 };
+    game->camera.target = (Vector2) {0, 0};
+    game->camera.offset = (Vector2) {screenWidth / 2.0f, screenHeight / 2.0f};
+    game->camera.rotation = 0.0f;
+    game->camera.zoom = 1.0f;
+
     game->terrainTileset = bzTilesetCreate( &(BzTilesetDesc) {
         .path="assets/terrain.tsj",
         .texturePath="assets/terrain.png"
@@ -28,18 +49,19 @@ bool init(Game *game) {
     game->map = bzTileMapCreate(&(BzTileMapDesc) {
         .path="assets/maps/test.tmj",
         .tilesets[0]=game->terrainTileset,
-        .tilesets[1]=game->buildingsTileset
+        .tilesets[1]=game->buildingsTileset,
+
+        .layers[0]=(BzTileLayerDesc) {"Terrain", NULL},
+        .layers[1]=(BzTileLayerDesc) {"Foliage", NULL},
+        .layers[2]=(BzTileLayerDesc) {"Trees", NULL},
+        .layers[3]=(BzTileLayerDesc) {"TreesS", NULL},
+        .layers[4]=(BzTileLayerDesc) {"Buildings", NULL},
+
+        .objectLayers[0]=(BzTileObjectsDesc) {"Game", handleGameObjects},
+        .objectLayers[1]=(BzTileObjectsDesc ) {"Entities", NULL}
     });
 
 
-    int screenWidth = 1280;
-    int screenHeight = 720;
-
-    game->camera = (Camera2D){ 0 };
-    game->camera.target = (Vector2) {0, 0};
-    game->camera.offset = (Vector2) {screenWidth / 2.0f, screenHeight / 2.0f};
-    game->camera.rotation = 0.0f;
-    game->camera.zoom = 1.0f;
     return true;
 }
 void deinit(Game *game) {

tiled/test.tmx

@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<map version="1.10" tiledversion="1.10.2" orientation="orthogonal" renderorder="right-down" width="80" height="50" tilewidth="16" tileheight="16" infinite="0" nextlayerid="32" nextobjectid="19727">
+<map version="1.10" tiledversion="1.10.2" orientation="orthogonal" renderorder="right-down" width="80" height="50" tilewidth="16" tileheight="16" infinite="0" nextlayerid="32" nextobjectid="19728">
  <editorsettings>
   <export target="../assets/maps/test.tmj" format="json"/>
  </editorsettings>