Complete level data packing and loading

main.c

@@ -30,10 +30,13 @@ int main(void)
     init_memory_pools();
 
     init_assets(&engine.assets);
-    //load_from_infofile("res/assets.info", &engine.assets);
+#ifndef NDEBUG
-    //init_player_creation("res/player_spr.info", &engine.assets);
+    load_from_infofile("res/assets_debug.info", &engine.assets);
+    init_player_creation("res/player_spr.info", &engine.assets);
+#else
     load_from_rres("res/myresources.rres", &engine.assets);
     init_player_creation_rres("res/myresources.rres", "player_spr.info", &engine.assets);
+#endif
     init_item_creation(&engine.assets);
 
     LevelScene_t sandbox_scene;
@@ -43,6 +46,12 @@ int main(void)
     LevelScene_t level_scene;
     level_scene.scene.engine = &engine;
     init_game_scene(&level_scene);
+    level_scene.data.tile_sprites[ONEWAY_TILE] = get_sprite(&engine.assets, "tl_owp");
+    level_scene.data.tile_sprites[LADDER] = get_sprite(&engine.assets, "tl_ldr");
+    level_scene.data.tile_sprites[SPIKES] = get_sprite(&engine.assets, "d_spikes");
+    level_scene.data.tile_sprites[SPIKES + TILE_90CWROT] = get_sprite(&engine.assets, "l_spikes");
+    level_scene.data.tile_sprites[SPIKES + TILE_90CCWROT] = get_sprite(&engine.assets, "r_spikes");
+    level_scene.data.tile_sprites[SPIKES + TILE_180ROT] = get_sprite(&engine.assets, "u_spikes");
     LevelPack_t* pack = get_level_pack(&engine.assets, "TestLevels");
     if (pack != NULL)
     {

res/ldtk_repacker.py

@@ -16,19 +16,39 @@ with open(args.filename, 'r') as f:
 #pprint.pprint(level_pack_data)
 ENUMIDS_TILETYPE_MAPPING = {
     'Solid': 1,
-    'Water': 2
+    'WoodenPlat': 2,
+    'Ladder': 3,
+    'LSpike': 4,
+    'RSpike': 5,
+    'USpike': 6,
+    'DSpike': 7,
+    'EmptyWCrate': 8,
+    'LArrowWCrate': 9,
+    'RArrowWCrate': 10,
+    'UArrowWCrate': 11,
+    'DArrowWCrate': 12,
+    'BombWCrate': 13,
+    'EmptyMCrate': 14,
+    'LArrowMCrate': 15,
+    'RArrowMCrate': 16,
+    'UArrowMCrate': 17,
+    'DArrowMCrate': 18,
+    'BombMCrate': 19,
+    'Boulder': 20,
+    'Runner': 21,
+    'Player': 22,
 }
 
-ENTID_MAPPING = {
+#ENTID_MAPPING = {
-    'Player': 1
+#    'Player': 1
-}
+#}
 
 # First go to tilesets and find Simple_tiles identifier, then find enumTags to identifier which tile type is what tileid
 ids_tiletype_map = {}
 tileset_defs = level_pack_data["defs"]["tilesets"]
 
 for ts_def in tileset_defs:
-    if ts_def["identifier"] != "Simple_tiles":
+    if ts_def["identifier"] != "Items_spritesheet":
         continue
     for tag in ts_def["enumTags"]:
         ids_tiletype_map[tag["tileIds"][0]] =  ENUMIDS_TILETYPE_MAPPING[tag["enumValueId"]]
@@ -85,10 +105,10 @@ with open(converted_filename, 'wb+') as out_file:
         for i, water_level in enumerate(water_layout["intGridCsv"]):
             tiles_info[i][2] = water_level
 
+        # Subject to change
         for ent in entity_layout["entityInstances"]:
-            if ent["__identifier"] in ENTID_MAPPING:
+            x,y = ent["__grid"]
-                x,y = ent["__grid"]
+            tiles_info[y*width + x][0] = ENUMIDS_TILETYPE_MAPPING[ent["__identifier"]]
-                tiles_info[y*width + x][1] = ENTID_MAPPING[ent["__identifier"]]
 
         out_file.write(struct.pack("<32s2H", level_name.encode('utf-8'), width, height))
         for tile in tiles_info:

scenes/engine/EC/EC.h

@@ -221,11 +221,12 @@ static inline void set_bbox(CBBox_t* p_bbox, unsigned int x, unsigned int y)
 }
 
 struct Entity {
+    Vector2 spawn_pos;
     unsigned long m_id;
     unsigned int m_tag;
-    bool m_alive;
     unsigned long components[N_COMPONENTS]; 
     EntityManager_t* manager;
+    bool m_alive;
 };
 
 enum EntityUpdateEvent

scenes/engine/EC/entManager.c

@@ -101,6 +101,7 @@ Entity_t *add_entity(EntityManager_t* p_manager, unsigned int tag)
     Entity_t* p_ent = new_entity_from_mempool(&e_idx);
     if (p_ent == NULL) return NULL;
 
+    p_ent->spawn_pos = (Vector2){0, 0};
     p_ent->m_tag = tag;
     sc_queue_add_last(&p_manager->to_add, e_idx);
     p_ent->manager = p_manager;

scenes/game_systems.c

@@ -208,10 +208,9 @@ void player_respawn_system(Scene_t* scene)
                 memcpy(&new_ct->position, &p_ct->position, sizeof(p_ct->position));
             }
             p_player->m_alive = true;
-            memset(&p_ct->position, 0, sizeof(p_ct->position));
+            p_ct->position = p_player->spawn_pos;
             memset(&p_ct->velocity, 0, sizeof(p_ct->velocity));
             memset(&p_ct->accel, 0, sizeof(p_ct->accel));
-
         }
     }
 }

scenes/scene_systems.c

@@ -1,4 +1,5 @@
 #include "scene_impl.h"
+#include "water_flow.h"
 #include "ent_impl.h"
 #include "constants.h"
 
@@ -72,30 +73,82 @@ bool load_level_tilemap(LevelScene_t* scene, unsigned int level_num)
         scene->data.tilemap.tiles[i].moveable = true;
         scene->data.tilemap.tiles[i].size = (Vector2){TILE_SIZE, TILE_SIZE};
         sc_map_clear_64v(&scene->data.tilemap.tiles[i].entities_set);
-
+        
-        switch (lvl_map.tiles[i].tile_type)
+        if (lvl_map.tiles[i].tile_type == 1)
         {
-            case 1:
                 change_a_tile(&scene->data.tilemap, i, SOLID_TILE);
-            break;
-            default:
-            break;
         }
-        switch (lvl_map.tiles[i].entity_to_spawn)
+
-        {
+                scene->data.tilemap.tiles[i].water_level = lvl_map.tiles[i].water;
-            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) * scene->data.tilemap.tile_size;
-                p_ct->position.y = (i / scene->data.tilemap.width) * scene->data.tilemap.tile_size;
-            }
-            break;
-            default:
-            break;
-        }
-        scene->data.tilemap.tiles[i].water_level = lvl_map.tiles[i].water;
     }
+    // Two pass
+    for (size_t i = 0; i < scene->data.tilemap.n_tiles;i++)
+    {
+        if (lvl_map.tiles[i].tile_type >= 8 && lvl_map.tiles[i].tile_type < 20)
+        {
+            uint32_t tmp_idx = lvl_map.tiles[i].tile_type - 8;
+            uint32_t item_type = tmp_idx % 6;
+            ContainerItem_t item = CONTAINER_EMPTY;
+            switch (item_type)
+            {
+                case 1: item = CONTAINER_LEFT_ARROW;break;
+                case 2: item = CONTAINER_RIGHT_ARROW;break;
+                case 3: item = CONTAINER_UP_ARROW;break;
+                case 4: item = CONTAINER_DOWN_ARROW;break;
+                case 5: item = CONTAINER_BOMB;break;
+                default: break;
+            }
+
+            Entity_t* ent = create_crate(&scene->scene.ent_manager, &scene->scene.engine->assets, tmp_idx > 5, item);
+            CTransform_t* p_ct = get_component(ent, CTRANSFORM_COMP_T);
+            p_ct->position.x = (i % scene->data.tilemap.width) * scene->data.tilemap.tile_size;
+            p_ct->position.y = (i / scene->data.tilemap.width) * scene->data.tilemap.tile_size;
+        }
+        else
+        {
+        
+            switch (lvl_map.tiles[i].tile_type)
+            {
+                case 2:
+                    change_a_tile(&scene->data.tilemap, i, ONEWAY_TILE);
+                break;
+                case 3:
+                    change_a_tile(&scene->data.tilemap, i, LADDER);
+                break;
+                case 4:
+                case 5:
+                case 6:
+                case 7:
+                    change_a_tile(&scene->data.tilemap, i, SPIKES);
+                break;
+                case 20:
+                {
+                    Entity_t* ent = create_boulder(&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) * scene->data.tilemap.tile_size;
+                    p_ct->position.y = (i / scene->data.tilemap.width) * scene->data.tilemap.tile_size;
+                }
+                break;
+                case 21:
+                {
+                    create_water_runner(&scene->scene.ent_manager, lvl_map.width, lvl_map.height, i);
+                }
+                break;
+                case 22:
+                {
+                    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) * scene->data.tilemap.tile_size;
+                    p_ct->position.y = (i / scene->data.tilemap.width) * scene->data.tilemap.tile_size;
+                    ent->spawn_pos = p_ct->position;
+                }
+                break;
+                default:
+                break;
+            }
+        }
+    }
+
     return true;
 }