Implement level pack loading and testing

CMakeLists.txt

@@ -85,6 +85,19 @@ target_link_libraries(water_test
 target_compile_options(water_test PRIVATE -fsanitize=address -gdwarf-4)
 target_link_options(water_test PRIVATE -fsanitize=address -gdwarf-4)
 
+add_executable(level_load_test
+    level_load_test.c
+)
+target_include_directories(level_load_test
+    PRIVATE
+    ${CMAKE_CURRENT_LIST_DIR}
+)
+target_link_libraries(level_load_test
+    ${GAME_LIBS}
+)
+target_compile_options(level_load_test PRIVATE -fsanitize=address -gdwarf-4)
+target_link_options(level_load_test PRIVATE -fsanitize=address -gdwarf-4)
+
 add_executable(menu_test
     menu_test.c
 )

level_load_test.c

@@ -0,0 +1,421 @@
+#include "constants.h"
+#include "mempool.h"
+#include "raymath.h"
+#include "scene_impl.h"
+#include "ent_impl.h"
+#include "water_flow.h"
+#include "game_systems.h"
+#include "assets_loader.h"
+#include <stdio.h>
+#include <unistd.h>
+
+static Tile_t all_tiles[MAX_N_TILES] = {0};
+
+// Maintain own queue to handle key presses
+struct sc_queue_32 key_buffer;
+
+Scene_t* scenes[1];
+static GameEngine_t engine =
+{
+    .scenes = scenes,
+    .max_scenes = 1,
+    .curr_scene = 0,
+    .assets = {0}
+};
+
+static void level_scene_render_func(Scene_t* scene)
+{
+    LevelSceneData_t* data = &(CONTAINER_OF(scene, LevelScene_t, scene)->data);
+    TileGrid_t tilemap = data->tilemap;
+
+    Entity_t* p_ent;
+
+    BeginTextureMode(data->game_viewport);
+        ClearBackground(WHITE);
+        BeginMode2D(data->cam);
+        for (size_t i = 0; i < tilemap.n_tiles; ++i)
+        {
+            char buffer[6] = {0};
+            int x = (i % tilemap.width) * TILE_SIZE;
+            int y = (i / tilemap.width) * TILE_SIZE;
+            sprintf(buffer, "%u", sc_map_size_64v(&tilemap.tiles[i].entities_set));
+
+            if (!tilemap.tiles[i].moveable)
+            {
+                // Draw water tile
+                Color water_colour = ColorAlpha(RED, 0.2);
+                DrawRectangle(x, y, TILE_SIZE, TILE_SIZE, water_colour);
+            }
+
+            if (tilemap.tiles[i].tile_type == SOLID_TILE)
+            {
+                DrawRectangle(x, y, TILE_SIZE, TILE_SIZE, BLACK);
+            }
+            
+            if (tilemap.tiles[i].wet)
+            {
+#define SURFACE_THICKNESS 4
+                int up = i - tilemap.width;
+                int bot = i + tilemap.width;
+                int right = i + 1;
+                int left = i - 1;
+                int bot_line = y + TILE_SIZE - tilemap.tiles[i].water_level * WATER_BBOX_STEP - SURFACE_THICKNESS / 2;
+                if (up >= 0 && tilemap.tiles[up].wet)
+                {
+                    DrawLineEx((Vector2){x + TILE_SIZE / 2, y}, (Vector2){x + TILE_SIZE / 2, y + TILE_SIZE - tilemap.tiles[i].water_level * WATER_BBOX_STEP}, SURFACE_THICKNESS, ColorAlpha(BLUE, 0.7));
+                }
+
+
+                if (
+                    bot <= tilemap.n_tiles
+                    && tilemap.tiles[bot].water_level < MAX_WATER_LEVEL
+                    && tilemap.tiles[i].water_level == 0
+                    )
+                {
+                    if (i % tilemap.width != 0 && tilemap.tiles[left].wet)
+                    {
+                        DrawLineEx((Vector2){x, bot_line}, (Vector2){x + TILE_SIZE / 2, bot_line}, SURFACE_THICKNESS, ColorAlpha(BLUE, 0.7));
+                    }
+                    if (right % tilemap.width != 0 && tilemap.tiles[right].wet)
+                    {
+                        DrawLineEx((Vector2){x + TILE_SIZE / 2, bot_line}, (Vector2){x + TILE_SIZE, bot_line}, SURFACE_THICKNESS, ColorAlpha(BLUE, 0.7));
+                    }
+                }
+            }
+
+            uint32_t water_height = tilemap.tiles[i].water_level * WATER_BBOX_STEP;
+            // Draw water tile
+            Color water_colour = ColorAlpha(BLUE, 0.5);
+            DrawRectangle(
+                x,
+                y + (TILE_SIZE - water_height),
+                TILE_SIZE,
+                water_height,
+                water_colour
+            );
+        }
+
+        sc_map_foreach_value(&scene->ent_manager.entities, p_ent)
+        {
+            CTransform_t* p_ct = get_component(p_ent, CTRANSFORM_COMP_T);
+            if (p_ct == NULL) continue;
+
+
+            CSprite_t* p_cspr = get_component(p_ent, CSPRITE_T);
+            if (p_cspr != NULL)
+            {
+                const SpriteRenderInfo_t spr = p_cspr->sprites[p_cspr->current_idx];
+                if (spr.sprite != NULL)
+                {
+                    Vector2 pos = Vector2Add(p_ct->position, spr.offset);
+                    draw_sprite(spr.sprite, pos, p_cspr->flip_x);
+                }
+            }
+        }
+        sc_map_foreach_value(&scene->ent_manager.entities_map[DYNMEM_ENT_TAG], p_ent)
+        {
+            CWaterRunner_t* p_runner = get_component(p_ent, CWATERRUNNER_T);
+
+            unsigned int x = ((p_runner->current_tile) % tilemap.width) * tilemap.tile_size; 
+            unsigned int y = ((p_runner->current_tile) / tilemap.width) * tilemap.tile_size; 
+            DrawCircle(x+16, y+16, 8, ColorAlpha(BLACK, 0.2));
+            if (p_runner->target_tile < p_runner->bfs_tilemap.len)
+            {
+                unsigned int x = ((p_runner->target_tile) % tilemap.width) * tilemap.tile_size; 
+                unsigned int y = ((p_runner->target_tile) / tilemap.width) * tilemap.tile_size; 
+                DrawCircle(x+16, y+16, 8, ColorAlpha(BLUE, 0.2));
+            }
+
+            if (p_runner->state == LOWEST_POINT_MOVEMENT)
+            {
+                int curr_idx = p_runner->current_tile;
+                int next_idx = p_runner->bfs_tilemap.tilemap[curr_idx].to;
+                while(curr_idx != p_runner->target_tile || curr_idx == next_idx)
+                while(next_idx >= 0)
+                {
+                    unsigned int x1 = (curr_idx % tilemap.width) * tilemap.tile_size + tilemap.tile_size / 2; 
+                    unsigned int y1 = (curr_idx / tilemap.width) * tilemap.tile_size + tilemap.tile_size / 2; 
+                    unsigned int x2 = (next_idx % tilemap.width) * tilemap.tile_size + tilemap.tile_size / 2; 
+                    unsigned int y2 = (next_idx / tilemap.width) * tilemap.tile_size + tilemap.tile_size / 2; 
+                    DrawLine(x1, y1, x2, y2, BLACK);
+                    curr_idx = next_idx;
+                    next_idx = p_runner->bfs_tilemap.tilemap[curr_idx].to;
+                }
+            }
+        }
+
+        char buffer[64] = {0};
+        for (size_t i = 0; i < tilemap.n_tiles; ++i)
+        {
+            int x = (i % tilemap.width) * TILE_SIZE;
+            int y = (i / tilemap.width) * TILE_SIZE;
+            sprintf(buffer, "%u", sc_map_size_64v(&tilemap.tiles[i].entities_set));
+
+            if (tilemap.tiles[i].solid > 0)
+            {
+                DrawText(buffer, x, y, 10, WHITE);
+            }
+            else
+            {
+                // Draw water tile
+                DrawText(buffer, x, y, 10, BLACK);
+            }
+        }
+
+        // Draw tile grid
+        for (size_t i = 0; i < tilemap.width; ++i)
+        {
+            int x = (i+1)*TILE_SIZE;
+            DrawLine(x, 0, x, tilemap.height * TILE_SIZE, BLACK);
+        }
+        for (size_t i = 0; i < tilemap.height;++i)
+        {
+            int y = (i+1)*TILE_SIZE;
+            DrawLine(0, y, tilemap.width * TILE_SIZE, y, BLACK);
+        }
+        EndMode2D();
+    EndTextureMode();
+
+    Rectangle draw_rec = data->game_rec;
+    draw_rec.x = 0;
+    draw_rec.y = 0;
+    draw_rec.height *= -1;
+    BeginDrawing();
+        DrawTextureRec(
+            data->game_viewport.texture,
+            draw_rec,
+            (Vector2){data->game_rec.x, data->game_rec.y},
+            WHITE
+        );
+    EndDrawing();
+}
+
+static inline unsigned int get_tile_idx(int x, int y, const TileGrid_t* tilemap)
+{
+    unsigned int tile_x = x / TILE_SIZE;
+    unsigned int tile_y = y / TILE_SIZE;
+
+    if (tile_x < tilemap->width && tile_y < tilemap->height)
+    {
+        return tile_y * tilemap->width + tile_x;
+    }
+
+    return MAX_N_TILES;
+}
+
+static void simple_friction_system(Scene_t* scene)
+{
+    CMovementState_t* p_mstate;
+    unsigned long ent_idx;
+    sc_map_foreach(&scene->ent_manager.component_map[CMOVEMENTSTATE_T], ent_idx, p_mstate)
+    {
+        Entity_t* p_ent =  get_entity(&scene->ent_manager, ent_idx);
+        CTransform_t* p_ctransform = get_component(p_ent, CTRANSFORM_COMP_T);
+        p_ctransform->fric_coeff = (Vector2){-4.5, -4.5};
+        p_ctransform->accel = Vector2Add(
+            p_ctransform->accel,
+            Vector2Multiply((Vector2){-3.0,-3.0}, p_ctransform->velocity)
+        );
+    }
+}
+
+static void level_do_action(Scene_t* scene, ActionType_t action, bool pressed)
+{
+    CPlayerState_t* p_playerstate;
+    sc_map_foreach_value(&scene->ent_manager.component_map[CPLAYERSTATE_T], p_playerstate)
+    {
+        switch(action)
+        {
+            case ACTION_UP:
+                p_playerstate->player_dir.y = (pressed)? -1 : 0;
+            break;
+            case ACTION_DOWN:
+                p_playerstate->player_dir.y = (pressed)? 1 : 0;
+            break;
+            case ACTION_LEFT:
+                p_playerstate->player_dir.x = (pressed)? -1 : 0;
+            break;
+            case ACTION_RIGHT:
+                p_playerstate->player_dir.x = (pressed)? 1 : 0;
+            break;
+            default:
+            break;
+        }
+    }
+    switch (action)
+    {
+        case ACTION_RESTART:
+            puts("Restarting!");
+        break;
+        default:
+        break;
+    }
+}
+
+static void player_simple_movement_system(Scene_t* scene)
+{
+    // Deal with player acceleration/velocity via inputs first
+    CPlayerState_t* p_pstate;
+    unsigned int ent_idx;
+    sc_map_foreach(&scene->ent_manager.component_map[CPLAYERSTATE_T], ent_idx, p_pstate)
+    {
+        Entity_t* p_player = get_entity(&scene->ent_manager, ent_idx);
+        CTransform_t* p_ctransform = get_component(p_player, CTRANSFORM_COMP_T);
+        p_ctransform->accel = Vector2Scale(Vector2Normalize(p_pstate->player_dir), MOVE_ACCEL);
+    }
+
+}
+
+int main(void)
+{
+    sc_queue_init(&key_buffer);
+    InitWindow(1280, 640, "raylib");
+    SetTargetFPS(60);
+    init_memory_pools();
+
+    init_assets(&engine.assets);
+    load_from_infofile("res/assets.info", &engine.assets);
+    init_player_creation("res/player_spr.info", &engine.assets);
+
+    LevelPack_t* pack = add_level_pack(&engine.assets, "TestLevels", "res/defaultLevels.lvldata");
+    assert(pack != NULL);
+
+    LevelScene_t scene;
+    scene.scene.engine = &engine;
+    init_scene(&scene.scene, &level_scene_render_func, &level_do_action);
+    init_level_scene_data(&scene.data);
+
+    pack = get_level_pack(&engine.assets, "TestLevels");
+    assert(pack != NULL);
+
+    scene.data.level_pack = pack;
+    scene.data.current_level = 0;
+
+    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];
+    // Level loading in here
+    for (size_t i = 0; i < scene.data.tilemap.n_tiles;i++)
+    {
+        all_tiles[i].max_water_level = 4;
+        all_tiles[i].solid = NOT_SOLID;
+        all_tiles[i].tile_type = EMPTY_TILE;
+        all_tiles[i].moveable = true;
+        all_tiles[i].size = (Vector2){TILE_SIZE, TILE_SIZE};
+
+        switch (lvl_map.tiles[i].tile_type)
+        {
+            case 1:
+                change_a_tile(&scene.data.tilemap, i, SOLID_TILE);
+            break;
+            case 2:
+                all_tiles[i].water_level = all_tiles[i].max_water_level;
+            break;
+            default:
+            break;
+        }
+
+        sc_map_init_64v(&all_tiles[i].entities_set, 16, 0);
+        switch (lvl_map.tiles[i].entity_to_spawn)
+        {
+            case 1:
+            {
+                Entity_t* ent = create_player(&scene.scene.ent_manager, &scene.scene.engine->assets);
+                CTransform_t* p_ct = get_component(ent, CTRANSFORM_COMP_T);
+                p_ct->position.x = i & scene.data.tilemap.width;
+                p_ct->position.y = i / scene.data.tilemap.width;
+            }
+            break;
+            default:
+            break;
+        }
+    }
+
+    update_entity_manager(&scene.scene.ent_manager);
+
+    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;
+    change_scene(&engine, 0);
+
+    sc_array_add(&scene.scene.systems, &player_simple_movement_system);
+    sc_array_add(&scene.scene.systems, &simple_friction_system);
+    sc_array_add(&scene.scene.systems, &movement_update_system);
+    sc_array_add(&scene.scene.systems, &update_tilemap_system);
+    sc_array_add(&scene.scene.systems, &update_water_runner_system);
+    sc_array_add(&scene.scene.systems, &camera_update_system);
+    sc_array_add(&scene.scene.systems, &player_dir_reset_system);
+
+
+    sc_map_put_64(&scene.scene.action_map, KEY_R, ACTION_RESTART);
+    sc_map_put_64(&scene.scene.action_map, KEY_UP, ACTION_UP);
+    sc_map_put_64(&scene.scene.action_map, KEY_DOWN, ACTION_DOWN);
+    sc_map_put_64(&scene.scene.action_map, KEY_LEFT, ACTION_LEFT);
+    sc_map_put_64(&scene.scene.action_map, KEY_RIGHT, ACTION_RIGHT);
+    sc_map_put_64(&scene.scene.action_map, KEY_P, ACTION_METAL_TOGGLE);
+
+
+    while(true)
+    {
+
+        // This entire key processing relies on the assumption that a pressed key will
+        // appear in the polling of raylib
+
+        unsigned int sz = sc_queue_size(&key_buffer);
+        // Process any existing pressed key
+        for (size_t i = 0; i < sz; i++)
+        {
+            int button = sc_queue_del_first(&key_buffer);
+            ActionType_t action = sc_map_get_64(&scene.scene.action_map, button);
+            if (IsKeyReleased(button))
+            {
+                do_action(&scene.scene, action, false);
+            }
+            else
+            {
+                do_action(&scene.scene, action, true);
+                sc_queue_add_last(&key_buffer, button);
+            }
+        }
+
+        // Detect new key presses
+        while(true)
+        {
+            int button = GetKeyPressed();
+            if (button == 0) break;
+            ActionType_t action = sc_map_get_64(&scene.scene.action_map, button);
+            if (!sc_map_found(&scene.scene.action_map)) continue;
+            do_action(&scene.scene, action, true);
+            sc_queue_add_last(&key_buffer, button);
+        }
+
+        update_scene(&scene.scene);
+        update_entity_manager(&scene.scene.ent_manager);
+        // This is needed to advance time delta
+        render_scene(&scene.scene);
+        if (WindowShouldClose()) break;
+    }
+
+    unsigned int m_id;
+    Entity_t* ent;
+    sc_map_foreach(&scene.scene.ent_manager.entities_map[DYNMEM_ENT_TAG], m_id, ent)
+    {
+        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);
+    CloseWindow();
+}

res/ldtk_repacker.py

@@ -52,7 +52,7 @@ converted_filename = '.'.join(fileparts)
 
 # Each level should be packed as: [width, 2 bytes][height, 2 bytes][tile_type,entity,water,padding 1,1,1,1 bytes][tile_type,entity,water,padding 1,1,1,1 bytes]...
 with open(converted_filename, 'wb+') as out_file:
-    out_file.write(struct.pack("I", n_levels))
+    out_file.write(struct.pack("<I", n_levels))
     # Then loop the levels. Read the layerIndstances
     for level in level_pack_data["levels"]:
         # Search for __identifier for the level layout
@@ -84,9 +84,9 @@ with open(converted_filename, 'wb+') as out_file:
                 x,y = ent["__grid"]
                 tiles_info[y*width + x][1] = ENTID_MAPPING[ent["__identifier"]]
 
-        out_file.write(struct.pack("32s2H", level_name.encode('utf-8'), width, height))
+        out_file.write(struct.pack("<32s2H", level_name.encode('utf-8'), width, height))
         for tile in tiles_info:
-            out_file.write(struct.pack("3Bx", *tile))
+            out_file.write(struct.pack("<3Bx", *tile))
 
 
         for y in range(height):

scenes/engine/assets.c

@@ -1,6 +1,8 @@
 #include "assets.h"
 #include "assert.h"
 
+#include <stdio.h>
+
 #define MAX_TEXTURES 16
 #define MAX_SPRITES 16
 #define MAX_SOUNDS 16
@@ -45,6 +47,11 @@ static LevelPackData_t levelpacks[MAX_LEVEL_PACK];
 
 static void unload_level_pack(LevelPack_t pack)
 {
+    for (uint8_t i = 0; i < pack.n_levels; ++i)
+    {
+        free(pack.levels[i].tiles);
+    }
+    free(pack.levels);
 }
 
 // Maybe need a circular buffer??
@@ -96,9 +103,39 @@ Font* add_font(Assets_t* assets, const char* name, const char* path)
     return &fonts[fnt_idx].font;
 }
 
-LevelTileInfo_t* add_level_pack(Assets_t* assets, const char* name, const char* path)
+LevelPack_t* add_level_pack(Assets_t* assets, const char* name, const char* path)
 {
-    return NULL;
+    FILE* file = fopen(path, "rb");
+    if (file == NULL) return NULL;
+
+    LevelPackData_t* pack_info = levelpacks + n_loaded[4];
+    fread(&pack_info->pack.n_levels, sizeof(uint32_t), 1, file);
+    pack_info->pack.levels = calloc(pack_info->pack.n_levels, sizeof(LevelMap_t));
+
+    for (uint8_t i = 0; i < pack_info->pack.n_levels; ++i)
+    {
+        fread(pack_info->pack.levels[i].level_name, sizeof(char), 32, file);
+        fread(&pack_info->pack.levels[i].width, sizeof(uint16_t), 1, file);
+        fread(&pack_info->pack.levels[i].height, sizeof(uint16_t), 1, file);
+        uint32_t n_tiles = pack_info->pack.levels[i].width * pack_info->pack.levels[i].height;
+
+        pack_info->pack.levels[i].tiles = calloc(n_tiles, sizeof(LevelTileInfo_t));
+        uint16_t dummy;
+        for (uint32_t j = 0; j < n_tiles; j++)
+        {
+            fread(&pack_info->pack.levels[i].tiles[j].tile_type, 1, 1, file);
+            fread(&pack_info->pack.levels[i].tiles[j].entity_to_spawn, 1, 1, file);
+            fread(&dummy, 2, 1, file);
+        }
+    }
+    
+    fclose(file);
+    uint8_t pack_idx = n_loaded[4];
+    strncpy(pack_info->name, name, MAX_NAME_LEN);
+    sc_map_put_s64(&assets->m_levelpacks, levelpacks[pack_idx].name, pack_idx);
+    n_loaded[4]++;
+
+    return &levelpacks[pack_idx].pack;
 }
 
 void init_assets(Assets_t* assets)
@@ -187,6 +224,16 @@ Font* get_font(Assets_t* assets, const char* name)
     return NULL;
 }
 
+LevelPack_t* get_level_pack(Assets_t* assets, const char* name)
+{
+    uint8_t pack_idx = sc_map_get_s64(&assets->m_levelpacks, name);
+    if (sc_map_found(&assets->m_levelpacks))
+    {
+        return &levelpacks[pack_idx].pack;
+    }
+    return NULL;
+}
+
 void draw_sprite(Sprite_t* spr, Vector2 pos, bool flip_x)
 {
     Rectangle rec = {

scenes/engine/assets.h

@@ -17,20 +17,19 @@ typedef struct LevelTileInfo
 {
     uint8_t tile_type;
     uint8_t entity_to_spawn;
-    uint8_t water;
 }LevelTileInfo_t;
 
 typedef struct LevelMap
 {
-    unsigned int width;
+    char level_name[32];
-    unsigned int height;
+    uint16_t width;
-    unsigned int n_tiles;
+    uint16_t height;
     LevelTileInfo_t* tiles;
 }LevelMap_t;
 
 typedef struct LevelPack
 {
-   unsigned int n_levels;
+   uint32_t n_levels;
    LevelMap_t* levels;
 }LevelPack_t;
 
@@ -42,13 +41,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);
+LevelPack_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);
+LevelPack_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,7 +25,7 @@ typedef struct LevelSceneData {
     Rectangle game_rec;
     Camera2D cam;
     Sprite_t* tile_sprites[MAX_TILE_TYPES];
-    LevelPack_t level_pack;
+    LevelPack_t* level_pack;
     unsigned int current_level;
 }LevelSceneData_t;