Add struct for loading in a level pack

scenes/constants.h

@@ -40,4 +40,8 @@
 
 #define MAX_WATER_LEVEL 4
 #define WATER_BBOX_STEP (TILE_SIZE / MAX_WATER_LEVEL)
+
+#define MAX_LEVEL_NUM 50
+#define MAX_N_TILES 4096
+
 #endif // __CONSTANTS_H

scenes/editor_scene.c

@@ -8,7 +8,6 @@
 #include "raymath.h"
 #include <stdio.h>
 
-#define MAX_N_TILES 4096
 static Tile_t all_tiles[MAX_N_TILES] = {0};
 
 enum EntitySpawnSelection {

scenes/engine/assets.c

@@ -5,8 +5,10 @@
 #define MAX_SPRITES 16
 #define MAX_SOUNDS 16
 #define MAX_FONTS 4
+#define MAX_N_TILES 4096
 #define MAX_NAME_LEN 32
-uint8_t free_idx[4] = {0};
+#define MAX_LEVEL_PACK 1
+uint8_t n_loaded[5] = {0};
 
 // Hard limit number of 
 typedef struct TextureData
@@ -29,17 +31,26 @@ typedef struct SoundData
     Sound sound;
     char name[MAX_NAME_LEN];
 }SoundData_t;
-
+typedef struct LevelPackData
+{
+    LevelPack_t pack;
+    char name[MAX_NAME_LEN];
+}LevelPackData_t;
 
 static TextureData_t textures[MAX_TEXTURES];
 static FontData_t fonts[MAX_FONTS];
 static SoundData_t sfx[MAX_SOUNDS];
 static SpriteData_t sprites[MAX_SPRITES];
+static LevelPackData_t levelpacks[MAX_LEVEL_PACK];
+
+static void unload_level_pack(LevelPack_t pack)
+{
+}
 
 // Maybe need a circular buffer??
 Texture2D* add_texture(Assets_t* assets, const char* name, const char* path)
 {
-    uint8_t tex_idx = free_idx[0];
+    uint8_t tex_idx = n_loaded[0];
     assert(tex_idx < MAX_TEXTURES);
     Texture2D tex = LoadTexture(path);
     if (tex.width == 0 || tex.height == 0) return NULL;
@@ -47,59 +58,83 @@ Texture2D* add_texture(Assets_t* assets, const char* name, const char* path)
     textures[tex_idx].texture = tex;
     strncpy(textures[tex_idx].name, name, MAX_NAME_LEN);
     sc_map_put_s64(&assets->m_textures, textures[tex_idx].name, tex_idx);
-    free_idx[0]++;
+    n_loaded[0]++;
     return &textures[tex_idx].texture;
 }
 
 Sprite_t* add_sprite(Assets_t* assets, const char* name, Texture2D* texture)
 {
-    uint8_t spr_idx = free_idx[1];
+    uint8_t spr_idx = n_loaded[1];
     assert(spr_idx < MAX_SPRITES);
     memset(sprites + spr_idx, 0, sizeof(Sprite_t));
     sprites[spr_idx].sprite.texture = texture;
     strncpy(sprites[spr_idx].name, name, MAX_NAME_LEN);
     sc_map_put_s64(&assets->m_sprites, sprites[spr_idx].name, spr_idx);
-    free_idx[1]++;
+    n_loaded[1]++;
     return &sprites[spr_idx].sprite;
 }
 
 Sound* add_sound(Assets_t* assets, const char* name, const char* path)
 {
-    uint8_t snd_idx = free_idx[2];
+    uint8_t snd_idx = n_loaded[2];
     assert(snd_idx < MAX_SOUNDS);
     sfx[snd_idx].sound = LoadSound(path);
     strncpy(sfx[snd_idx].name, name, MAX_NAME_LEN);
     sc_map_put_s64(&assets->m_sounds, sfx[snd_idx].name, snd_idx);
-    free_idx[2]++;
+    n_loaded[2]++;
     return &sfx[snd_idx].sound;
 }
 
 Font* add_font(Assets_t* assets, const char* name, const char* path)
 {
-    uint8_t fnt_idx = free_idx[3];
+    uint8_t fnt_idx = n_loaded[3];
     assert(fnt_idx < MAX_FONTS);
     fonts[fnt_idx].font = LoadFont(path);
     strncpy(fonts[fnt_idx].name, name, MAX_NAME_LEN);
     sc_map_put_s64(&assets->m_fonts, fonts[fnt_idx].name, fnt_idx);
-    free_idx[3]++;
+    n_loaded[3]++;
     return &fonts[fnt_idx].font;
 }
 
+LevelTileInfo_t* add_level_pack(Assets_t* assets, const char* name, const char* path)
+{
+    return NULL;
+}
+
 void init_assets(Assets_t* assets)
 {
     sc_map_init_s64(&assets->m_fonts, MAX_FONTS, 0);
     sc_map_init_s64(&assets->m_sprites, MAX_SPRITES, 0);
     sc_map_init_s64(&assets->m_textures, MAX_TEXTURES, 0);
     sc_map_init_s64(&assets->m_sounds, MAX_SOUNDS, 0);
+    sc_map_init_s64(&assets->m_levelpacks, MAX_LEVEL_PACK, 0);
 }
 
 void free_all_assets(Assets_t* assets)
 {
+    for (uint8_t i = 0; i < n_loaded[0]; ++i)
+    {
+        UnloadTexture(textures[i].texture);
+    }
+    for (uint8_t i = 0; i < n_loaded[2]; ++i)
+    {
+        UnloadSound(sfx[i].sound);
+    }
+    for (uint8_t i = 0; i < n_loaded[3]; ++i)
+    {
+        UnloadFont(fonts[i].font);
+    }
+    for (uint8_t i = 0; i < n_loaded[4]; ++i)
+    {
+        unload_level_pack(levelpacks[i].pack);
+    }
+
     sc_map_clear_s64(&assets->m_textures);
     sc_map_clear_s64(&assets->m_fonts);
     sc_map_clear_s64(&assets->m_sounds);
     sc_map_clear_s64(&assets->m_sprites);
-    memset(free_idx, 0, sizeof(free_idx));
+    sc_map_clear_s64(&assets->m_levelpacks);
+    memset(n_loaded, 0, sizeof(n_loaded));
 }
 
 void term_assets(Assets_t* assets)
@@ -109,6 +144,7 @@ void term_assets(Assets_t* assets)
     sc_map_term_s64(&assets->m_fonts);
     sc_map_term_s64(&assets->m_sounds);
     sc_map_term_s64(&assets->m_sprites);
+    sc_map_term_s64(&assets->m_levelpacks);
 }
 
 Texture2D* get_texture(Assets_t* assets, const char* name)

scenes/engine/assets.h

@@ -10,8 +10,29 @@ typedef struct Assets
     struct sc_map_s64 m_sounds;
     struct sc_map_s64 m_fonts;
     struct sc_map_s64 m_sprites;
+    struct sc_map_s64 m_levelpacks;
 }Assets_t;
 
+typedef struct LevelTileInfo
+{
+    uint8_t tile_type;
+    uint8_t entity_to_spawn;
+    uint8_t water;
+}LevelTileInfo_t;
+
+typedef struct LevelMap
+{
+    unsigned int width;
+    unsigned int height;
+    unsigned int n_tiles;
+    LevelTileInfo_t* tiles;
+}LevelMap_t;
+
+typedef struct LevelPack
+{
+   unsigned int n_levels;
+   LevelMap_t* levels;
+}LevelPack_t;
 
 void init_assets(Assets_t* assets);
 void free_all_assets(Assets_t* assets);
@@ -21,12 +42,13 @@ Texture2D* add_texture(Assets_t* assets, const char* name, const char* path);
 Sprite_t* add_sprite(Assets_t* assets, const char* name, Texture2D* texture);
 Sound* add_sound(Assets_t * assets, const char* name, const char* path);
 Font* add_font(Assets_t* assets, const char* name, const char* path);
-
+LevelTileInfo_t* add_level_pack(Assets_t* assets, const char* name, const char* path);
 
 Texture2D* get_texture(Assets_t* assets, const char* name);
 Sprite_t* get_sprite(Assets_t* assets, const char* name);
 Sound* get_sound(Assets_t* assets, const char* name);
 Font* get_font(Assets_t* assets, const char* name);
+LevelMap_t* get_level_pack(Assets_t* assets, const char* name);
 
 void draw_sprite(Sprite_t* spr, Vector2 pos, bool flip_x);
 #endif // __ASSETS_H

scenes/scene_impl.h

@@ -25,6 +25,8 @@ typedef struct LevelSceneData {
     Rectangle game_rec;
     Camera2D cam;
     Sprite_t* tile_sprites[MAX_TILE_TYPES];
+    LevelPack_t level_pack;
+    unsigned int current_level;
 }LevelSceneData_t;
 
 typedef struct LevelScene {
@@ -35,6 +37,7 @@ typedef struct LevelScene {
 void init_level_scene(LevelScene_t* scene);
 void free_level_scene(LevelScene_t* scene);
 void reload_level_scene(LevelScene_t* scene);
+bool load_a_level(LevelScene_t* scene, unsigned int level_num);
 
 typedef enum GuiMode {
     KEYBOARD_MODE,