Remove dead code and add const

Changelog:
- Use atk and def values to determine whether a hitbox destroys a
  hurtbox

scenes/editor_scene.c

@@ -425,11 +425,12 @@ void init_level_scene(LevelScene_t* scene)
 
     sc_array_add(&scene->scene.systems, &moveable_update_system);
     sc_array_add(&scene->scene.systems, &movement_update_system);
+    sc_array_add(&scene->scene.systems, &boulder_destroy_wooden_tile_system);
     sc_array_add(&scene->scene.systems, &update_tilemap_system);
     sc_array_add(&scene->scene.systems, &tile_collision_system);
+    sc_array_add(&scene->scene.systems, &update_tilemap_system);
     sc_array_add(&scene->scene.systems, &hitbox_update_system);
     sc_array_add(&scene->scene.systems, &player_crushing_system);
-    //sc_array_add(&scene->scene.systems, &update_tilemap_system);
     sc_array_add(&scene->scene.systems, &state_transition_update_system);
     sc_array_add(&scene->scene.systems, &player_ground_air_transition_system);
     sc_array_add(&scene->scene.systems, &sprite_animation_system);

scenes/engine/EC/EC.h

@@ -26,6 +26,11 @@ typedef enum ComponentEnum {
     CMOVEABLE_T,
 } ComponentEnum_t;
 
+typedef enum MovementMode {
+    REGULAR_MOVEMENT = 0,
+    KINEMATIC_MOVEMENT,
+}MovementMode_t;
+
 typedef struct _CBBox_t {
     Vector2 size;
     Vector2 offset;
@@ -36,13 +41,14 @@ typedef struct _CBBox_t {
 
 typedef struct _CTransform_t {
     Vector2 prev_position;
+    Vector2 prev_velocity;
     Vector2 position;
     Vector2 velocity;
-    Vector2 prev_velocity;
     Vector2 accel;
     Vector2 fric_coeff;
     int8_t grav_delay;
     int8_t grav_timer;
+    MovementMode_t movement_mode;
 } CTransform_t;
 
 typedef struct _CMovementState_t {
@@ -102,13 +108,13 @@ typedef struct _CContainer_t {
 typedef struct _CHitBoxes_t {
     Rectangle boxes[2];
     uint8_t n_boxes;
-    bool strong;
+    uint8_t atk;
 } CHitBoxes_t;
 
 typedef struct _CHurtbox_t {
     Vector2 offset;
     Vector2 size;
-    bool fragile;
+    uint8_t def;
 } CHurtbox_t;
 
 // Credits to bedroomcoders.co.uk for this

scenes/game_systems.c

@@ -912,8 +912,6 @@ void moveable_update_system(Scene_t* scene)
 
         if (p_moveable->gridmove)
         {
-            memset(&p_ctransform->velocity, 0, sizeof(p_ctransform->velocity));
-            memset(&p_ctransform->accel, 0, sizeof(p_ctransform->velocity));
             float remaining_distance = p_moveable->target_pos.x - p_ctransform->position.x;
             if (fabs(remaining_distance) < 0.1)
             {
@@ -921,6 +919,7 @@ void moveable_update_system(Scene_t* scene)
                 p_ctransform->position = p_moveable->target_pos;
                 p_moveable->gridmove = false;
                 p_bbox->solid = true;
+                p_ctransform->movement_mode = REGULAR_MOVEMENT;
             }
             else if (remaining_distance > 0.1)
             {
@@ -929,6 +928,7 @@ void moveable_update_system(Scene_t* scene)
             else
             {
                 p_ctransform->position.x +=  (remaining_distance < -p_moveable->move_speed) ? -p_moveable->move_speed : remaining_distance;
+                memset(&p_ctransform->velocity, 0, sizeof(p_ctransform->velocity));
             }
         }
 
@@ -1035,6 +1035,9 @@ void moveable_update_system(Scene_t* scene)
                 p_bbox->solid = false;
                 p_moveable->prev_pos = p_ctransform->position;
                 p_moveable->target_pos = Vector2Scale((Vector2){tile_x,tile_y2}, TILE_SIZE); 
+                memset(&p_ctransform->velocity, 0, sizeof(p_ctransform->velocity));
+                memset(&p_ctransform->accel, 0, sizeof(p_ctransform->accel));
+                p_ctransform->movement_mode = KINEMATIC_MOVEMENT;
             }
 
         }
@@ -1119,6 +1122,9 @@ void player_pushing_system(Scene_t* scene)
                         p_other_moveable->gridmove = true;
                         p_other_moveable->prev_pos = p_other_ct->position;
                         p_other_moveable->target_pos = target_pos;
+                        memset(&p_ctransform->velocity, 0, sizeof(p_ctransform->velocity));
+                        memset(&p_ctransform->accel, 0, sizeof(p_ctransform->accel));
+                        p_other_ct->movement_mode = KINEMATIC_MOVEMENT;
                     }
                 }
             }
@@ -1137,11 +1143,15 @@ void movement_update_system(Scene_t* scene)
     sc_map_foreach(&scene->ent_manager.component_map[CTRANSFORM_COMP_T], ent_idx, p_ctransform)
     {
         p_ctransform->prev_velocity = p_ctransform->velocity;
+
+        if (p_ctransform->movement_mode == REGULAR_MOVEMENT)
+        {
             p_ctransform->velocity =
                 Vector2Add(
                     p_ctransform->velocity,
                     Vector2Scale(p_ctransform->accel, delta_time)
                 );
+        }
 
         float mag = Vector2Length(p_ctransform->velocity);
         p_ctransform->velocity = Vector2Scale(
@@ -1159,8 +1169,7 @@ void movement_update_system(Scene_t* scene)
             p_ctransform->position,
             Vector2Scale(p_ctransform->velocity, delta_time)
         );
-        p_ctransform->accel.x = 0;
-        p_ctransform->accel.y = 0;
+        memset(&p_ctransform->accel, 0, sizeof(p_ctransform->accel));
 
         // Level boundary collision
         Entity_t* p_ent =  get_entity(&scene->ent_manager, ent_idx);
@@ -1203,8 +1212,8 @@ void player_ground_air_transition_system(Scene_t* scene)
     sc_map_foreach_value(&scene->ent_manager.entities_map[PLAYER_ENT_TAG], p_player)
     {
         CJump_t* p_cjump = get_component(p_player, CJUMP_COMP_T);
-        CMovementState_t* p_mstate = get_component(p_player, CMOVEMENTSTATE_T);
-        CPlayerState_t* p_pstate = get_component(p_player, CPLAYERSTATE_T);
+        const CMovementState_t* p_mstate = get_component(p_player, CMOVEMENTSTATE_T);
+        const CPlayerState_t* p_pstate = get_component(p_player, CPLAYERSTATE_T);
 
         // Handle Ground<->Air Transition
         bool in_water = (p_mstate->water_state & 1);
@@ -1231,7 +1240,6 @@ void player_ground_air_transition_system(Scene_t* scene)
 void state_transition_update_system(Scene_t* scene)
 {
     LevelSceneData_t* data = &(CONTAINER_OF(scene, LevelScene_t, scene)->data);
-    //Entity_t* p_ent;
 
     CMovementState_t* p_mstate;
     unsigned long ent_idx;
@@ -1377,6 +1385,7 @@ void hitbox_update_system(Scene_t* scene)
                         if (p_other_hurtbox == NULL) continue;
                         CTransform_t* p_other_ct = get_component(p_other_ent, CTRANSFORM_COMP_T);
                         Vector2 hurtbox_pos = Vector2Add(p_other_ct->position, p_other_hurtbox->offset);
+                        if (p_hitbox->atk <= p_other_hurtbox->def) continue;
 
                         Vector2 overlap;
                         if (
@@ -1386,14 +1395,12 @@ void hitbox_update_system(Scene_t* scene)
                             )
                         )
                         {
-                            if (!p_other_hurtbox->fragile) continue;
                             //if (p_other_ent->m_tag == CRATES_ENT_TAG)
                             {
 
                                 CBBox_t* p_bbox = get_component(p_ent, CBBOX_COMP_T);
                                 CPlayerState_t* p_pstate = get_component(p_ent, CPLAYERSTATE_T);
                                 if (
-                                    // TODO: Check Material of the crates
                                     p_ctransform->position.y + p_bbox->size.y <= p_other_ct->position.y
                                 )
                                 {
@@ -1428,6 +1435,43 @@ void hitbox_update_system(Scene_t* scene)
     }
 }
 
+void boulder_destroy_wooden_tile_system(Scene_t* scene)
+{
+    LevelSceneData_t* data = &(CONTAINER_OF(scene, LevelScene_t, scene)->data);
+    TileGrid_t tilemap = data->tilemap;
+    Entity_t* p_boulder;
+    sc_map_foreach_value(&scene->ent_manager.entities_map[BOULDER_ENT_TAG], p_boulder)
+    {
+        const CTransform_t* p_ctransform = get_component(p_boulder, CTRANSFORM_COMP_T);
+        const CBBox_t* p_bbox = get_component(p_boulder, CBBOX_COMP_T);
+
+        if (p_ctransform->velocity.y <= 0) continue;
+
+        unsigned int tile_idx = get_tile_idx(
+                p_ctransform->position.x + p_bbox->half_size.x,
+                p_ctransform->position.y + p_bbox->size.y,
+                tilemap.width
+        );
+        unsigned int tile_x = (p_ctransform->position.x + p_bbox->half_size.x) / TILE_SIZE;
+
+        if (tilemap.tiles[tile_idx].tile_type == ONEWAY_TILE)
+        {
+            tilemap.tiles[tile_idx].tile_type = EMPTY_TILE;
+            tilemap.tiles[tile_idx].solid = NOT_SOLID;
+            if (tile_x > 0 && tilemap.tiles[tile_idx - 1].tile_type == ONEWAY_TILE)
+            {
+                tilemap.tiles[tile_idx - 1].tile_type = EMPTY_TILE;
+                tilemap.tiles[tile_idx - 1].solid = NOT_SOLID;
+            }
+            if (tile_x < tilemap.width && tilemap.tiles[tile_idx + 1].tile_type == ONEWAY_TILE)
+            {
+                tilemap.tiles[tile_idx + 1].tile_type = EMPTY_TILE;
+                tilemap.tiles[tile_idx + 1].solid = NOT_SOLID;
+            }
+        }
+    }
+}
+
 void sprite_animation_system(Scene_t* scene)
 {
     unsigned int ent_idx;
@@ -1491,7 +1535,6 @@ void camera_update_system(Scene_t* scene)
 
 void init_level_scene_data(LevelSceneData_t* data)
 {
-    //sc_map_init_32(&data->collision_events, 128, 0);
     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};
@@ -1501,6 +1544,5 @@ void init_level_scene_data(LevelSceneData_t* data)
 
 void term_level_scene_data(LevelSceneData_t* data)
 {
-    //sc_map_term_32(&data->collision_events);
     UnloadRenderTexture(data->game_viewport); // Unload render texture
 }

scenes/game_systems.h

@@ -18,6 +18,7 @@ void state_transition_update_system(Scene_t* scene);
 void update_tilemap_system(Scene_t* scene);
 void hitbox_update_system(Scene_t* scene);
 void sprite_animation_system(Scene_t* scene);
+void boulder_destroy_wooden_tile_system(Scene_t* scene);
 void camera_update_system(Scene_t* scene);
 void player_dir_reset_system(Scene_t* scene);
 void player_respawn_system(Scene_t* scene);

scenes/items_ent.c

@@ -16,7 +16,7 @@ Entity_t* create_crate(EntityManager_t* ent_manager, Assets_t* assets, bool meta
     add_component(p_crate, CTILECOORD_COMP_T);
     CHurtbox_t* p_hurtbox = add_component(p_crate, CHURTBOX_T);
     p_hurtbox->size = p_bbox->size;
-    p_hurtbox->fragile = !metal;
+    p_hurtbox->def = metal ? 2 : 1;
     return p_crate;
 }
 
@@ -37,6 +37,6 @@ Entity_t* create_boulder(EntityManager_t* ent_manager, Assets_t* assets)
     p_cmove->move_speed = 8;
     CHurtbox_t* p_hurtbox = add_component(p_boulder, CHURTBOX_T);
     p_hurtbox->size = p_bbox->size;
-    p_hurtbox->fragile = false;
+    p_hurtbox->def = 2;
     return p_boulder;
 }

scenes/player_ent.c

@@ -83,6 +83,7 @@ Entity_t* create_player(EntityManager_t* ent_manager, Assets_t* assets)
         .width = p_bbox->size.x + 2,
         .height = p_bbox->size.y - 1,
     };
+    p_hitbox->atk = 2;
     CSprite_t* p_cspr = add_component(p_ent, CSPRITE_T);
     p_cspr->sprites = player_sprite_map;
     p_cspr->transition_func = &player_sprite_transition_func;