Add parsing for urchins

engine/assets.c

@@ -275,7 +275,7 @@ static LevelPack_t* add_level_pack_zst(Assets_t* assets, const char* name, const
     for (lvls = 0; lvls < n_levels; ++lvls)
     {
         printf("Parsing level %u\n", lvls);
-        output.size = 38;
+        output.size = 40;
         output.pos = 0;
 
         do
@@ -311,6 +311,7 @@ static LevelPack_t* add_level_pack_zst(Assets_t* assets, const char* name, const
         memcpy(&pack_info->pack.levels[lvls].width, level_decompressor.out_buffer + 32, 2);
         memcpy(&pack_info->pack.levels[lvls].height, level_decompressor.out_buffer + 34, 2);
         memcpy(&pack_info->pack.levels[lvls].n_chests, level_decompressor.out_buffer + 36, 2);
+        memcpy(&pack_info->pack.levels[lvls].flags, level_decompressor.out_buffer + 38, 2);
         pack_info->pack.levels[lvls].level_name[31] = '\0';
         printf("Level name: %s\n", pack_info->pack.levels[lvls].level_name);
         printf("WxH: %u %u\n", pack_info->pack.levels[lvls].width, pack_info->pack.levels[lvls].height);

engine/assets.h

@@ -59,6 +59,7 @@ typedef struct LevelMap
     uint16_t width;
     uint16_t height;
     uint16_t n_chests;
+    uint16_t flags; // In case of extras
     LevelTileInfo_t* tiles;
 }LevelMap_t;
 

res/ldtk_repacker.py

@@ -39,12 +39,9 @@ ENUMIDS_TILETYPE_MAPPING = {
     'Player': 22,
     'Chest': 23,
     'Exit': 24,
+    'Urchin': 25,
 }
 
-#ENTID_MAPPING = {
-#    '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"]
@@ -61,8 +58,18 @@ if not ids_tiletype_map:
 
 pprint.pprint(ids_tiletype_map)
 
+def get_level_order(lvl) -> int:
+    order = 65535;
+    for data in lvl['fieldInstances']:
+        if data["__identifier"] == "Order":
+            order = data["__value"]
+    return order
+
+all_levels = level_pack_data["levels"]
+all_levels.sort(key=get_level_order)
+
 # Number of levels is the length of the levels
-n_levels = len(level_pack_data["levels"])
+n_levels = len(all_levels)
 print("Number of levels:", n_levels)
 
 fileparts = args.filename.split('.')
@@ -76,12 +83,20 @@ converted_filename = '.'.join(fileparts)
 with open(converted_filename, 'wb+') as out_file:
     out_file.write(struct.pack("<I", n_levels))
     # Then loop the levels. Read the layerIndstances
-    for level in level_pack_data["levels"]:
+    for level in all_levels:
         n_chests : int = 0
         # Search for __identifier for the level layout
-        level_name = level["identifier"]
-        print("Parsing level", level_name)
+        level_name = "" 
 
+        level_metadata = level['fieldInstances']
+        level_tileset = 0;
+        for data in level_metadata:
+            if data["__identifier"] == "TileSet":
+                level_tileset = data["__value"]
+            if data["__identifier"] == "Name":
+                level_name = data["__value"]
+
+        print("Parsing level", level_name)
 
         level_layout = {}
         entity_layout = {}
@@ -97,7 +112,7 @@ with open(converted_filename, 'wb+') as out_file:
         # Dimensions of each level is obtained via __cWid and __cHei. Get the __gridSize as well
         width = level_layout["__cWid"]
         height = level_layout["__cHei"]
-        print(f"Dim.: {width}x{height}")
+        print(f"Dim.: {width}x{height}. N Tiles: {width * height}")
         # Create a W x H array of tile information
         n_tiles = width * height
         tiles_info = [[0,0,0] for _ in range(n_tiles)]
@@ -119,8 +134,17 @@ with open(converted_filename, 'wb+') as out_file:
         for ent in entity_layout["entityInstances"]:
             x,y = ent["__grid"]
             tiles_info[y*width + x][0] = ENUMIDS_TILETYPE_MAPPING[ent["__identifier"]]
+            if ent["__identifier"] == "Urchin":
+                spd_encoding = 0
+                for urchin_data in ent['fieldInstances']:
+                    if urchin_data["__identifier"] == "Direction":
+                        spd_encoding |= urchin_data["__value"] << 2
+                    elif urchin_data["__identifier"] == "SpeedLevel":
+                        spd_encoding |= urchin_data["__value"]
 
-        out_file.write(struct.pack("<32s3H", level_name.encode('utf-8'), width, height, n_chests))
+                tiles_info[y*width + x][0] += spd_encoding
+
+        out_file.write(struct.pack("<32s4H", level_name.encode('utf-8'), width, height, n_chests, level_tileset))
         for tile in tiles_info:
             out_file.write(struct.pack("<3Bx", *tile))
 

scenes/constants.h

@@ -19,7 +19,7 @@
 
 #define DELTA_T 0.017
 #define GRAV_ACCEL 1500
-#define JUMP_SPEED 70
+#define JUMP_SPEED 600
 #define MOVE_ACCEL 1300
 
 #ifndef TILE16_SIZE

scenes/game_systems.c

@@ -1739,7 +1739,7 @@ void hitbox_update_system(Scene_t* scene)
                                             }
                                             else
                                             {
-                                                p_clifetimer->life_time = 0.05f;
+                                                p_clifetimer->life_time = 0.1f;
                                             }
                                         }
                                         else

scenes/items_ent.c

@@ -233,7 +233,7 @@ Entity_t* create_explosion(EntityManager_t* ent_manager)
     CTransform_t* p_ctransform = add_component(p_explosion, CTRANSFORM_COMP_T);
     p_ctransform->movement_mode = KINEMATIC_MOVEMENT;
     p_ctransform->active = true;
-    const int hitbox_sz = TILE_SIZE + 40;
+    const int hitbox_sz = (TILE_SIZE << 1) + (TILE_SIZE >> 1);
     p_hitbox->boxes[0] = (Rectangle){-(hitbox_sz >> 1), -(hitbox_sz >> 1), hitbox_sz, hitbox_sz};
 
     CSprite_t* p_cspr = add_component(p_explosion, CSPRITE_T);

scenes/level_select_scene.c

@@ -97,10 +97,10 @@ static void level_select_do_action(Scene_t* scene, ActionType_t action, bool pre
     }
 }
 
-#define FONT_SIZE 30
+#define FONT_SIZE 15
 #define TEXT_PADDING 3
-#define DISPLAY_AREA_HEIGHT 200
-#define SCROLL_TOTAL_HEIGHT 300
+#define DISPLAY_AREA_HEIGHT 400
+#define SCROLL_TOTAL_HEIGHT 400
 void init_level_select_scene(LevelSelectScene_t* scene)
 {
     init_scene(&scene->scene, &level_select_do_action, 0);

scenes/player_ent.c

@@ -75,7 +75,7 @@ Entity_t* create_player(EntityManager_t* ent_manager)
     p_ct->shape_factor = (Vector2){1, 1};
 
     CJump_t* p_cjump = add_component(p_ent, CJUMP_COMP_T);
-    p_cjump->jump_speed = 680;
+    p_cjump->jump_speed = JUMP_SPEED;
     p_cjump->jumps = 1;
     p_cjump->max_jumps = 1;
     p_cjump->jump_ready = true;

scenes/scene_systems.c

@@ -3,6 +3,8 @@
 #include "ent_impl.h"
 #include "constants.h"
 
+#include "raymath.h"
+
 void init_level_scene_data(LevelSceneData_t* data, uint32_t max_tiles, Tile_t* tiles, Rectangle view_zone)
 {
     data->game_rec = view_zone;
@@ -106,6 +108,13 @@ bool load_level_tilemap(LevelScene_t* scene, unsigned int level_num)
     scene->data.coins.current = 0;
     scene->data.coins.total = lvl_map.n_chests;
 
+    #define N_SOLID_TILESETS 3
+    static const char* SOLID_TILE_SELECTIONS[N_SOLID_TILESETS] = {
+        "stile0", "stile1", "stile2"
+    };
+    scene->data.selected_solid_tilemap = lvl_map.flags;
+    scene->data.solid_tile_sprites = get_sprite(&scene->scene.engine->assets, SOLID_TILE_SELECTIONS[lvl_map.flags]);
+
     clear_all_game_entities(scene);
 
     for (size_t i = 0; i < scene->data.tilemap.n_tiles;i++)
@@ -206,9 +215,31 @@ bool load_level_tilemap(LevelScene_t* scene, unsigned int level_num)
                     }
                 }
                 break;
+   
                 default:
                 break;
             }
+
+            if (lvl_map.tiles[i].tile_type >= 25) 
+            {
+                Entity_t* ent = create_urchin(&scene->scene.ent_manager);
+                if (ent != NULL)
+                {
+                    CBBox_t* p_bbox = get_component(ent, CBBOX_COMP_T);
+                    ent->position.x = (i % scene->data.tilemap.width) * scene->data.tilemap.tile_size + (scene->data.tilemap.tile_size >> 1) - p_bbox->half_size.x;
+
+                    ent->position.y = (i / scene->data.tilemap.width) * scene->data.tilemap.tile_size + (scene->data.tilemap.tile_size >> 1) + (scene->data.tilemap.tile_size >> 1) - p_bbox->half_size.y;
+
+                    uint8_t spd_encoding = lvl_map.tiles[i].tile_type - 25;
+                    float angle = 45.0f / 180.0f * PI * ((spd_encoding >> 2) & 7);
+                    float mag = 100 * (spd_encoding & 3);
+
+                    CTransform_t* p_ct = get_component(ent, CTRANSFORM_COMP_T);
+                    p_ct->velocity = Vector2Scale(
+                        (Vector2){cosf(angle), sinf(angle)}, mag
+                    );
+                }
+            }
         }
     }