Refactor out level tilemap initialisation

- Rename sandbox scene initialisation, which is just a convenience
  function
- Also refactor out tilemap related functions to a new file

level_load_test.c

@@ -283,7 +283,7 @@ int main(void)
     LevelScene_t scene;
     scene.scene.engine = &engine;
     init_scene(&scene.scene, &level_scene_render_func, &level_do_action);
-    init_level_scene_data(&scene.data);
+    init_level_scene_data(&scene.data, MAX_N_TILES, all_tiles);
 
     pack = get_level_pack(&engine.assets, "TestLevels");
     assert(pack != NULL);
@@ -293,10 +293,8 @@ int main(void)
 
     scene.data.tilemap.width = scene.data.level_pack->levels[scene.data.current_level].width;
     scene.data.tilemap.height = scene.data.level_pack->levels[scene.data.current_level].height;
-    scene.data.tilemap.tile_size = TILE_SIZE;
     scene.data.tilemap.n_tiles = scene.data.tilemap.width * scene.data.tilemap.height;
     assert(scene.data.tilemap.n_tiles <= MAX_N_TILES);
-    scene.data.tilemap.tiles = all_tiles;
     memset(scene.data.tile_sprites, 0, sizeof(scene.data.tile_sprites));
 
     LevelMap_t lvl_map = scene.data.level_pack->levels[scene.data.current_level];
@@ -320,8 +318,6 @@ int main(void)
             default:
             break;
         }
-
-        sc_map_init_64v(&all_tiles[i].entities_set, 16, 0);
         switch (lvl_map.tiles[i].entity_to_spawn)
         {
             case 1:
@@ -409,11 +405,6 @@ int main(void)
         free_water_runner(ent, &scene.scene.ent_manager);
     }
     free_scene(&scene.scene);
-    for (size_t i = 0; i < scene.data.tilemap.n_tiles;i++)
-    {
-        all_tiles[i].solid = 0;
-        sc_map_term_64v(&all_tiles[i].entities_set);
-    }
     term_level_scene_data(&scene.data);
     sc_queue_term(&key_buffer);
     term_assets(&engine.assets);

main.c

@@ -46,7 +46,7 @@ int main(void)
 
     LevelScene_t level_scene;
     level_scene.scene.engine = &engine;
-    init_level_scene(&level_scene);
+    init_sandbox_scene(&level_scene);
     MenuScene_t menu_scene;
     menu_scene.scene.engine = &engine;
     init_menu_scene(&menu_scene);
@@ -102,7 +102,7 @@ int main(void)
             sc_queue_clear(&key_buffer);
         }
     }
-    free_level_scene(&level_scene);
+    free_sandbox_scene(&level_scene);
     free_menu_scene(&menu_scene);
     sc_queue_term(&key_buffer);
     term_assets(&engine.assets);

scene_test.c

@@ -31,7 +31,7 @@ int main(void)
 
     LevelScene_t scene;
     scene.scene.engine = &engine;
-    init_level_scene(&scene);
+    init_sandbox_scene(&scene);
     scene.data.tile_sprites[ONEWAY_TILE] = get_sprite(&engine.assets, "tl_owp");
     scene.data.tile_sprites[LADDER] = get_sprite(&engine.assets, "tl_ldr");
     scenes[0] = &scene.scene;
@@ -78,7 +78,7 @@ int main(void)
         render_scene(&scene.scene);
         if (WindowShouldClose()) break;
     } 
-    free_level_scene(&scene);
+    free_sandbox_scene(&scene);
     sc_queue_term(&key_buffer);
     term_assets(&engine.assets);
     CloseWindow();

scenes/CMakeLists.txt

@@ -7,6 +7,7 @@ add_library(lib_scenes STATIC
     editor_scene.c
     menu_scene.c
     game_systems.c
+    scene_systems.c
 )
 target_include_directories(lib_scenes
     PUBLIC

scenes/editor_scene.c

@@ -776,12 +776,22 @@ void level_do_action(Scene_t* scene, ActionType_t action, bool pressed)
     }
 }
 
-void init_level_scene(LevelScene_t* scene)
+void init_sandbox_scene(LevelScene_t* scene)
 {
     //init_scene(&scene->scene, LEVEL_SCENE, &level_scene_render_func, &level_do_action);
     init_scene(&scene->scene, &level_scene_render_func, &level_do_action);
 
-    init_level_scene_data(&scene->data);
+    scene->data.tilemap.tiles = all_tiles;
+    init_level_scene_data(&scene->data, MAX_N_TILES, all_tiles);
+    for (size_t i = 0; i < scene->data.tilemap.width; ++i)
+    {
+        unsigned int tile_idx = (scene->data.tilemap.height - 1) * scene->data.tilemap.width + i;
+        change_a_tile(&scene->data.tilemap, tile_idx, SOLID_TILE);
+    }
+
+    create_player(&scene->scene.ent_manager, &scene->scene.engine->assets);
+    update_entity_manager(&scene->scene.ent_manager);
+
     // insert level scene systems
     sc_array_add(&scene->scene.systems, &update_tilemap_system);
     sc_array_add(&scene->scene.systems, &player_movement_input_system);
@@ -824,43 +834,10 @@ void init_level_scene(LevelScene_t* scene)
     sc_map_put_64(&scene->scene.action_map, KEY_Q, ACTION_EXIT);
     sc_map_put_64(&scene->scene.action_map, KEY_R, ACTION_RESTART);
 
-    scene->data.tilemap.width = DEFAULT_MAP_WIDTH;
-    scene->data.tilemap.height = DEFAULT_MAP_HEIGHT;
-    scene->data.tilemap.tile_size = TILE_SIZE;
-    scene->data.tilemap.n_tiles = scene->data.tilemap.width * scene->data.tilemap.height;
-    assert(scene->data.tilemap.n_tiles <= MAX_N_TILES);
-    scene->data.tilemap.tiles = all_tiles;
-    memset(scene->data.tile_sprites, 0, sizeof(scene->data.tile_sprites));
-    for (size_t i = 0; i < scene->data.tilemap.n_tiles;i++)
-    {
-        all_tiles[i].solid = NOT_SOLID;
-        all_tiles[i].tile_type = EMPTY_TILE;
-        all_tiles[i].moveable = true;
-        all_tiles[i].max_water_level = 4;
-        sc_map_init_64v(&all_tiles[i].entities_set, 16, 0);
-        all_tiles[i].size = (Vector2){TILE_SIZE, TILE_SIZE};
-    }
-    for (size_t i = 0; i < scene->data.tilemap.width; ++i)
-    {
-        unsigned int tile_idx = (scene->data.tilemap.height - 1) * scene->data.tilemap.width + i;
-        change_a_tile(&scene->data.tilemap, tile_idx, SOLID_TILE);
-    }
-
-    create_player(&scene->scene.ent_manager, &scene->scene.engine->assets);
-    update_entity_manager(&scene->scene.ent_manager);
 }
 
-void free_level_scene(LevelScene_t* scene)
+void free_sandbox_scene(LevelScene_t* scene)
 {
     free_scene(&scene->scene);
-    for (size_t i = 0; i < scene->data.tilemap.n_tiles;i++)
-    {
-        all_tiles[i].solid = 0;
-        sc_map_term_64v(&all_tiles[i].entities_set);
-    }
     term_level_scene_data(&scene->data);
 }
-
-void reload_level_scene(LevelScene_t* scene)
-{
-}

scenes/engine/collisions.h

@@ -28,6 +28,7 @@ typedef struct TileGrid
     unsigned int width;
     unsigned int height;
     unsigned int n_tiles;
+    unsigned int max_tiles;
     unsigned int tile_size;
     Tile_t* tiles;
 }TileGrid_t;

scenes/game_systems.c

@@ -26,103 +26,6 @@ static inline unsigned int get_tile_idx(int x, int y, unsigned int tilemap_width
     return tile_y * tilemap_width + tile_x;
 }
 
-void change_a_tile(TileGrid_t* tilemap, unsigned int tile_idx, TileType_t new_type)
-{
-    TileType_t last_type = tilemap->tiles[tile_idx].tile_type;
-    tilemap->tiles[tile_idx].tile_type = new_type;
-
-    switch (new_type)
-    {
-        case EMPTY_TILE:
-            tilemap->tiles[tile_idx].solid = NOT_SOLID;
-        break;
-        case ONEWAY_TILE:
-            tilemap->tiles[tile_idx].solid = ONE_WAY;
-        break;
-        case LADDER:
-        {
-            int up_tile = tile_idx - tilemap->width;
-            if (up_tile > 0 && tilemap->tiles[up_tile].tile_type != LADDER)
-            {
-                tilemap->tiles[tile_idx].solid = ONE_WAY;
-            }
-            else
-            {
-                tilemap->tiles[tile_idx].solid = NOT_SOLID;
-            }
-            int down_tile = tile_idx + tilemap->width;
-            if (down_tile < tilemap->n_tiles && tilemap->tiles[down_tile].tile_type == LADDER)
-            {
-                tilemap->tiles[down_tile].solid = (tilemap->tiles[tile_idx].tile_type != LADDER)? ONE_WAY : NOT_SOLID;
-            }
-        }
-        break;
-        case SPIKES:
-            tilemap->tiles[tile_idx].solid = NOT_SOLID;
-        break;
-        case SOLID_TILE:
-            tilemap->tiles[tile_idx].solid = SOLID;
-        break;
-    }
-
-    if (last_type == LADDER && new_type != LADDER)
-    {
-        int down_tile = tile_idx + tilemap->width;
-        if (down_tile < tilemap->n_tiles && tilemap->tiles[down_tile].tile_type == LADDER)
-        {
-            tilemap->tiles[down_tile].solid = ONE_WAY;
-        }
-
-    }
-
-    if (new_type == SPIKES)
-    {
-        // Priority: Down, Up, Left, Right
-        if (tile_idx + tilemap->width < tilemap->n_tiles && tilemap->tiles[tile_idx + tilemap->width].tile_type == SOLID_TILE)
-        {
-            tilemap->tiles[tile_idx].offset = (Vector2){0,16};
-            tilemap->tiles[tile_idx].size = (Vector2){32,16};
-        }
-        else if (tile_idx - tilemap->width >= 0 && tilemap->tiles[tile_idx - tilemap->width].tile_type == SOLID_TILE)
-        {
-            tilemap->tiles[tile_idx].offset = (Vector2){0,0};
-            tilemap->tiles[tile_idx].size = (Vector2){32,16};
-        }
-        else if (tile_idx % tilemap->width != 0 && tilemap->tiles[tile_idx - 1].tile_type == SOLID_TILE)
-        {
-            tilemap->tiles[tile_idx].offset = (Vector2){0,0};
-            tilemap->tiles[tile_idx].size = (Vector2){16,32};
-        }
-        else if ((tile_idx + 1) % tilemap->width != 0 && tilemap->tiles[tile_idx + 1].tile_type == SOLID_TILE)
-        {
-            tilemap->tiles[tile_idx].offset = (Vector2){16,0};
-            tilemap->tiles[tile_idx].size = (Vector2){16,32};
-        }
-        else
-        {
-            tilemap->tiles[tile_idx].offset = (Vector2){0,16};
-            tilemap->tiles[tile_idx].size = (Vector2){32,16};
-        }
-    }
-    else if (new_type == ONEWAY_TILE)
-    {
-        tilemap->tiles[tile_idx].offset = (Vector2){0,0};
-        tilemap->tiles[tile_idx].size = (Vector2){32,10};
-    }
-    else
-    {
-        tilemap->tiles[tile_idx].offset = (Vector2){0,0};
-        tilemap->tiles[tile_idx].size = (Vector2){32,32};
-    }
-
-    tilemap->tiles[tile_idx].moveable = (
-        tilemap->tiles[tile_idx].tile_type == EMPTY_TILE
-        || tilemap->tiles[tile_idx].tile_type == SPIKES
-    );
-    tilemap->tiles[tile_idx].def = (tilemap->tiles[tile_idx].tile_type == SOLID_TILE) ? 5: 2;
-
-}
-
 // ------------------------- Collision functions ------------------------------------
 // Do not subtract one for the size for any collision check, just pass normally. The extra one is important for AABB test
 
@@ -1758,17 +1661,3 @@ void camera_update_system(Scene_t* scene)
     if (min.x > 0) lvl_scene->data.cam.offset.x = width/2.0f - min.x;
     if (min.y > 0) lvl_scene->data.cam.offset.y = height/2.0f - min.y;
 }
-
-void init_level_scene_data(LevelSceneData_t* data)
-{
-    data->game_viewport = LoadRenderTexture(VIEWABLE_MAP_WIDTH*TILE_SIZE, VIEWABLE_MAP_HEIGHT*TILE_SIZE);
-    data->game_rec = (Rectangle){25, 25, VIEWABLE_MAP_WIDTH*TILE_SIZE, VIEWABLE_MAP_HEIGHT*TILE_SIZE};
-    data->cam = (Camera2D){0};
-    data->cam.rotation = 0.0f;
-    data->cam.zoom = 1.0f;
-}
-
-void term_level_scene_data(LevelSceneData_t* data)
-{
-    UnloadRenderTexture(data->game_viewport); // Unload render texture
-}

scenes/game_systems.h

@@ -1,8 +1,6 @@
 #ifndef __GAME_SYSTEMS_H
 #define __GAME_SYSTEMS_H
 #include "scene_impl.h"
-void init_level_scene_data(LevelSceneData_t* data);
-void term_level_scene_data(LevelSceneData_t* data);
 
 void player_movement_input_system(Scene_t* scene);
 void player_bbox_update_system(Scene_t* scene);
@@ -26,5 +24,4 @@ void player_respawn_system(Scene_t* scene);
 void lifetimer_update_system(Scene_t* scene);
 void spike_collision_system(Scene_t* scene);
 
-void change_a_tile(TileGrid_t* tilemap, unsigned int tile_idx, TileType_t new_type);
 #endif // __GAME_SYSTEMS_H

scenes/scene_impl.h

@@ -34,10 +34,13 @@ typedef struct LevelScene {
     LevelSceneData_t data;
 }LevelScene_t;
 
-void init_level_scene(LevelScene_t* scene);
+void init_sandbox_scene(LevelScene_t* scene);
-void free_level_scene(LevelScene_t* scene);
+void free_sandbox_scene(LevelScene_t* scene);
-void reload_level_scene(LevelScene_t* scene);
+void init_level_scene_data(LevelSceneData_t* data, uint32_t max_tiles, Tile_t* tiles);
-bool load_a_level(LevelScene_t* scene, unsigned int level_num);
+void term_level_scene_data(LevelSceneData_t* data);
+void reload_level_tilemap(LevelScene_t* scene);
+bool load_level_tilemap(LevelScene_t* scene, unsigned int level_num);
+void change_a_tile(TileGrid_t* tilemap, unsigned int tile_idx, TileType_t new_type);
 
 typedef enum GuiMode {
     KEYBOARD_MODE,
@@ -58,4 +61,5 @@ typedef struct MenuScene {
 
 void init_menu_scene(MenuScene_t* scene);
 void free_menu_scene(MenuScene_t* scene);
+
 #endif // __SCENE_IMPL_H

scenes/scene_systems.c

@@ -0,0 +1,155 @@
+#include "scene_impl.h"
+#include "constants.h"
+
+void init_level_scene_data(LevelSceneData_t* data, uint32_t max_tiles, Tile_t* tiles)
+{
+    data->game_viewport = LoadRenderTexture(VIEWABLE_MAP_WIDTH*TILE_SIZE, VIEWABLE_MAP_HEIGHT*TILE_SIZE);
+    data->game_rec = (Rectangle){25, 25, VIEWABLE_MAP_WIDTH*TILE_SIZE, VIEWABLE_MAP_HEIGHT*TILE_SIZE};
+    data->cam = (Camera2D){0};
+    data->cam.rotation = 0.0f;
+    data->cam.zoom = 1.0f;
+
+    data->tilemap.max_tiles = max_tiles;
+    if (tiles != NULL)
+    {
+        data->tilemap.tiles = tiles;
+    }
+    else
+    {
+        data->tilemap.tiles = calloc(max_tiles, sizeof(Tile_t));
+    }
+
+    data->tilemap.width = DEFAULT_MAP_WIDTH;
+    data->tilemap.height = DEFAULT_MAP_HEIGHT;
+    data->tilemap.tile_size = TILE_SIZE;
+    data->tilemap.n_tiles = data->tilemap.width * data->tilemap.height;
+    memset(data->tile_sprites, 0, sizeof(data->tile_sprites));
+    for (size_t i = 0; i < max_tiles;i++)
+    {
+        data->tilemap.tiles[i].solid = NOT_SOLID;
+        data->tilemap.tiles[i].tile_type = EMPTY_TILE;
+        data->tilemap.tiles[i].moveable = true;
+        data->tilemap.tiles[i].max_water_level = 4;
+        sc_map_init_64v(&data->tilemap.tiles[i].entities_set, 16, 0);
+        data->tilemap.tiles[i].size = (Vector2){TILE_SIZE, TILE_SIZE};
+    }
+}
+
+void term_level_scene_data(LevelSceneData_t* data)
+{
+    for (size_t i = 0; i < data->tilemap.max_tiles;i++)
+    {
+        sc_map_term_64v(&data->tilemap.tiles[i].entities_set);
+    }
+    UnloadRenderTexture(data->game_viewport); // Unload render texture
+}
+
+static void clear_level_tilemap(LevelSceneData_t* data)
+{
+}
+
+bool load_level_tilemap(LevelScene_t* scene, unsigned int level_num)
+{
+    return true;
+}
+
+void reload_level_tilemap(LevelScene_t* scene)
+{
+}
+
+void change_a_tile(TileGrid_t* tilemap, unsigned int tile_idx, TileType_t new_type)
+{
+    TileType_t last_type = tilemap->tiles[tile_idx].tile_type;
+    tilemap->tiles[tile_idx].tile_type = new_type;
+
+    switch (new_type)
+    {
+        case EMPTY_TILE:
+            tilemap->tiles[tile_idx].solid = NOT_SOLID;
+        break;
+        case ONEWAY_TILE:
+            tilemap->tiles[tile_idx].solid = ONE_WAY;
+        break;
+        case LADDER:
+        {
+            int up_tile = tile_idx - tilemap->width;
+            if (up_tile > 0 && tilemap->tiles[up_tile].tile_type != LADDER)
+            {
+                tilemap->tiles[tile_idx].solid = ONE_WAY;
+            }
+            else
+            {
+                tilemap->tiles[tile_idx].solid = NOT_SOLID;
+            }
+            int down_tile = tile_idx + tilemap->width;
+            if (down_tile < tilemap->n_tiles && tilemap->tiles[down_tile].tile_type == LADDER)
+            {
+                tilemap->tiles[down_tile].solid = (tilemap->tiles[tile_idx].tile_type != LADDER)? ONE_WAY : NOT_SOLID;
+            }
+        }
+        break;
+        case SPIKES:
+            tilemap->tiles[tile_idx].solid = NOT_SOLID;
+        break;
+        case SOLID_TILE:
+            tilemap->tiles[tile_idx].solid = SOLID;
+        break;
+    }
+
+    if (last_type == LADDER && new_type != LADDER)
+    {
+        int down_tile = tile_idx + tilemap->width;
+        if (down_tile < tilemap->n_tiles && tilemap->tiles[down_tile].tile_type == LADDER)
+        {
+            tilemap->tiles[down_tile].solid = ONE_WAY;
+        }
+
+    }
+
+    if (new_type == SPIKES)
+    {
+        // Priority: Down, Up, Left, Right
+        if (tile_idx + tilemap->width < tilemap->n_tiles && tilemap->tiles[tile_idx + tilemap->width].tile_type == SOLID_TILE)
+        {
+            tilemap->tiles[tile_idx].offset = (Vector2){0,16};
+            tilemap->tiles[tile_idx].size = (Vector2){32,16};
+        }
+        else if (tile_idx - tilemap->width >= 0 && tilemap->tiles[tile_idx - tilemap->width].tile_type == SOLID_TILE)
+        {
+            tilemap->tiles[tile_idx].offset = (Vector2){0,0};
+            tilemap->tiles[tile_idx].size = (Vector2){32,16};
+        }
+        else if (tile_idx % tilemap->width != 0 && tilemap->tiles[tile_idx - 1].tile_type == SOLID_TILE)
+        {
+            tilemap->tiles[tile_idx].offset = (Vector2){0,0};
+            tilemap->tiles[tile_idx].size = (Vector2){16,32};
+        }
+        else if ((tile_idx + 1) % tilemap->width != 0 && tilemap->tiles[tile_idx + 1].tile_type == SOLID_TILE)
+        {
+            tilemap->tiles[tile_idx].offset = (Vector2){16,0};
+            tilemap->tiles[tile_idx].size = (Vector2){16,32};
+        }
+        else
+        {
+            tilemap->tiles[tile_idx].offset = (Vector2){0,16};
+            tilemap->tiles[tile_idx].size = (Vector2){32,16};
+        }
+    }
+    else if (new_type == ONEWAY_TILE)
+    {
+        tilemap->tiles[tile_idx].offset = (Vector2){0,0};
+        tilemap->tiles[tile_idx].size = (Vector2){32,10};
+    }
+    else
+    {
+        tilemap->tiles[tile_idx].offset = (Vector2){0,0};
+        tilemap->tiles[tile_idx].size = (Vector2){32,32};
+    }
+
+    tilemap->tiles[tile_idx].moveable = (
+        tilemap->tiles[tile_idx].tile_type == EMPTY_TILE
+        || tilemap->tiles[tile_idx].tile_type == SPIKES
+    );
+    tilemap->tiles[tile_idx].def = (tilemap->tiles[tile_idx].tile_type == SOLID_TILE) ? 5: 2;
+
+}

water_test.c

@@ -9,7 +9,6 @@
 #include <stdio.h>
 #include <unistd.h>
 
-#define MAX_N_TILES 4096
 static Tile_t all_tiles[MAX_N_TILES] = {0};
 
 // Maintain own queue to handle key presses
@@ -193,7 +192,6 @@ static void level_scene_render_func(Scene_t* scene)
         );
     EndDrawing();
 }
-#define MAX_N_TILES 4096
 
 static inline unsigned int get_tile_idx(int x, int y, const TileGrid_t* tilemap)
 {
@@ -421,24 +419,9 @@ int main(void)
     LevelScene_t scene;
     scene.scene.engine = &engine;
     init_scene(&scene.scene, &level_scene_render_func, &level_do_action);
-    init_level_scene_data(&scene.data);
+    init_level_scene_data(&scene.data, MAX_N_TILES, all_tiles);
-
-    scene.data.tilemap.width = DEFAULT_MAP_WIDTH;
-    scene.data.tilemap.height = DEFAULT_MAP_HEIGHT;
-    scene.data.tilemap.tile_size = TILE_SIZE;
-    scene.data.tilemap.n_tiles = scene.data.tilemap.width * scene.data.tilemap.height;
     assert(scene.data.tilemap.n_tiles <= MAX_N_TILES);
-    scene.data.tilemap.tiles = all_tiles;
+
-    memset(scene.data.tile_sprites, 0, sizeof(scene.data.tile_sprites));
-    for (size_t i = 0; i < scene.data.tilemap.n_tiles;i++)
-    {
-        all_tiles[i].solid = NOT_SOLID;
-        all_tiles[i].tile_type = EMPTY_TILE;
-        all_tiles[i].moveable = true;
-        all_tiles[i].max_water_level = 4;
-        sc_map_init_64v(&all_tiles[i].entities_set, 16, 0);
-        all_tiles[i].size = (Vector2){TILE_SIZE, TILE_SIZE};
-    }
     for (size_t i = 0; i < scene.data.tilemap.width; ++i)
     {
         unsigned int tile_idx = (scene.data.tilemap.height - 1) * scene.data.tilemap.width + i;
@@ -519,11 +502,6 @@ int main(void)
         free_water_runner(ent, &scene.scene.ent_manager);
     }
     free_scene(&scene.scene);
-    for (size_t i = 0; i < scene.data.tilemap.n_tiles;i++)
-    {
-        all_tiles[i].solid = 0;
-        sc_map_term_64v(&all_tiles[i].entities_set);
-    }
     term_level_scene_data(&scene.data);
     sc_queue_term(&key_buffer);
     term_assets(&engine.assets);