Implement key controls to scene

Changelog:
- Add double buffer to handle key presses and release
- Add more actions
- Update action mapping of level scene
- Implement action function for level scene
- Remove action queue for Scene struct. This is handled by raylib
  and the game engine
- Update scene struct with action function field

actions.h

@@ -2,6 +2,9 @@
 #define __ACTIONS_H
 typedef enum ActionType
 {
-    ACTION_UP
+    ACTION_UP,
+    ACTION_DOWN,
+    ACTION_LEFT,
+    ACTION_RIGHT,
 }ActionType_t;
 #endif // __ACTIONS_H

scene.c

@@ -1,14 +1,14 @@
 #include "scene.h"
 
-void init_scene(Scene_t *scene, SceneType_t scene_type, system_func_t render_func)
+void init_scene(Scene_t *scene, SceneType_t scene_type, system_func_t render_func, action_func_t action_func)
 {
     sc_map_init_64(&scene->action_map, 32, 0);
-    sc_queue_init(&scene->action_queue);
     sc_array_init(&scene->systems);
     init_entity_manager(&scene->ent_manager);
 
     scene->scene_type = scene_type;
     scene->render_function = render_func;
+    scene->action_function = action_func;
     scene->paused = false;
     scene->has_ended = false;
 }
@@ -16,7 +16,6 @@ void init_scene(Scene_t *scene, SceneType_t scene_type, system_func_t render_fun
 void free_scene(Scene_t *scene)
 {
     sc_map_term_64(&scene->action_map);
-    sc_queue_term(&scene->action_queue);
     sc_array_term(&scene->systems);
     free_entity_manager(&scene->ent_manager);
 }
@@ -35,8 +34,7 @@ inline void render_scene(Scene_t *scene)
     scene->render_function(scene);
 }
 
-inline void queue_action(Scene_t *scene, ActionType_t action)
+inline void do_action(Scene_t *scene, ActionType_t action, bool pressed)
 {
-    sc_queue_add_last(&scene->action_queue, action);
+    scene->action_function(scene, action, pressed);
 }
-

scene.h

@@ -10,14 +10,15 @@ typedef enum SceneType
 
 typedef struct Scene Scene_t;
 typedef void(*system_func_t)(Scene_t *);
+typedef void(*action_func_t)(Scene_t *, ActionType_t, bool);
 sc_array_def(system_func_t, systems);
 
 struct Scene
 {
     struct sc_map_64 action_map; // key -> actions
-    struct sc_queue_64 action_queue;
     struct sc_array_systems systems;
     system_func_t render_function;
+    action_func_t action_function;
     EntityManager_t ent_manager;
     SceneType_t scene_type;
     void * scene_data;
@@ -25,11 +26,12 @@ struct Scene
     bool has_ended;
 };
 
+// Inline functions, for convenience
 extern void update_scene(Scene_t *scene);
 extern void render_scene(Scene_t *scene);
-extern void queue_action(Scene_t *scene, ActionType_t action);
+extern void do_action(Scene_t *scene, ActionType_t action, bool pressed);
 
-void init_scene(Scene_t *scene, SceneType_t scene_type, system_func_t render_func);
+void init_scene(Scene_t *scene, SceneType_t scene_type, system_func_t render_func, action_func_t action_func);
 void free_scene(Scene_t *scene);
 
 #endif // __SCENE_H

scene_impl.c

@@ -17,7 +17,6 @@ static void level_scene_render_func(Scene_t* scene)
 
 static void movement_update_system(Scene_t* scene)
 {
-    puts("Updating movement");
     float delta_time = GetFrameTime();
     CTransform_t * p_ctransform;
     sc_map_foreach_value(&scene->ent_manager.component_map[CTRANSFORM_COMP_T], p_ctransform)
@@ -30,18 +29,79 @@ static void movement_update_system(Scene_t* scene)
             p_ctransform->position,
             Vector2Scale(p_ctransform->velocity, delta_time)
         );
-
     }
 }
+
+static void screen_bounce_system(Scene_t *scene)
+{
+    Entity_t* p_ent;
+    sc_map_foreach_value(&scene->ent_manager.entities, p_ent)
+    {
+        CBBox_t* p_bbox = get_component(&scene->ent_manager, p_ent, CBBOX_COMP_T);
+        CTransform_t* p_ctransform = get_component(&scene->ent_manager, p_ent, CTRANSFORM_COMP_T);
+        if (p_bbox == NULL || p_ctransform == NULL) continue;
+
+        if(p_ctransform->position.x < 0 || p_ctransform->position.x + p_bbox->size.x > 320)
+        {
+            p_ctransform->position.x = (p_ctransform->position.x < 0) ? 0 : p_ctransform->position.x;
+            p_ctransform->position.x = (p_ctransform->position.x + p_bbox->size.x > 320) ? 320 - p_bbox->size.x : p_ctransform->position.x;
+            p_ctransform->velocity.x *= -1;
+        }
+        
+        if(p_ctransform->position.y < 0 || p_ctransform->position.y + p_bbox->size.y > 240)
+        {
+            p_ctransform->position.y = (p_ctransform->position.y < 0) ? 0 : p_ctransform->position.y;
+            p_ctransform->position.y = (p_ctransform->position.y + p_bbox->size.y > 240) ? 240 - p_bbox->size.y : p_ctransform->position.y;
+            p_ctransform->velocity.y *= -1;
+        }
+    }
+
+}
+
+void level_do_action(Scene_t *scene, ActionType_t action, bool pressed)
+{
+    LevelSceneData_t *data = (LevelSceneData_t *)scene->scene_data;
+    CTransform_t *p_ctransform = get_component(&scene->ent_manager, data->player, CTRANSFORM_COMP_T);
+    Vector2 dir = {0, 0};
+    if (pressed)
+    {
+        switch(action)
+        {
+            case ACTION_UP:
+                dir.y -= 1;
+            break;
+            case ACTION_DOWN:
+                dir.y += 1;
+            break;
+            case ACTION_LEFT:
+                dir.x -= 1;
+            break;
+            case ACTION_RIGHT:
+                dir.x += 1;
+            break;
+        }
+    }
+    p_ctransform->accel.x = dir.x * 500;
+    p_ctransform->accel.y = dir.y * 500;
+
+}
+
 void init_level_scene(LevelScene_t *scene)
 {
-    init_scene(&scene->scene, LEVEL_SCENE, &level_scene_render_func);
+    init_scene(&scene->scene, LEVEL_SCENE, &level_scene_render_func, &level_do_action);
     scene->scene.scene_data = &scene->data;
     scene->data.player = NULL;
 
     // insert level scene systems
     sc_array_add(&scene->scene.systems, &movement_update_system);
+    sc_array_add(&scene->scene.systems, &screen_bounce_system);
+
+    sc_map_put_64(&scene->scene.action_map, KEY_UP, ACTION_UP);
+    sc_map_put_64(&scene->scene.action_map, KEY_DOWN, ACTION_DOWN);
+    sc_map_put_64(&scene->scene.action_map, KEY_LEFT, ACTION_LEFT);
+    sc_map_put_64(&scene->scene.action_map, KEY_RIGHT, ACTION_RIGHT);
 }
+
 void free_level_scene(LevelScene_t *scene)
 {
     free_scene(&scene->scene);

scene_impl.h

@@ -5,10 +5,25 @@
 #ifndef __SCENE_IMPL_H
 #define __SCENE_IMPL_H
 #include "scene.h"
+typedef struct Tile
+{
+    bool solid;
+    // TODO: add a map?
+}Tile_t;
+
+typedef struct TileGrid
+{
+    unsigned int width;
+    unsigned int height;
+    Tile_t * const tiles;
+}TileGrid_t;
+
 typedef struct LevelSceneData
 {
     Entity_t * player;
-}LevelSceneData_t ;
+    TileGrid_t tilemap;
+}LevelSceneData_t;
+
 typedef struct LevelScene
 {
     Scene_t scene;

scene_test.c

@@ -3,36 +3,82 @@
 #include <stdio.h>
 #include <unistd.h>
 
+// Use double buffer to handle key presses
+// Can do single buffer, but need careful handling
+unsigned int curr_keybuf = 0;
+unsigned int next_keybuf = 1;
+struct sc_queue_32 key_buffer[2];
+
 int main(void)
 {
+    sc_queue_init(key_buffer);
+    sc_queue_init(key_buffer + 1);
     InitWindow(320, 240, "raylib");
-    SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
+    SetTargetFPS(60);
     init_memory_pools();
     LevelScene_t scene;
     init_level_scene(&scene);
     Entity_t *p_ent = add_entity(&scene.scene.ent_manager, PLAYER_ENT_TAG);
+    scene.data.player = p_ent;
+
     CBBox_t *p_bbox = add_component(&scene.scene.ent_manager, p_ent, CBBOX_COMP_T);
     p_bbox->size.x = 30;
     p_bbox->size.y = 30;
-    CTransform_t * p_ctran = (CTransform_t *)add_component(&scene.scene.ent_manager, p_ent, CTRANSFORM_COMP_T);
-    p_ctran->accel.x = 20;
-    p_ctran->accel.y = 10;
+    add_component(&scene.scene.ent_manager, p_ent, CTRANSFORM_COMP_T);
     update_entity_manager(&scene.scene.ent_manager);
-    for (size_t step = 0; step < 120; step++)
+    for (size_t step = 0; step < 6000; step++)
     {
-        puts("======");
+
+        // This entire key processing relies on the assumption that a pressed key will
+        // appear in the polling of raylib
+
+        // Process any existing pressed key
+        while (!sc_queue_empty(key_buffer + curr_keybuf))
+        {
+            int button = sc_queue_del_first(key_buffer + curr_keybuf);
+            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 + next_keybuf, button);
+            }
+        }
+
+        // Detect new key presses
+        while(true)
+        {
+            int button = GetKeyPressed();
+            printf("Button pressed: %d\n", button);
+            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;
+            printf("Action mapped: %d\n", action);
+            do_action(&scene.scene, action, true);
+            sc_queue_add_last(key_buffer + next_keybuf, button);
+        }
+
+        // Swap keystroke buffer;
+        {
+            unsigned int tmp = curr_keybuf;
+            curr_keybuf = next_keybuf;
+            next_keybuf = tmp;
+        }
+
         printf("Step %lu\n", step);
         update_scene(&scene.scene);
-        printf("Position: %f,%f\n", p_ctran->position.x, p_ctran->position.y);
-        printf("Velocity: %f,%f\n", p_ctran->velocity.x, p_ctran->velocity.y);
-        printf("Accel: %f,%f\n", p_ctran->accel.x, p_ctran->accel.y);
         // This is needed to advance time delta
         BeginDrawing();
-            // TODO: Call the current scene Render function
             render_scene(&scene.scene);
             ClearBackground(RAYWHITE);
         EndDrawing();
+        if (WindowShouldClose()) break;
     } 
     CloseWindow();
     free_level_scene(&scene);
+    sc_queue_term(key_buffer);
+    sc_queue_term(key_buffer + 1);
 }