Make water runner travel faster

Changelog:
- introduce travel speed: how many move can the water runner make
    - normal movement cost : 2
    - water movement cost : 1

level_load_test.c

@@ -9,9 +9,6 @@
 #include <stdio.h>
 #include <unistd.h>
 
-// Maintain own queue to handle key presses
-struct sc_queue_32 key_buffer;
-
 Scene_t* scenes[1];
 static GameEngine_t engine =
 {
@@ -23,7 +20,7 @@ static GameEngine_t engine =
 
 int main(void)
 {
-    sc_queue_init(&key_buffer);
+    init_engine(&engine);
     InitWindow(1280, 640, "raylib");
     SetTargetFPS(60);
     init_memory_pools();
@@ -48,38 +45,7 @@ int main(void)
 
     while(true)
     {
-
-        // This entire key processing relies on the assumption that a pressed key will
-        // appear in the polling of raylib
-
-        unsigned int sz = sc_queue_size(&key_buffer);
-        // Process any existing pressed key
-        for (size_t i = 0; i < sz; i++)
-        {
-            int button = sc_queue_del_first(&key_buffer);
-            ActionType_t action = sc_map_get_64(&scene.scene.action_map, button);
-            if (IsKeyReleased(button))
-            {
-                do_action(&scene.scene, action, false);
-            }
-            else
-            {
-                do_action(&scene.scene, action, true);
-                sc_queue_add_last(&key_buffer, button);
-            }
-        }
-
-        // Detect new key presses
-        while(true)
-        {
-            int button = GetKeyPressed();
-            if (button == 0) break;
-            ActionType_t action = sc_map_get_64(&scene.scene.action_map, button);
-            if (!sc_map_found(&scene.scene.action_map)) continue;
-            do_action(&scene.scene, action, true);
-            sc_queue_add_last(&key_buffer, button);
-        }
-
+        process_inputs(&engine, &scene.scene);
         update_scene(&scene.scene);
         update_entity_manager(&scene.scene.ent_manager);
         // This is needed to advance time delta
@@ -95,7 +61,7 @@ int main(void)
     }
     free_scene(&scene.scene);
     term_level_scene_data(&scene.data);
-    sc_queue_term(&key_buffer);
+    deinit_engine(&engine);
     term_assets(&engine.assets);
     CloseWindow();
 }

main.c

@@ -24,7 +24,7 @@ int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    sc_queue_init(&key_buffer);
+    init_engine(&engine);
     InitWindow(screenWidth, screenHeight, "raylib");
     SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
     init_memory_pools();
@@ -62,33 +62,7 @@ int main(void)
         // appear in the polling of raylib
         Scene_t* curr_scene = engine.scenes[engine.curr_scene];
 
-        unsigned int sz = sc_queue_size(&key_buffer);
-        // Process any existing pressed key
-        for (size_t i = 0; i < sz; i++)
-        {
-            int button = sc_queue_del_first(&key_buffer);
-            ActionType_t action = sc_map_get_64(&curr_scene->action_map, button);
-            if (IsKeyReleased(button))
-            {
-                do_action(curr_scene, action, false);
-            }
-            else
-            {
-                do_action(curr_scene, action, true);
-                sc_queue_add_last(&key_buffer, button);
-            }
-        }
-
-        // Detect new key presses
-        while(true)
-        {
-            int button = GetKeyPressed();
-            if (button == 0) break;
-            ActionType_t action = sc_map_get_64(&curr_scene->action_map, button);
-            if (!sc_map_found(&curr_scene->action_map)) continue;
-            do_action(curr_scene, action, true);
-            sc_queue_add_last(&key_buffer, button);
-        }
+        process_inputs(&engine, curr_scene);
 
         update_scene(curr_scene);
         update_entity_manager(&curr_scene->ent_manager);
@@ -99,11 +73,16 @@ int main(void)
         {
             sc_queue_clear(&key_buffer);
         }
+
+        if (curr_scene->state == SCENE_ENDED && engine.curr_scene == 0)
+        {
+            break;
+        }
     }
     free_sandbox_scene(&sandbox_scene);
     free_game_scene(&level_scene);
     free_menu_scene(&menu_scene);
-    sc_queue_term(&key_buffer);
+    deinit_engine(&engine);
     term_assets(&engine.assets);
     CloseWindow(); 
 }

scene_test.c

@@ -5,8 +5,6 @@
 #include <stdio.h>
 #include <unistd.h>
 
-// Maintain own queue to handle key presses
-struct sc_queue_32 key_buffer;
 
 Scene_t* scenes[1];
 static GameEngine_t engine =
@@ -19,7 +17,7 @@ static GameEngine_t engine =
 
 int main(void)
 {
-    sc_queue_init(&key_buffer);
+    init_engine(&engine);
     InitWindow(1280, 640, "raylib");
     SetTargetFPS(60);
     init_memory_pools();
@@ -47,34 +45,7 @@ int main(void)
 
         // This entire key processing relies on the assumption that a pressed key will
         // appear in the polling of raylib
-
-        unsigned int sz = sc_queue_size(&key_buffer);
-        // Process any existing pressed key
-        for (size_t i = 0; i < sz; i++)
-        {
-            int button = sc_queue_del_first(&key_buffer);
-            ActionType_t action = sc_map_get_64(&scene.scene.action_map, button);
-            if (IsKeyReleased(button))
-            {
-                do_action(&scene.scene, action, false);
-            }
-            else
-            {
-                do_action(&scene.scene, action, true);
-                sc_queue_add_last(&key_buffer, button);
-            }
-        }
-
-        // Detect new key presses
-        while(true)
-        {
-            int button = GetKeyPressed();
-            if (button == 0) break;
-            ActionType_t action = sc_map_get_64(&scene.scene.action_map, button);
-            if (!sc_map_found(&scene.scene.action_map)) continue;
-            do_action(&scene.scene, action, true);
-            sc_queue_add_last(&key_buffer, button);
-        }
+        process_inputs(&engine, &scene.scene);
 
         update_scene(&scene.scene);
         update_entity_manager(&scene.scene.ent_manager);
@@ -83,7 +54,7 @@ int main(void)
         if (WindowShouldClose()) break;
     } 
     free_sandbox_scene(&scene);
-    sc_queue_term(&key_buffer);
+    deinit_engine(&engine);
     term_assets(&engine.assets);
     CloseWindow();
 }

scenes/engine/EC/EC.h

@@ -163,6 +163,7 @@ typedef struct _CWaterRunner {
     int32_t fill_idx;
     int16_t fill_range[2];
     uint8_t movement_delay;
+    int8_t movement_speed;
     int16_t counter;
 }CWaterRunner_t;
 

scenes/engine/engine.c

@@ -1,5 +1,46 @@
 #include "engine.h"
 
+void init_engine(GameEngine_t* engine)
+{
+    sc_queue_init(&engine->key_buffer);
+}
+
+void deinit_engine(GameEngine_t* engine)
+{
+    sc_queue_term(&engine->key_buffer);
+}
+
+void process_inputs(GameEngine_t* engine, Scene_t* scene)
+{
+    unsigned int sz = sc_queue_size(&engine->key_buffer);
+    // Process any existing pressed key
+    for (size_t i = 0; i < sz; i++)
+    {
+        int button = sc_queue_del_first(&engine->key_buffer);
+        ActionType_t action = sc_map_get_64(&scene->action_map, button);
+        if (IsKeyReleased(button))
+        {
+            do_action(scene, action, false);
+        }
+        else
+        {
+            do_action(scene, action, true);
+            sc_queue_add_last(&engine->key_buffer, button);
+        }
+    }
+
+    // Detect new key presses
+    while(true)
+    {
+        int button = GetKeyPressed();
+        if (button == 0) break;
+        ActionType_t action = sc_map_get_64(&scene->action_map, button);
+        if (!sc_map_found(&scene->action_map)) continue;
+        do_action(scene, action, true);
+        sc_queue_add_last(&engine->key_buffer, button);
+    }
+}
+
 void change_scene(GameEngine_t* engine, unsigned int idx)
 {
     engine->scenes[engine->curr_scene]->state = SCENE_ENDED;

scenes/engine/engine.h

@@ -12,6 +12,8 @@ typedef struct GameEngine {
     unsigned int max_scenes;
     unsigned int curr_scene;
     Assets_t assets;
+    // Maintain own queue to handle key presses
+    struct sc_queue_32 key_buffer;
 } GameEngine_t;
 void change_scene(GameEngine_t* engine, unsigned int idx);
 
@@ -41,6 +43,10 @@ struct Scene {
     GameEngine_t *engine;
 };
 
+void init_engine(GameEngine_t* engine);
+void deinit_engine(GameEngine_t* engine);
+void process_inputs(GameEngine_t* engine, Scene_t* scene);
+
 // Inline functions, for convenience
 extern void update_scene(Scene_t* scene);
 extern void render_scene(Scene_t* scene);

scenes/game_systems.c

@@ -199,8 +199,6 @@ static Vector2 shift_bbox(Vector2 bbox, Vector2 new_bbox, AnchorPoint_t anchor)
 
 void player_respawn_system(Scene_t* scene)
 {
-    LevelSceneData_t* data = &(CONTAINER_OF(scene, LevelScene_t, scene)->data);
-    TileGrid_t tilemap = data->tilemap;
     Entity_t* p_player;
     // Cannot create player while looping though the players
     // So have to create outside of the loop
@@ -902,12 +900,12 @@ void moveable_update_system(Scene_t* scene)
         // Intentional. Want this check even after a gridmove to allow gridmove after that
         if (!p_moveable->gridmove)
         {
-            if (p_ctransform->prev_velocity.y <= 0 && p_ctransform->prev_position.x == p_ctransform->position.x) continue;
+            //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;
             Vector2 point_to_check = {
                 .x = p_ctransform->position.x + p_bbox->half_size.x,
-                .y = p_ctransform->position.y + p_bbox->size.y + 5 // 5 is arbitrary, just to make sure there's a little gap
+                .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;

scenes/menu_scene.c

@@ -18,17 +18,20 @@ static void menu_scene_render_func(Scene_t* scene)
 
 static void exec_component_function(Scene_t* scene, int sel)
 {
-            switch(sel)
-            {
-                case 0:
-                    change_scene(scene->engine, 1);
-                break;
-                case 1:
-                    change_scene(scene->engine, 2);
-                break;
-                default:
-                break;
-            }
+    switch(sel)
+    {
+        case 0:
+            change_scene(scene->engine, 1);
+        break;
+        case 1:
+            change_scene(scene->engine, 2);
+        break;
+        case 3:
+            scene->state = SCENE_ENDED;
+        break;
+        default:
+        break;
+    }
 }
 
 static void menu_do_action(Scene_t* scene, ActionType_t action, bool pressed)

scenes/water_flow.c

@@ -23,6 +23,7 @@ Entity_t* create_water_runner(EntityManager_t* ent_manager, int32_t width, int32
     p_crunner->bfs_tilemap.height = height;
     p_crunner->bfs_tilemap.len = total;
     p_crunner->movement_delay = 5;
+    p_crunner->movement_speed = 6;
 
     sc_queue_init(&p_crunner->bfs_queue);
     p_crunner->visited = calloc(total, sizeof(bool));
@@ -217,16 +218,29 @@ void update_water_runner_system(Scene_t* scene)
                 p_crunner->counter--;
                 if (p_crunner->counter == 0)
                 {
-                    p_crunner->current_tile = p_crunner->bfs_tilemap.tilemap[p_crunner->current_tile].to;
-                    CTransform_t* p_ct = get_component(ent, CTRANSFORM_COMP_T);
-                    p_ct->position.x = (p_crunner->current_tile % tilemap.width) * tilemap.tile_size; 
-                    p_ct->position.y = (p_crunner->current_tile / tilemap.width) * tilemap.tile_size; 
-                    tilemap.tiles[p_crunner->current_tile].wet = true;
-                    if (p_crunner->current_tile == p_crunner->target_tile)
+
+                    int8_t move_left = p_crunner->movement_speed;
+                    while (move_left)
                     {
-                        p_crunner->state = REACHABILITY_SEARCH;
+                        p_crunner->current_tile = p_crunner->bfs_tilemap.tilemap[p_crunner->current_tile].to;
+                        CTransform_t* p_ct = get_component(ent, CTRANSFORM_COMP_T);
+                        p_ct->position.x = (p_crunner->current_tile % tilemap.width) * tilemap.tile_size; 
+                        p_ct->position.y = (p_crunner->current_tile / tilemap.width) * tilemap.tile_size; 
+
+                        Tile_t* tile = tilemap.tiles + p_crunner->current_tile;
+                        tile->wet = true;
+                        move_left--;
+                        if (tile->water_level != tile->max_water_level)
+                        {
+                            move_left--;
+                        }
+                        if (p_crunner->current_tile == p_crunner->target_tile)
+                        {
+                            p_crunner->state = REACHABILITY_SEARCH;
+                            break;
+                        }
+                        p_crunner->counter = p_crunner->movement_delay;
                     }
-                    p_crunner->counter = p_crunner->movement_delay;
                 }
             break;
             case REACHABILITY_SEARCH:

water_test.c

@@ -407,7 +407,7 @@ static void player_simple_movement_system(Scene_t* scene)
 
 int main(void)
 {
-    sc_queue_init(&key_buffer);
+    init_engine(&engine);
     InitWindow(1280, 640, "raylib");
     SetTargetFPS(60);
     init_memory_pools();
@@ -457,38 +457,7 @@ int main(void)
 
     while(true)
     {
-
-        // This entire key processing relies on the assumption that a pressed key will
-        // appear in the polling of raylib
-
-        unsigned int sz = sc_queue_size(&key_buffer);
-        // Process any existing pressed key
-        for (size_t i = 0; i < sz; i++)
-        {
-            int button = sc_queue_del_first(&key_buffer);
-            ActionType_t action = sc_map_get_64(&scene.scene.action_map, button);
-            if (IsKeyReleased(button))
-            {
-                do_action(&scene.scene, action, false);
-            }
-            else
-            {
-                do_action(&scene.scene, action, true);
-                sc_queue_add_last(&key_buffer, button);
-            }
-        }
-
-        // Detect new key presses
-        while(true)
-        {
-            int button = GetKeyPressed();
-            if (button == 0) break;
-            ActionType_t action = sc_map_get_64(&scene.scene.action_map, button);
-            if (!sc_map_found(&scene.scene.action_map)) continue;
-            do_action(&scene.scene, action, true);
-            sc_queue_add_last(&key_buffer, button);
-        }
-
+        process_inputs(&engine, &scene.scene);
         update_scene(&scene.scene);
         update_entity_manager(&scene.scene.ent_manager);
         // This is needed to advance time delta
@@ -504,7 +473,7 @@ int main(void)
     }
     free_scene(&scene.scene);
     term_level_scene_data(&scene.data);
-    sc_queue_term(&key_buffer);
+    deinit_engine(&engine);
     term_assets(&engine.assets);
     CloseWindow();
 }