'Fix' unused params for remaining functions

The entity tag mapping is not that used often enough.

So, change it to manual init.

engine/EC.h

@@ -148,9 +148,9 @@ typedef struct _BFSTile {
 
 typedef struct _BFSTileMap {
     BFSTile_t* tilemap;
-    uint32_t width;
-    uint32_t height;
-    uint32_t len;
+    int32_t width;
+    int32_t height;
+    int32_t len;
 }BFSTileMap_t;
 
 typedef enum _WaterRunnerState
@@ -252,6 +252,7 @@ struct EntityManager {
     // All fields are Read-Only
     struct sc_map_64v entities; // ent id : entity
     struct sc_map_64v entities_map[N_TAGS]; // [{ent id: ent}]
+    bool tag_map_inited[N_TAGS];
     struct sc_map_64v component_map[N_COMPONENTS]; // [{ent id: comp}, ...]
     struct sc_queue_uint to_add;
     struct sc_queue_uint to_remove;
@@ -259,6 +260,7 @@ struct EntityManager {
 };
 
 void init_entity_manager(EntityManager_t* p_manager);
+void init_entity_tag_map(EntityManager_t* p_manager, unsigned int tag_number, unsigned int initial_size);
 void update_entity_manager(EntityManager_t* p_manager);
 void clear_entity_manager(EntityManager_t* p_manager);
 void free_entity_manager(EntityManager_t* p_manager);

engine/collisions.c

@@ -196,7 +196,7 @@ bool check_on_ground(Entity_t* p_ent, Vector2 pos, Vector2 prev_pos, Vector2 bbo
 
 uint8_t check_bbox_edges(
     TileGrid_t* tilemap,
-    Entity_t* p_ent, Vector2 pos, Vector2 prev_pos, Vector2 bbox,
+    Entity_t* p_ent, Vector2 pos, Vector2 bbox,
     bool ignore_fragile
 )
 {

engine/collisions.h

@@ -61,5 +61,5 @@ uint8_t check_collision(const CollideEntity_t* ent, TileGrid_t* grid, bool check
 uint8_t check_collision_line(const CollideEntity_t* ent, TileGrid_t* grid, bool check_oneway);
 uint8_t check_collision_offset(Entity_t* p_ent, Vector2 pos, Vector2 bbox_sz, TileGrid_t* grid, Vector2 offset);
 bool check_on_ground(Entity_t* p_ent, Vector2 pos, Vector2 prev_pos, Vector2 bbox_sz, TileGrid_t* grid);
-uint8_t check_bbox_edges(TileGrid_t* tilemap, Entity_t* p_ent, Vector2 pos, Vector2 prev_pos, Vector2 bbox, bool ignore_fragile);
+uint8_t check_bbox_edges(TileGrid_t* tilemap, Entity_t* p_ent, Vector2 pos, Vector2 bbox, bool ignore_fragile);
 #endif // __COLLISION_FUNCS_H

engine/entManager.c

@@ -7,15 +7,20 @@ void init_entity_manager(EntityManager_t* p_manager)
     {
         sc_map_init_64v(p_manager->component_map + i, MAX_COMP_POOL_SIZE, 0);
     }
-    for (size_t i = 0; i < N_TAGS; ++i)
-    {
-        sc_map_init_64v(p_manager->entities_map + i, MAX_COMP_POOL_SIZE, 0);
-    }
+    memset(p_manager->tag_map_inited, 0, sizeof(p_manager->tag_map_inited));
     sc_queue_init(&p_manager->to_add);
     sc_queue_init(&p_manager->to_remove);
     sc_queue_init(&p_manager->to_update);
 }
 
+void init_entity_tag_map(EntityManager_t* p_manager, unsigned int tag_number, unsigned int initial_size)
+{
+    if (tag_number >= N_TAGS) return;
+
+    sc_map_init_64v(p_manager->entities_map + tag_number, initial_size, 0);
+    p_manager->tag_map_inited[tag_number] = true;
+}
+
 void update_entity_manager(EntityManager_t* p_manager)
 {
     // This will only update the entity map of the manager
@@ -27,7 +32,10 @@ void update_entity_manager(EntityManager_t* p_manager)
     {
         Entity_t *p_entity = get_entity_wtih_id(e_idx);
         sc_map_put_64v(&p_manager->entities, e_idx, (void *)p_entity);
-        sc_map_put_64v(&p_manager->entities_map[p_entity->m_tag], e_idx, (void *)p_entity);
+        if (p_manager->tag_map_inited[p_entity->m_tag])
+        {
+            sc_map_put_64v(&p_manager->entities_map[p_entity->m_tag], e_idx, (void *)p_entity);
+        }
     }
     sc_queue_clear(&p_manager->to_add);
 
@@ -42,7 +50,10 @@ void update_entity_manager(EntityManager_t* p_manager)
             sc_map_del_64v(&p_manager->component_map[i], e_idx);
             p_entity->components[i] = MAX_COMP_POOL_SIZE;
         }
-        sc_map_del_64v(&p_manager->entities_map[p_entity->m_tag], e_idx);
+        if (p_manager->tag_map_inited[p_entity->m_tag])
+        {
+            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);
     }
@@ -88,7 +99,10 @@ void free_entity_manager(EntityManager_t* p_manager)
     }
     for (size_t i = 0; i < N_TAGS; ++i)
     {
-        sc_map_term_64v(p_manager->entities_map + i);
+        if (p_manager->tag_map_inited[i])
+        {
+            sc_map_term_64v(p_manager->entities_map + i);
+        }
     }
     sc_queue_term(&p_manager->to_add);
     sc_queue_term(&p_manager->to_remove);

engine/rres.c

@@ -42,7 +42,7 @@ static rresResourceChunkData rresLoadResourceChunkData(rresResourceChunkInfo inf
 // Module Functions Definition
 //----------------------------------------------------------------------------------
 // Load one resource chunk for provided id
-rresResourceChunk rresLoadResourceChunk(const char *fileName, int rresId)
+rresResourceChunk rresLoadResourceChunk(const char *fileName, unsigned int rresId)
 {
     rresResourceChunk chunk = { 0 };
 
@@ -139,7 +139,7 @@ void rresUnloadResourceChunk(rresResourceChunk chunk)
 
 // Load resource from file by id
 // NOTE: All resources conected to base id are loaded
-rresResourceMulti rresLoadResourceMulti(const char *fileName, int rresId)
+rresResourceMulti rresLoadResourceMulti(const char *fileName, unsigned int rresId)
 {
     rresResourceMulti rres = { 0 };
 
@@ -252,7 +252,7 @@ void rresUnloadResourceMulti(rresResourceMulti multi)
 }
 
 // Load resource chunk info for provided id
-RRESAPI rresResourceChunkInfo rresLoadResourceChunkInfo(const char *fileName, int rresId)
+RRESAPI rresResourceChunkInfo rresLoadResourceChunkInfo(const char *fileName, unsigned int rresId)
 {
     rresResourceChunkInfo info = { 0 };
     
@@ -443,9 +443,9 @@ unsigned int rresGetDataType(const unsigned char *fourCC)
 
 // Get resource identifier from filename
 // WARNING: It requires the central directory previously loaded
-int rresGetResourceId(rresCentralDir dir, const char *fileName)
+unsigned int rresGetResourceId(rresCentralDir dir, const char *fileName)
 {
-    int id = 0;
+    unsigned int id = 0;
 
     for (unsigned int i = 0, len = 0; i < dir.count; i++)
     {

engine/rres.h

@@ -485,22 +485,22 @@ extern "C" {            // Prevents name mangling of functions
 #endif
 
 // Load only one resource chunk (first resource id found)
-RRESAPI rresResourceChunk rresLoadResourceChunk(const char *fileName, int rresId);  // Load one resource chunk for provided id
+RRESAPI rresResourceChunk rresLoadResourceChunk(const char *fileName, unsigned int rresId);  // Load one resource chunk for provided id
 RRESAPI void rresUnloadResourceChunk(rresResourceChunk chunk);                      // Unload resource chunk from memory
 
 // Load multi resource chunks for a specified rresId
-RRESAPI rresResourceMulti rresLoadResourceMulti(const char *fileName, int rresId);  // Load resource for provided id (multiple resource chunks)
+RRESAPI rresResourceMulti rresLoadResourceMulti(const char *fileName, unsigned int rresId);  // Load resource for provided id (multiple resource chunks)
 RRESAPI void rresUnloadResourceMulti(rresResourceMulti multi);                      // Unload resource from memory (multiple resource chunks)
 
 // Load resource(s) chunk info from file
-RRESAPI rresResourceChunkInfo rresLoadResourceChunkInfo(const char *fileName, int rresId);  // Load resource chunk info for provided id
+RRESAPI rresResourceChunkInfo rresLoadResourceChunkInfo(const char *fileName, unsigned int rresId);  // Load resource chunk info for provided id
 RRESAPI rresResourceChunkInfo *rresLoadResourceChunkInfoAll(const char *fileName, unsigned int *chunkCount); // Load all resource chunks info
 
 RRESAPI rresCentralDir rresLoadCentralDirectory(const char *fileName);              // Load central directory resource chunk from file
 RRESAPI void rresUnloadCentralDirectory(rresCentralDir dir);                        // Unload central directory resource chunk
 
 RRESAPI unsigned int rresGetDataType(const unsigned char *fourCC);                  // Get rresResourceDataType from FourCC code
-RRESAPI int rresGetResourceId(rresCentralDir dir, const char *fileName);            // Get resource id for a provided filename
+RRESAPI unsigned int rresGetResourceId(rresCentralDir dir, const char *fileName);            // Get resource id for a provided filename
                                                                                     // NOTE: It requires CDIR available in the file (it's optinal by design)
 RRESAPI unsigned int rresComputeCRC32(unsigned char *data, int len);                // Compute CRC32 for provided data
 

particle_test.c

@@ -8,6 +8,7 @@ static const Vector2 GRAVITY = {0, GRAV_ACCEL};
 
 void simple_particle_system_update(Particle_t* part, void* user_data)
 {
+    (void)user_data;
 
     float delta_time = DELTA_T; // TODO: Will need to think about delta time handling
     part->rotation += part->angular_vel;

res/rres_packer.c

@@ -14,7 +14,7 @@ static unsigned char *LoadDataBuffer(rresResourceChunkData data, unsigned int ra
     unsigned char *buffer = (unsigned char *)RRES_CALLOC((data.propCount + 1)*sizeof(unsigned int) + rawSize, 1);
     
     memcpy(buffer, &data.propCount, sizeof(unsigned int));
-    for (int i = 0; i < data.propCount; i++) memcpy(buffer + (i + 1)*sizeof(unsigned int), &data.props[i], sizeof(unsigned int));
+    for (unsigned int i = 0; i < data.propCount; i++) memcpy(buffer + (i + 1)*sizeof(unsigned int), &data.props[i], sizeof(unsigned int));
     memcpy(buffer + (data.propCount + 1)*sizeof(unsigned int), data.raw, rawSize);
     
     return buffer;

scenes/assets_tag.h

@@ -6,6 +6,7 @@ typedef enum EntityTag {
     ENEMY_ENT_TAG,
     CRATES_ENT_TAG,
     CHEST_ENT_TAG,
+    ARROW_ENT_TAG,
     BOULDER_ENT_TAG,
     LEVEL_END_TAG,
     DESTRUCTABLE_ENT_TAG,

scenes/editor_scene.c

@@ -250,7 +250,7 @@ static void render_editor_game_scene(Scene_t* scene)
                 {
 #define     SURFACE_THICKNESS 4
                     int up = i - tilemap.width;
-                    int bot = i + tilemap.width;
+                    unsigned 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;
@@ -491,7 +491,7 @@ static void render_editor_game_scene(Scene_t* scene)
 static void spawn_chest(Scene_t* scene, unsigned int tile_idx)
 {
     LevelSceneData_t* data = &(CONTAINER_OF(scene, LevelScene_t, scene)->data);
-    Entity_t* p_crate = create_chest(&scene->ent_manager, &scene->engine->assets);
+    Entity_t* p_crate = create_chest(&scene->ent_manager);
     if (p_crate == NULL) return;
 
     CTransform_t* p_ctransform = get_component(p_crate, CTRANSFORM_COMP_T);
@@ -503,7 +503,7 @@ static void spawn_chest(Scene_t* scene, unsigned int tile_idx)
 static void spawn_crate(Scene_t* scene, unsigned int tile_idx, bool metal, ContainerItem_t item, bool active)
 {
     LevelSceneData_t* data = &(CONTAINER_OF(scene, LevelScene_t, scene)->data);
-    Entity_t* p_crate = create_crate(&scene->ent_manager, &scene->engine->assets, metal, item);
+    Entity_t* p_crate = create_crate(&scene->ent_manager, metal, item);
     if (p_crate == NULL) return;
 
     CTransform_t* p_ctransform = get_component(p_crate, CTRANSFORM_COMP_T);
@@ -515,7 +515,7 @@ static void spawn_crate(Scene_t* scene, unsigned int tile_idx, bool metal, Conta
 static void spawn_boulder(Scene_t* scene, unsigned int tile_idx)
 {
     LevelSceneData_t* data = &(CONTAINER_OF(scene, LevelScene_t, scene)->data);
-    Entity_t* p_boulder = create_boulder(&scene->ent_manager, &scene->engine->assets);
+    Entity_t* p_boulder = create_boulder(&scene->ent_manager);
     if (p_boulder == NULL) return;
 
     CTransform_t* p_ctransform = get_component(p_boulder, CTRANSFORM_COMP_T);
@@ -626,7 +626,7 @@ static void toggle_block_system(Scene_t* scene)
                 break;
                 case SPAWN_LEVEL_END:
                 {
-                    Entity_t* p_ent = create_level_end(&scene->ent_manager, &scene->engine->assets);
+                    Entity_t* p_ent = create_level_end(&scene->ent_manager);
                     if (p_ent != NULL)
                     {
                         CTransform_t* p_ct = get_component(p_ent, CTRANSFORM_COMP_T);
@@ -883,8 +883,11 @@ static void level_do_action(Scene_t* scene, ActionType_t action, bool pressed)
 
 void init_sandbox_scene(LevelScene_t* scene)
 {
-    //init_scene(&scene->scene, LEVEL_SCENE, &level_scene_render_func, &level_do_action);
     init_scene(&scene->scene, &level_scene_render_func, &level_do_action);
+    init_entity_tag_map(&scene->scene.ent_manager, PLAYER_ENT_TAG, 4);
+    init_entity_tag_map(&scene->scene.ent_manager, BOULDER_ENT_TAG, MAX_COMP_POOL_SIZE);
+    init_entity_tag_map(&scene->scene.ent_manager, LEVEL_END_TAG, 16);
+    init_entity_tag_map(&scene->scene.ent_manager, DYNMEM_ENT_TAG, 16);
 
     scene->data.tilemap.tiles = all_tiles;
     init_level_scene_data(
@@ -978,7 +981,7 @@ void init_sandbox_scene(LevelScene_t* scene)
 
     EndTextureMode();
 
-    create_player(&scene->scene.ent_manager, &scene->scene.engine->assets);
+    create_player(&scene->scene.ent_manager);
     update_entity_manager(&scene->scene.ent_manager);
 
     // insert level scene systems

scenes/ent_impl.h

@@ -5,17 +5,17 @@
 
 bool init_player_creation(const char* info_file, Assets_t* assets);
 bool init_player_creation_rres(const char* rres_file, const char* file, Assets_t* assets);
-Entity_t* create_player(EntityManager_t* ent_manager, Assets_t* assets);
-Entity_t* create_dead_player(EntityManager_t* ent_manager, Assets_t* assets);
+Entity_t* create_player(EntityManager_t* ent_manager);
+Entity_t* create_dead_player(EntityManager_t* ent_manager);
 
 
 bool init_item_creation(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);
-Entity_t* create_chest(EntityManager_t* ent_manager, Assets_t* assets);
-Entity_t* create_level_end(EntityManager_t* ent_manager, Assets_t* assets);
+Entity_t* create_crate(EntityManager_t* ent_manager, bool metal, ContainerItem_t item);
+Entity_t* create_boulder(EntityManager_t* ent_manager);
+Entity_t* create_arrow(EntityManager_t* ent_manager, uint8_t dir);
+Entity_t* create_bomb(EntityManager_t* ent_manager, Vector2 launch_dir);
+Entity_t* create_explosion(EntityManager_t* ent_manager);
+Entity_t* create_chest(EntityManager_t* ent_manager);
+Entity_t* create_level_end(EntityManager_t* ent_manager);
 
 #endif // __ENT_IMPL_H

scenes/game_scene.c

@@ -167,7 +167,7 @@ static void render_regular_game_scene(Scene_t* scene)
                 {
 #define SURFACE_THICKNESS 4
                     int up = i - tilemap.width;
-                    int bot = i + tilemap.width;
+                    unsigned 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;
@@ -345,8 +345,11 @@ static void render_regular_game_scene(Scene_t* scene)
 
 void init_game_scene(LevelScene_t* scene)
 {
-    //init_scene(&scene->scene, LEVEL_SCENE, &level_scene_render_func, &level_do_action);
     init_scene(&scene->scene, &level_scene_render_func, &level_do_action);
+    init_entity_tag_map(&scene->scene.ent_manager, PLAYER_ENT_TAG, 4);
+    init_entity_tag_map(&scene->scene.ent_manager, BOULDER_ENT_TAG, MAX_COMP_POOL_SIZE);
+    init_entity_tag_map(&scene->scene.ent_manager, LEVEL_END_TAG, 16);
+    init_entity_tag_map(&scene->scene.ent_manager, DYNMEM_ENT_TAG, 16);
 
     scene->data.tilemap.tiles = all_tiles;
     init_level_scene_data(
@@ -354,7 +357,7 @@ void init_game_scene(LevelScene_t* scene)
         (Rectangle){25, 25, 32*TILE_SIZE, 18*TILE_SIZE}
     );
 
-    create_player(&scene->scene.ent_manager, &scene->scene.engine->assets);
+    create_player(&scene->scene.ent_manager);
     update_entity_manager(&scene->scene.ent_manager);
 
     // insert level scene systems

scenes/game_systems.c

@@ -282,6 +282,20 @@ void destroy_entity(Scene_t* scene, TileGrid_t* tilemap, Entity_t* p_ent)
         };
         play_particle_emitter(&scene->part_sys, &emitter);
     }
+    else if (p_ent->m_tag == ARROW_ENT_TAG)
+    {
+        const CTransform_t* p_ctransform = get_component(p_ent, CTRANSFORM_COMP_T);
+        ParticleEmitter_t emitter = {
+            .spr = get_sprite(&scene->engine->assets, "p_arrow"),
+            .config = get_emitter_conf(&scene->engine->assets, "pe_burst"),
+            .position = p_ctransform->position,
+            .n_particles = 2,
+            .user_data = &(CONTAINER_OF(scene, LevelScene_t, scene)->data),
+            .update_func = &simple_particle_system_update,
+        };
+        play_particle_emitter(&scene->part_sys, &emitter);
+    }
+
     remove_entity_from_tilemap(&scene->ent_manager, tilemap, p_ent);
 }
 
@@ -295,7 +309,7 @@ void player_respawn_system(Scene_t* scene)
         if (!p_player->m_alive)
         {
             CTransform_t* p_ct = get_component(p_player, CTRANSFORM_COMP_T);
-            Entity_t* ent = create_dead_player(&scene->ent_manager, &scene->engine->assets);
+            Entity_t* ent = create_dead_player(&scene->ent_manager);
             if (ent != NULL)
             {
                 CTransform_t* new_ct = get_component(ent, CTRANSFORM_COMP_T);
@@ -567,7 +581,7 @@ void player_crushing_system(Scene_t* scene)
 
         uint8_t edges = check_bbox_edges(
             &data->tilemap, p_player,
-            p_ctransform->position, p_ctransform->prev_position, p_bbox->size, true
+            p_ctransform->position, p_bbox->size, true
         );
 
         // There is a second check for to ensure that there is an solid entity/tile overlapping the player bbox
@@ -801,7 +815,7 @@ void edge_velocity_check_system(Scene_t* scene)
         // Post movement edge check to zero out velocity
         uint8_t edges = check_bbox_edges(
             &data->tilemap, p_ent,
-            p_ctransform->position, p_ctransform->prev_position, p_bbox->size, false
+            p_ctransform->position, p_bbox->size, false
         );
         if (edges & (1<<3))
         {
@@ -947,7 +961,7 @@ void global_external_forces_system(Scene_t* scene)
         // Zero out acceleration for contacts with sturdy entites and tiles
         uint8_t edges = check_bbox_edges(
             &data->tilemap, p_ent,
-            p_ctransform->position, p_ctransform->prev_position, p_bbox->size, false
+            p_ctransform->position, p_bbox->size, false
         );
         if (edges & (1<<3))
         {
@@ -1018,18 +1032,19 @@ void moveable_update_system(Scene_t* scene)
             //if (p_ctransform->prev_velocity.y <= 0 && p_ctransform->prev_position.x == p_ctransform->position.x) continue;
 
             TileGrid_t tilemap = (CONTAINER_OF(scene, LevelScene_t, scene)->data).tilemap;
+
+            // Point to check is the one row below
             Vector2 point_to_check = {
                 .x = p_ctransform->position.x + p_bbox->half_size.x,
                 .y = p_ctransform->position.y + p_bbox->size.y + 1
             };
-            int tile_x = point_to_check.x / TILE_SIZE;
-            int tile_y = point_to_check.y / TILE_SIZE;
+            unsigned int tile_x = point_to_check.x / TILE_SIZE;
+            unsigned int tile_y = point_to_check.y / TILE_SIZE;
             if (tile_y >= tilemap.height) continue;
 
             int tile_idx = tile_y * tilemap.width + tile_x;
             unsigned int other_ent_idx;
             bool can_move = false;
-            int tile_y2 = tile_y - 1;
             sc_map_foreach_key(&tilemap.tiles[tile_idx].entities_set, other_ent_idx)
             {
                 if (other_ent_idx == ent_idx) continue;
@@ -1049,7 +1064,7 @@ void moveable_update_system(Scene_t* scene)
                 if (tile_x >= 0 && tile_x < tilemap.width)
                 {
                     unsigned int tile_idx1 = tile_y * tilemap.width + tile_x;
-                    unsigned int tile_idx2 = tile_y2 * tilemap.width + tile_x;
+                    unsigned int tile_idx2 = (tile_y - 1) * tilemap.width + tile_x;
                     if ( tilemap.tiles[tile_idx1].moveable && tilemap.tiles[tile_idx2].moveable )
                     {
                         bool any_solid = false;
@@ -1084,7 +1099,7 @@ void moveable_update_system(Scene_t* scene)
                 if (tile_x >= 0 && tile_x < tilemap.width)
                 {
                     unsigned int tile_idx1 = tile_y * tilemap.width + tile_x;
-                    unsigned int tile_idx2 = tile_y2 * tilemap.width + tile_x;
+                    unsigned int tile_idx2 = (tile_y - 1) * tilemap.width + tile_x;
                     if ( tilemap.tiles[tile_idx1].moveable && tilemap.tiles[tile_idx2].moveable )
                     {
                         bool any_solid = false;
@@ -1121,7 +1136,7 @@ void moveable_update_system(Scene_t* scene)
                 p_moveable->gridmove = true;
                 p_bbox->solid = false;
                 p_moveable->prev_pos = p_ctransform->position;
-                p_moveable->target_pos = Vector2Scale((Vector2){tile_x,tile_y2}, TILE_SIZE); 
+                p_moveable->target_pos = Vector2Scale((Vector2){tile_x,tile_y-1}, 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;
@@ -1737,16 +1752,16 @@ void container_destroy_system(Scene_t* scene)
             switch (p_container->item)
             {
                 case CONTAINER_LEFT_ARROW:
-                    new_ent = create_arrow(&scene->ent_manager, &scene->engine->assets, 0);
+                    new_ent = create_arrow(&scene->ent_manager, 0);
                 break;
                 case CONTAINER_RIGHT_ARROW:
-                    new_ent = create_arrow(&scene->ent_manager, &scene->engine->assets, 1);
+                    new_ent = create_arrow(&scene->ent_manager, 1);
                 break;
                 case CONTAINER_UP_ARROW:
-                    new_ent = create_arrow(&scene->ent_manager, &scene->engine->assets, 2);
+                    new_ent = create_arrow(&scene->ent_manager, 2);
                 break;
                 case CONTAINER_DOWN_ARROW:
-                    new_ent = create_arrow(&scene->ent_manager, &scene->engine->assets, 3);
+                    new_ent = create_arrow(&scene->ent_manager, 3);
                 break;
                 case CONTAINER_BOMB:
                     if (dmg_src != NULL && dmg_src->m_tag == PLAYER_ENT_TAG)
@@ -1764,15 +1779,15 @@ void container_destroy_system(Scene_t* scene)
                         {
                             launch_dir.x = -1;
                         }
-                        new_ent = create_bomb(&scene->ent_manager, &scene->engine->assets, launch_dir);
+                        new_ent = create_bomb(&scene->ent_manager, launch_dir);
                     }
                     else
                     {
-                        new_ent = create_explosion(&scene->ent_manager, &scene->engine->assets);
+                        new_ent = create_explosion(&scene->ent_manager); 
                     }
                 break;
                 case CONTAINER_EXPLOSION:
-                    new_ent = create_explosion(&scene->ent_manager, &scene->engine->assets);
+                    new_ent = create_explosion(&scene->ent_manager);
                 break;
                 default:
                     new_ent = NULL;

scenes/items_ent.c

@@ -2,7 +2,7 @@
 #include "constants.h"
 #include "raymath.h"
 
-static SpriteRenderInfo_t item_sprite_map[19] = {0};
+static SpriteRenderInfo_t item_sprite_map[20] = {0};
 
 bool init_item_creation(Assets_t* assets)
 {
@@ -28,11 +28,12 @@ bool init_item_creation(Assets_t* assets)
     item_sprite_map[17].sprite = get_sprite(assets, "explode");
     item_sprite_map[17].offset = (Vector2){-12, -12};
     item_sprite_map[18].sprite = get_sprite(assets, "chest");
+    item_sprite_map[19].sprite = get_sprite(assets, "boulder");
     return true;
 }
 
 
-Entity_t* create_crate(EntityManager_t* ent_manager, Assets_t* assets, bool metal, ContainerItem_t item)
+Entity_t* create_crate(EntityManager_t* ent_manager, bool metal, ContainerItem_t item)
 {
     Entity_t* p_crate = add_entity(ent_manager, CRATES_ENT_TAG);
     if (p_crate == NULL) return NULL;
@@ -74,7 +75,7 @@ Entity_t* create_crate(EntityManager_t* ent_manager, Assets_t* assets, bool meta
     return p_crate;
 }
 
-Entity_t* create_boulder(EntityManager_t* ent_manager, Assets_t* assets)
+Entity_t* create_boulder(EntityManager_t* ent_manager)
 {
     Entity_t* p_boulder = add_entity(ent_manager, BOULDER_ENT_TAG);
     if (p_boulder == NULL) return NULL;
@@ -96,12 +97,17 @@ Entity_t* create_boulder(EntityManager_t* ent_manager, Assets_t* assets)
     p_hurtbox->size = p_bbox->size;
     p_hurtbox->def = 2;
     p_hurtbox->damage_src = -1;
+
+    CSprite_t* p_cspr = add_component(p_boulder, CSPRITE_T);
+    p_cspr->sprites = item_sprite_map;
+    p_cspr->current_idx = 19;
+
     return p_boulder;
 }
 
-Entity_t* create_arrow(EntityManager_t* ent_manager, Assets_t* assets, uint8_t dir)
+Entity_t* create_arrow(EntityManager_t* ent_manager, uint8_t dir)
 {
-    Entity_t* p_arrow = add_entity(ent_manager, DESTRUCTABLE_ENT_TAG);
+    Entity_t* p_arrow = add_entity(ent_manager, ARROW_ENT_TAG);
     if (p_arrow == NULL) return NULL;
 
     add_component(p_arrow, CTILECOORD_COMP_T);
@@ -145,7 +151,7 @@ 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* create_bomb(EntityManager_t* ent_manager, Vector2 launch_dir)
 {
     Entity_t* p_bomb = add_entity(ent_manager, DESTRUCTABLE_ENT_TAG);
     if (p_bomb == NULL) return NULL;
@@ -177,7 +183,7 @@ Entity_t* create_bomb(EntityManager_t* ent_manager, Assets_t* assets, Vector2 la
     return p_bomb;
 }
 
-Entity_t* create_explosion(EntityManager_t* ent_manager, Assets_t* assets)
+Entity_t* create_explosion(EntityManager_t* ent_manager)
 {
     Entity_t* p_explosion = add_entity(ent_manager, DESTRUCTABLE_ENT_TAG);
     if (p_explosion == NULL) return NULL;
@@ -204,7 +210,7 @@ Entity_t* create_explosion(EntityManager_t* ent_manager, Assets_t* assets)
     return p_explosion;
 }
 
-Entity_t* create_chest(EntityManager_t* ent_manager, Assets_t* assets)
+Entity_t* create_chest(EntityManager_t* ent_manager)
 {
     Entity_t* p_chest = add_entity(ent_manager, CHEST_ENT_TAG);
     if (p_chest == NULL) return NULL;
@@ -232,7 +238,7 @@ Entity_t* create_chest(EntityManager_t* ent_manager, Assets_t* assets)
     return p_chest;
 }
 
-Entity_t* create_level_end(EntityManager_t* ent_manager, Assets_t* assets)
+Entity_t* create_level_end(EntityManager_t* ent_manager)
 {
     Entity_t* p_flag = add_entity(ent_manager, LEVEL_END_TAG);
     if (p_flag == NULL) return NULL;

scenes/menu_scene.c

@@ -35,7 +35,7 @@ static void exec_component_function(Scene_t* scene, int sel)
 static void menu_do_action(Scene_t* scene, ActionType_t action, bool pressed)
 {
     MenuSceneData_t* data = &(CONTAINER_OF(scene, MenuScene_t, scene)->data);
-    int new_selection = data->selected_comp;
+    unsigned int new_selection = data->selected_comp;
     if (!pressed)
     {
         if (data->mode == MOUSE_MODE)
@@ -47,10 +47,21 @@ static void menu_do_action(Scene_t* scene, ActionType_t action, bool pressed)
             switch(action)
             {
                 case ACTION_UP:
-                    new_selection--;
+                    if (new_selection == 0)
+                    {
+                        new_selection = data->max_comp - 1;
+                    }
+                    else
+                    {
+                        new_selection--;
+                    }
                 break;
                 case ACTION_DOWN:
                     new_selection++;
+                    if (new_selection == data->max_comp)
+                    {
+                        new_selection = 0;
+                    }
                 break;
                 case ACTION_LEFT:
                 break;
@@ -61,9 +72,7 @@ static void menu_do_action(Scene_t* scene, ActionType_t action, bool pressed)
             }
         }
         data->buttons[data->selected_comp].state = STATE_NORMAL;
-        if (new_selection < 0) new_selection = data->max_comp - 1;
-        if (new_selection >= data->max_comp) new_selection = 0;
-        printf("new: %d, old %d\n", new_selection, data->selected_comp);
+        printf("new: %u, old %u\n", new_selection, data->selected_comp);
 
         data->buttons[new_selection].state = STATE_FOCUSED;
         data->selected_comp = new_selection;

scenes/player_ent.c

@@ -55,7 +55,7 @@ static unsigned int player_sprite_transition_func(Entity_t* ent)
     return (p_ctrans->velocity.y < 0) ? SPR_PLAYER_JUMP : SPR_PLAYER_FALL;
 }
 
-Entity_t* create_player(EntityManager_t* ent_manager, Assets_t* assets)
+Entity_t* create_player(EntityManager_t* ent_manager)
 {
     Entity_t* p_ent = add_entity(ent_manager, PLAYER_ENT_TAG);
     if (p_ent == NULL) return NULL;
@@ -106,7 +106,7 @@ Entity_t* create_player(EntityManager_t* ent_manager, Assets_t* assets)
     return p_ent;
 }
 
-Entity_t* create_dead_player(EntityManager_t* ent_manager, Assets_t* assets)
+Entity_t* create_dead_player(EntityManager_t* ent_manager)
 {
     Entity_t* p_ent = add_entity(ent_manager, NO_ENT_TAG);
     if (p_ent == NULL) return NULL;
@@ -195,7 +195,7 @@ bool init_player_creation_rres(const char* rres_fname, const char* file, Assets_
         return false;
     }
 
-    int res_id = rresGetResourceId(rres_file.dir, file);
+    unsigned int res_id = rresGetResourceId(rres_file.dir, file);
     rresResourceChunk chunk = rresLoadResourceChunk(rres_file.fname, res_id);
     
     bool okay = false;

scenes/scene_impl.h

@@ -75,8 +75,8 @@ typedef enum GuiMode {
 
 typedef struct MenuSceneData {
     UIComp_t buttons[4];
-    int selected_comp;
-    int max_comp;
+    unsigned int selected_comp;
+    unsigned int max_comp;
     GuiMode_t mode;
 } MenuSceneData_t;
 

scenes/scene_systems.c

@@ -103,7 +103,7 @@ bool load_level_tilemap(LevelScene_t* scene, unsigned int level_num)
                 default: break;
             }
 
-            Entity_t* ent = create_crate(&scene->scene.ent_manager, &scene->scene.engine->assets, tmp_idx > 5, item);
+            Entity_t* ent = create_crate(&scene->scene.ent_manager, 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;
@@ -127,7 +127,7 @@ bool load_level_tilemap(LevelScene_t* scene, unsigned int level_num)
                 break;
                 case 20:
                 {
-                    Entity_t* ent = create_boulder(&scene->scene.ent_manager, &scene->scene.engine->assets);
+                    Entity_t* ent = create_boulder(&scene->scene.ent_manager);
                     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;
@@ -140,7 +140,7 @@ bool load_level_tilemap(LevelScene_t* scene, unsigned int level_num)
                 break;
                 case 22:
                 {
-                    Entity_t* ent = create_player(&scene->scene.ent_manager, &scene->scene.engine->assets);
+                    Entity_t* ent = create_player(&scene->scene.ent_manager);
                     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;
@@ -205,7 +205,7 @@ void change_a_tile(TileGrid_t* tilemap, unsigned int tile_idx, TileType_t new_ty
             {
                 tilemap->tiles[tile_idx].solid = NOT_SOLID;
             }
-            int down_tile = tile_idx + tilemap->width;
+            unsigned int down_tile = tile_idx + tilemap->width;
             if (down_tile < tilemap->n_tiles && tilemap->tiles[down_tile].tile_type == LADDER)
             {
                 tilemap->tiles[down_tile].solid = (tilemap->tiles[tile_idx].tile_type != LADDER)? ONE_WAY : NOT_SOLID;
@@ -222,7 +222,7 @@ void change_a_tile(TileGrid_t* tilemap, unsigned int tile_idx, TileType_t new_ty
 
     if (last_type == LADDER && new_type != LADDER)
     {
-        int down_tile = tile_idx + tilemap->width;
+        unsigned int down_tile = tile_idx + tilemap->width;
         if (down_tile < tilemap->n_tiles && tilemap->tiles[down_tile].tile_type == LADDER)
         {
             tilemap->tiles[down_tile].solid = ONE_WAY;

scenes/water_flow.c

@@ -180,7 +180,7 @@ void update_water_runner_system(Scene_t* scene)
         switch (p_crunner->state)
         {
             case BFS_RESET:
-                for (size_t i = 0; i < p_crunner->bfs_tilemap.len; ++i)
+                for (int32_t i = 0; i < p_crunner->bfs_tilemap.len; ++i)
                 {
                     //p_crunner->bfs_tilemap.tilemap[i].to = -1;
                     p_crunner->bfs_tilemap.tilemap[i].from = -1;
@@ -254,7 +254,7 @@ void update_water_runner_system(Scene_t* scene)
                 int start_tile =
                     (p_crunner->current_tile / p_crunner->bfs_tilemap.width) * p_crunner->bfs_tilemap.width;
 
-                for (size_t i = 0; i < p_crunner->bfs_tilemap.width; ++i)
+                for (int32_t i = 0; i < p_crunner->bfs_tilemap.width; ++i)
                 {
                     p_crunner->bfs_tilemap.tilemap[start_tile + i].reachable = false;
                 }

tests/test_mempool.c

@@ -9,18 +9,24 @@
 
 static int setup_mempool(void** state)
 {
+    (void)state;
+
     init_memory_pools();
     return 0;
 }
 
 static int teardown_mempool(void** state)
 {
+    (void)state;
+
     free_memory_pools();
     return 0;
 }
 
 static void test_simple_get_and_free(void **state)
 {
+    (void)state;
+
     unsigned long idx;
     Entity_t* ent = new_entity_from_mempool(&idx);
 

water_test.c

@@ -68,7 +68,7 @@ static void level_scene_render_func(Scene_t* scene)
 
 
                 if (
-                    bot <= tilemap.n_tiles
+                    (unsigned int)bot <= tilemap.n_tiles
                     && tilemap.tiles[bot].water_level < MAX_WATER_LEVEL
                     && tilemap.tiles[i].water_level == 0
                     )
@@ -424,7 +424,7 @@ int main(void)
         unsigned int tile_idx = (scene.data.tilemap.height - 1) * scene.data.tilemap.width + i;
         change_a_tile(&scene.data.tilemap, tile_idx, SOLID_TILE);
     }
-    create_player(&scene.scene.ent_manager, &scene.scene.engine->assets);
+    create_player(&scene.scene.ent_manager);
     update_entity_manager(&scene.scene.ent_manager);
 
     scene.data.tile_sprites[ONEWAY_TILE] = get_sprite(&engine.assets, "tl_owp");