Add player interaction with bomb crates

Changelog:
- Add damage source for hurtboxes
- Add logic to handle player as damage source for bomb crates

scenes/editor_scene.c

@@ -21,10 +21,11 @@ enum EntitySpawnSelection {
     SPAWN_CRATE_ARROW_R,
     SPAWN_CRATE_ARROW_U,
     SPAWN_CRATE_ARROW_D,
+    SPAWN_CRATE_BOMB,
     SPAWN_BOULDER,
 };
 
-#define MAX_SPAWN_TYPE 11
+#define MAX_SPAWN_TYPE 12
 static unsigned int current_spawn_selection = 0;
 static bool metal_toggle = false;
 
@@ -195,6 +196,9 @@ static void level_scene_render_func(Scene_t* scene)
                                     BLACK
                                 );
                             break;
+                            case CONTAINER_BOMB:
+                                DrawCircleV(Vector2Add(p_ct->position, p_bbox->half_size), p_bbox->half_size.x, BLACK);
+                            break;
                             default:
                             break;
                         }
@@ -287,7 +291,7 @@ static void level_scene_render_func(Scene_t* scene)
         const Color crate_colour = metal_toggle ? GRAY : BROWN;
         const Color draw_colour[MAX_SPAWN_TYPE] = {
             BLACK, MAROON, ORANGE, ColorAlpha(RAYWHITE, 0.5), ColorAlpha(BLUE, 0.5),
-            crate_colour, crate_colour, crate_colour, crate_colour, crate_colour,
+            crate_colour, crate_colour, crate_colour, crate_colour, crate_colour, crate_colour,
             ColorAlpha(RAYWHITE, 0.5)
         };
         for (uint8_t i = 0; i < MAX_SPAWN_TYPE; ++i)
@@ -340,6 +344,9 @@ static void level_scene_render_func(Scene_t* scene)
                             BLACK
                         );
                     break;
+                    case SPAWN_CRATE_BOMB:
+                        DrawCircleV(Vector2Add(draw_pos, half_size), half_size.x, BLACK);
+                    break;
                 }
             }
             draw_pos.x += SELECTION_TILE_SIZE;
@@ -396,6 +403,9 @@ static void level_scene_render_func(Scene_t* scene)
                     BLACK
                 );
             break;
+            case SPAWN_CRATE_BOMB:
+                DrawCircleV(Vector2Add(draw_pos, half_size), half_size.x, BLACK);
+            break;
         }
 
         // For DEBUG
@@ -520,6 +530,9 @@ static void toggle_block_system(Scene_t* scene)
             case SPAWN_CRATE_ARROW_D:
                 spawn_crate(scene, tile_idx, metal_toggle, CONTAINER_DOWN_ARROW);
             break;
+            case SPAWN_CRATE_BOMB:
+                spawn_crate(scene, tile_idx, metal_toggle, CONTAINER_BOMB);
+            break;
             }
             change_a_tile(&tilemap, tile_idx, new_type);
             last_tile_idx = tile_idx;
@@ -647,6 +660,7 @@ void init_level_scene(LevelScene_t* scene)
     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, &container_destroy_system);
+    sc_array_add(&scene->scene.systems, &lifetimer_update_system);
     sc_array_add(&scene->scene.systems, &sprite_animation_system);
     sc_array_add(&scene->scene.systems, &camera_update_system);
     sc_array_add(&scene->scene.systems, &player_dir_reset_system);

scenes/engine/EC/EC.h

@@ -7,7 +7,7 @@
 #include "sc/queue/sc_queue.h"
 
 #define N_TAGS 8
-#define N_COMPONENTS 11
+#define N_COMPONENTS 12
 #define MAX_COMP_POOL_SIZE 1024
 typedef struct EntityManager EntityManager_t;
 typedef struct Entity Entity_t;
@@ -24,6 +24,7 @@ typedef enum ComponentEnum {
     CHURTBOX_T,
     CSPRITE_T,
     CMOVEABLE_T,
+    CLIFETIMER_T,
 } ComponentEnum_t;
 
 typedef enum MovementMode {
@@ -94,6 +95,7 @@ typedef enum ContainerItem {
     CONTAINER_DOWN_ARROW,
     CONTAINER_COIN,
     CONTAINER_BOMB,
+    CONTAINER_EXPLOSION,
 } ContainerItem_t;
 
 typedef enum ContainerMaterial {
@@ -117,8 +119,14 @@ typedef struct _CHurtbox_t {
     Vector2 offset;
     Vector2 size;
     uint8_t def;
+    unsigned int damage_src;
 } CHurtbox_t;
 
+typedef struct _CLifeTimer_t {
+    uint8_t timer;
+    uint8_t life_time;
+} CLifeTimer_t;
+
 // Credits to bedroomcoders.co.uk for this
 typedef struct Sprite {
     Texture2D* texture;
@@ -170,6 +178,22 @@ struct Entity {
     EntityManager_t* manager;
 };
 
+enum EntityUpdateEvent
+{
+    COMP_ADDTION,
+    COMP_DELETION,
+};
+
+struct EntityUpdateEventInfo
+{
+    unsigned long e_id;
+    ComponentEnum_t comp_type;
+    unsigned long c_id;
+    enum EntityUpdateEvent evt_type;
+};
+
+sc_queue_def(struct EntityUpdateEventInfo, ent_evt);
+
 struct EntityManager {
     // All fields are Read-Only
     struct sc_map_64v entities; // ent id : entity
@@ -177,6 +201,7 @@ struct EntityManager {
     struct sc_map_64v component_map[N_COMPONENTS]; // [{ent id: comp}, ...]
     struct sc_queue_uint to_add;
     struct sc_queue_uint to_remove;
+    struct sc_queue_ent_evt to_update;
 };
 
 void init_entity_manager(EntityManager_t* p_manager);

scenes/engine/EC/entManager.c

@@ -13,6 +13,7 @@ void init_entity_manager(EntityManager_t* p_manager)
     }
     sc_queue_init(&p_manager->to_add);
     sc_queue_init(&p_manager->to_remove);
+    sc_queue_init(&p_manager->to_update);
 }
 
 void update_entity_manager(EntityManager_t* p_manager)
@@ -28,16 +29,14 @@ void update_entity_manager(EntityManager_t* p_manager)
         if (!p_entity) continue;
         for (size_t i = 0; i < N_COMPONENTS; ++i)
         {
-            if (p_entity->components[i] == MAX_COMP_POOL_SIZE) continue;
-
-            free_component_to_mempool((ComponentEnum_t)i, p_entity->components[i]);
-            sc_map_del_64v(&p_manager->component_map[i], e_idx);
-            sc_map_del_64v(&p_manager->entities_map[p_entity->m_tag], e_idx);
+            remove_component(p_entity, i);
         }
+        sc_map_del_64v(&p_manager->entities_map[p_entity->m_tag], e_idx);
         free_entity_to_mempool(e_idx);
         sc_map_del_64v(&p_manager->entities, e_idx);
     }
     sc_queue_clear(&p_manager->to_remove);
+
     sc_queue_foreach (&p_manager->to_add, e_idx)
     {
         Entity_t *p_entity = get_entity_wtih_id(e_idx);
@@ -45,6 +44,22 @@ void update_entity_manager(EntityManager_t* p_manager)
         sc_map_put_64v(&p_manager->entities_map[p_entity->m_tag], e_idx, (void *)p_entity);
     }
     sc_queue_clear(&p_manager->to_add);
+
+    struct EntityUpdateEventInfo evt;
+    sc_queue_foreach (&p_manager->to_update, evt)
+    {
+        switch(evt.evt_type)
+        {
+            case COMP_ADDTION:
+                sc_map_put_64v(&p_manager->component_map[evt.comp_type], evt.e_id, get_component_wtih_id(evt.comp_type, evt.c_id));
+            break;
+            case COMP_DELETION:
+                sc_map_del_64v(&p_manager->component_map[evt.comp_type], evt.e_id);
+                free_component_to_mempool(evt.comp_type, evt.c_id);
+            break;
+        }
+    }
+    sc_queue_clear(&p_manager->to_add);
 }
 
 void clear_entity_manager(EntityManager_t* p_manager)
@@ -72,6 +87,7 @@ void free_entity_manager(EntityManager_t* p_manager)
     }
     sc_queue_term(&p_manager->to_add);
     sc_queue_term(&p_manager->to_remove);
+    sc_queue_term(&p_manager->to_update);
 }
 
 Entity_t *add_entity(EntityManager_t* p_manager, unsigned int tag)
@@ -107,17 +123,15 @@ Entity_t* get_entity(EntityManager_t* p_manager, unsigned long id)
     return p_entity;
 }
 
-// Components are not expected to be removed
-// So, no need to extra steps to deal with iterator invalidation
 void* add_component(Entity_t* p_entity, ComponentEnum_t comp_type)
 {
-    unsigned long comp_type_idx = (unsigned long)comp_type;
     unsigned long comp_idx = 0;
     void* p_comp = new_component_from_mempool(comp_type, &comp_idx);
     if (p_comp)
     {
         p_entity->components[comp_type] = comp_idx;
-        sc_map_put_64v(&p_entity->manager->component_map[comp_type_idx], p_entity->m_id, p_comp);
+        struct EntityUpdateEventInfo evt = (struct EntityUpdateEventInfo){p_entity->m_id, comp_type, comp_idx, COMP_ADDTION};
+        sc_queue_add_last(&p_entity->manager->to_update, evt);
     }
     return p_comp;
 }
@@ -125,15 +139,14 @@ void* add_component(Entity_t* p_entity, ComponentEnum_t comp_type)
 void* get_component(Entity_t *p_entity, ComponentEnum_t comp_type)
 {
     unsigned long comp_type_idx = (unsigned long)comp_type;
-    void * p_comp = sc_map_get_64v(&p_entity->manager->component_map[comp_type_idx], p_entity->m_id);
-    if (!sc_map_found(&p_entity->manager->component_map[comp_type_idx])) return NULL;
-    return p_comp;
+    unsigned long c_idx = p_entity->components[comp_type_idx];
+    if (c_idx == MAX_COMP_POOL_SIZE) return NULL;
+    return get_component_wtih_id(comp_type, c_idx);
 }
 
 void remove_component(Entity_t *p_entity, ComponentEnum_t comp_type)
 {
-    unsigned long comp_type_idx = (unsigned long)comp_type;
     if (p_entity->components[comp_type] == MAX_COMP_POOL_SIZE) return;
-    sc_map_del_64v(&p_entity->manager->component_map[comp_type_idx], p_entity->m_id);
-    free_component_to_mempool(comp_type, p_entity->components[comp_type]);
+    struct EntityUpdateEventInfo evt = (struct EntityUpdateEventInfo){p_entity->m_id, comp_type, p_entity->components[comp_type] , COMP_DELETION};
+    sc_queue_add_last(&p_entity->manager->to_update, evt);
 }

scenes/engine/EC/mempool.c

@@ -18,6 +18,7 @@ static CHitBoxes_t chitboxes_buffer[MAX_COMP_POOL_SIZE];
 static CHurtbox_t churtbox_buffer[MAX_COMP_POOL_SIZE];
 static CSprite_t csprite_buffer[MAX_COMP_POOL_SIZE];
 static CMoveable_t cmoveable_buffer[MAX_COMP_POOL_SIZE];
+static CLifeTimer_t clifetimer_buffer[MAX_COMP_POOL_SIZE];
 
 typedef struct ULongCircBuffer {
     unsigned long* buffer;     // data buffer
@@ -88,6 +89,7 @@ static MemPool_t comp_mempools[N_COMPONENTS] = {
     {churtbox_buffer, MAX_COMP_POOL_SIZE, sizeof(CHurtbox_t), NULL, {0}},
     {csprite_buffer, MAX_COMP_POOL_SIZE, sizeof(CSprite_t), NULL, {0}},
     {cmoveable_buffer, MAX_COMP_POOL_SIZE, sizeof(CMoveable_t), NULL, {0}},
+    {clifetimer_buffer, MAX_COMP_POOL_SIZE, sizeof(CLifeTimer_t), NULL, {0}},
 };
 static MemPool_t ent_mempool = {
     .buffer = entity_buffer,

scenes/ent_impl.h

@@ -8,7 +8,7 @@ typedef enum EntityTag {
     ENEMY_ENT_TAG,
     CRATES_ENT_TAG,
     BOULDER_ENT_TAG,
-    ARROW_ENT_TAG,
+    DESTRUCTABLE_ENT_TAG,
 } EntityTag_t;
 
 
@@ -17,5 +17,7 @@ Entity_t* create_player(EntityManager_t* ent_manager, Assets_t* assets);
 Entity_t* create_crate(EntityManager_t* ent_manager, Assets_t* assets, bool metal, ContainerItem_t item);
 Entity_t* create_boulder(EntityManager_t* ent_manager, Assets_t* assets);
 Entity_t* create_arrow(EntityManager_t* ent_manager, Assets_t* assets, uint8_t dir);
+Entity_t* create_bomb(EntityManager_t* ent_manager, Assets_t* assets, Vector2 launch_dir);
+Entity_t* create_explosion(EntityManager_t* ent_manager, Assets_t* assets);
 
 #endif // __ENT_IMPL_H

scenes/game_systems.c

@@ -1114,6 +1114,12 @@ void global_external_forces_system(Scene_t* scene)
             continue;
         }
 
+        Vector2 half_size = {0, 0};
+        if (p_bbox != NULL)
+        {
+            half_size = p_bbox->half_size;
+        }
+
         if (!(p_mstate->ground_state & 1))
         {
             // Only apply upthrust if center is in water
@@ -1121,8 +1127,8 @@ void global_external_forces_system(Scene_t* scene)
             if (p_mstate->water_state & 1)
             {
                 unsigned int tile_idx = get_tile_idx(
-                    p_ctransform->position.x + p_bbox->half_size.x,
-                    p_ctransform->position.y + p_bbox->half_size.y,
+                    p_ctransform->position.x + half_size.x,
+                    p_ctransform->position.y + half_size.y,
                     data->tilemap.width
                 );
 
@@ -1139,6 +1145,8 @@ void global_external_forces_system(Scene_t* scene)
             p_ctransform->accel,
             Vector2Multiply(p_ctransform->fric_coeff, p_ctransform->velocity)
         );
+        
+        if (p_bbox == NULL) continue; //Do not proceed if no bbox
 
 
         // Zero out acceleration for contacts with sturdy entites and tiles
@@ -1667,6 +1675,7 @@ void hitbox_update_system(Scene_t* scene)
                 for (unsigned int tile_x = tile_x1; tile_x <= tile_x2; tile_x++)
                 {
                     unsigned int tile_idx = tile_y * tilemap.width + tile_x;
+                    if (tile_idx >= tilemap.n_tiles) break;
                     unsigned int other_ent_idx;
                     Entity_t* p_other_ent;
                     Vector2 overlap;
@@ -1707,7 +1716,6 @@ 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;
 
                         if (
                             find_AABB_overlap(
@@ -1716,27 +1724,31 @@ void hitbox_update_system(Scene_t* scene)
                             )
                         )
                         {
-                            if (p_other_ent->m_tag == CRATES_ENT_TAG)
+                            if (p_hitbox->atk > p_other_hurtbox->def)
                             {
-
-                                CBBox_t* p_bbox = get_component(p_ent, CBBOX_COMP_T);
-                                CPlayerState_t* p_pstate = get_component(p_ent, CPLAYERSTATE_T);
-                                if (
-                                    p_pstate != NULL
-                                    && p_ctransform->position.y + p_bbox->size.y <= p_other_ct->position.y
-                                )
+                                p_other_hurtbox->damage_src = ent_idx;
+                                if (p_other_ent->m_tag == CRATES_ENT_TAG)
                                 {
-                                    p_ctransform->velocity.y = -400;
-                                    if (p_pstate->jump_pressed)
+
+                                    CBBox_t* p_bbox = get_component(p_ent, CBBOX_COMP_T);
+                                    CPlayerState_t* p_pstate = get_component(p_ent, CPLAYERSTATE_T);
+                                    if (
+                                        p_pstate != NULL
+                                        && p_ctransform->position.y + p_bbox->size.y <= p_other_ct->position.y
+                                    )
                                     {
-                                        p_ctransform->velocity.y = -600;
-                                        CJump_t * p_cjump = get_component(p_ent, CJUMP_COMP_T);
-                                        p_cjump->short_hop = false;
-                                        p_cjump->jumped = true;
+                                        p_ctransform->velocity.y = -400;
+                                        if (p_pstate->jump_pressed)
+                                        {
+                                            p_ctransform->velocity.y = -600;
+                                            CJump_t * p_cjump = get_component(p_ent, CJUMP_COMP_T);
+                                            p_cjump->short_hop = false;
+                                            p_cjump->jumped = true;
+                                        }
                                     }
                                 }
+                                remove_entity_from_tilemap(&scene->ent_manager, &tilemap, p_other_ent);
                             }
-                            remove_entity_from_tilemap(&scene->ent_manager, &tilemap, p_other_ent);
 
                             if (p_hitbox->one_hit)
                             {
@@ -1801,6 +1813,14 @@ void container_destroy_system(Scene_t* scene)
         Entity_t* p_ent =  get_entity(&scene->ent_manager, ent_idx);
         if (!p_ent->m_alive)
         {
+
+            Entity_t* dmg_src = NULL;
+            CHurtbox_t* p_hurtbox = get_component(p_ent, CHURTBOX_T);
+            if(p_hurtbox != NULL)
+            {
+                dmg_src = get_entity(&scene->ent_manager, p_hurtbox->damage_src);
+            }
+
             Entity_t* new_ent;
             switch (p_container->item)
             {
@@ -1816,6 +1836,32 @@ void container_destroy_system(Scene_t* scene)
                 case CONTAINER_DOWN_ARROW:
                     new_ent = create_arrow(&scene->ent_manager, &scene->engine->assets, 3);
                 break;
+                case CONTAINER_BOMB:
+                    if (dmg_src != NULL && dmg_src->m_tag == PLAYER_ENT_TAG)
+                    {
+                        const CTransform_t* p_ctransform = get_component(p_ent, CTRANSFORM_COMP_T);
+                        const CBBox_t* p_bbox = get_component(p_ent, CBBOX_COMP_T);
+                        const CTransform_t* dmg_src_ctransform = get_component(dmg_src, CTRANSFORM_COMP_T);
+                        const CBBox_t* dmg_src_bbox = get_component(dmg_src, CBBOX_COMP_T);
+                        Vector2 launch_dir = {0, -1};
+                        if (dmg_src_ctransform->position.x + dmg_src_bbox->size.x <= p_ctransform->position.x)
+                        {
+                            launch_dir.x = 1;
+                        }
+                        else if (dmg_src_ctransform->position.x >= p_ctransform->position.x + p_bbox->size.x)
+                        {
+                            launch_dir.x = -1;
+                        }
+                        new_ent = create_bomb(&scene->ent_manager, &scene->engine->assets, launch_dir);
+                    }
+                    else
+                    {
+                        new_ent = create_explosion(&scene->ent_manager, &scene->engine->assets);
+                    }
+                break;
+                case CONTAINER_EXPLOSION:
+                    new_ent = create_explosion(&scene->ent_manager, &scene->engine->assets);
+                break;
                 default:
                     new_ent = NULL;
                 break;
@@ -1824,12 +1870,28 @@ void container_destroy_system(Scene_t* scene)
             {
                 CTransform_t* new_p_ct = get_component(new_ent, CTRANSFORM_COMP_T);
                 CTransform_t* p_ct = get_component(p_ent, CTRANSFORM_COMP_T);
-                memcpy(&new_p_ct->position, &p_ct->position, sizeof(Vector2));
+                new_p_ct->position = Vector2Add(new_p_ct->position, p_ct->position);
             }
         }
     }
 }
 
+void lifetimer_update_system(Scene_t* scene)
+{
+    LevelSceneData_t* data = &(CONTAINER_OF(scene, LevelScene_t, scene)->data);
+    TileGrid_t tilemap = data->tilemap;
+    unsigned int ent_idx;
+    CLifeTimer_t* p_lifetimer;
+    sc_map_foreach(&scene->ent_manager.component_map[CLIFETIMER_T], ent_idx, p_lifetimer)
+    {
+        p_lifetimer->life_time--;
+        if (p_lifetimer->life_time == 0)
+        {
+            remove_entity_from_tilemap(&scene->ent_manager, &tilemap, get_entity(&scene->ent_manager, ent_idx));
+        }
+    }
+}
+
 void sprite_animation_system(Scene_t* scene)
 {
     unsigned int ent_idx;

scenes/game_systems.h

@@ -23,6 +23,7 @@ void camera_update_system(Scene_t* scene);
 void container_destroy_system(Scene_t* scene);
 void player_dir_reset_system(Scene_t* scene);
 void player_respawn_system(Scene_t* scene);
+void lifetimer_update_system(Scene_t* scene);
 void spike_collision_system(Scene_t* scene);
 
 

scenes/items_ent.c

@@ -1,5 +1,6 @@
 #include "ent_impl.h"
 #include "constants.h"
+#include "raymath.h"
 
 Entity_t* create_crate(EntityManager_t* ent_manager, Assets_t* assets, bool metal, ContainerItem_t item)
 {
@@ -51,7 +52,7 @@ Entity_t* create_boulder(EntityManager_t* ent_manager, Assets_t* assets)
 
 Entity_t* create_arrow(EntityManager_t* ent_manager, Assets_t* assets, uint8_t dir)
 {
-    Entity_t* p_arrow = add_entity(ent_manager, ARROW_ENT_TAG);
+    Entity_t* p_arrow = add_entity(ent_manager, DESTRUCTABLE_ENT_TAG);
     add_component(p_arrow, CTILECOORD_COMP_T);
     CHitBoxes_t* p_hitbox = add_component(p_arrow, CHITBOXES_T);
     p_hitbox->n_boxes = 1;
@@ -86,3 +87,49 @@ Entity_t* create_arrow(EntityManager_t* ent_manager, Assets_t* assets, uint8_t d
 
     return p_arrow;
 }
+
+Entity_t* create_bomb(EntityManager_t* ent_manager, Assets_t* assets, Vector2 launch_dir)
+{
+    Entity_t* p_bomb = add_entity(ent_manager, DESTRUCTABLE_ENT_TAG);
+    add_component(p_bomb, CTILECOORD_COMP_T);
+    add_component(p_bomb, CMOVEMENTSTATE_T);
+    CHitBoxes_t* p_hitbox = add_component(p_bomb, CHITBOXES_T);
+    p_hitbox->n_boxes = 1;
+    p_hitbox->boxes[0] = (Rectangle){0, 0, 25, 25};
+
+    p_hitbox->atk = 0;
+    p_hitbox->one_hit = true;
+
+    CContainer_t* p_container = add_component(p_bomb, CCONTAINER_T);
+    p_container->item = CONTAINER_EXPLOSION;
+
+    CTransform_t* p_ctransform = add_component(p_bomb, CTRANSFORM_COMP_T);
+    p_ctransform->active = true; 
+    p_ctransform->movement_mode = REGULAR_MOVEMENT;
+    p_ctransform->position.x += (TILE_SIZE - 25) / 2;
+    p_ctransform->position.y += (TILE_SIZE - 25) / 2;
+
+    p_ctransform->velocity = Vector2Scale(Vector2Normalize(launch_dir), 500);
+    return p_bomb;
+}
+
+Entity_t* create_explosion(EntityManager_t* ent_manager, Assets_t* assets)
+{
+    Entity_t* p_explosion = add_entity(ent_manager, DESTRUCTABLE_ENT_TAG);
+    add_component(p_explosion, CTILECOORD_COMP_T);
+    CHitBoxes_t* p_hitbox = add_component(p_explosion, CHITBOXES_T);
+    p_hitbox->n_boxes = 1;
+
+    p_hitbox->atk = 3;
+
+    CTransform_t* p_ctransform = add_component(p_explosion, CTRANSFORM_COMP_T);
+    p_ctransform->movement_mode = KINEMATIC_MOVEMENT;
+    p_ctransform->active = true;
+    p_ctransform->position.x -= 15;
+    p_ctransform->position.y -= 15;
+    p_hitbox->boxes[0] = (Rectangle){0, 0, TILE_SIZE + 30, TILE_SIZE + 30};
+
+    CLifeTimer_t* p_clifetimer = add_component(p_explosion, CLIFETIMER_T);
+    p_clifetimer->life_time = 3;
+    return p_explosion;
+}