actions.h

@@ -2,9 +2,6 @@
 #define __ACTIONS_H
 typedef enum ActionType
 {
-    ACTION_UP,
-    ACTION_DOWN,
-    ACTION_LEFT,
-    ACTION_RIGHT,
+    ACTION_UP
 }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, action_func_t action_func)
+void init_scene(Scene_t *scene, SceneType_t scene_type, system_func_t render_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,6 +16,7 @@ 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);
 }
@@ -34,7 +35,8 @@ inline void render_scene(Scene_t *scene)
     scene->render_function(scene);
 }
 
-inline void do_action(Scene_t *scene, ActionType_t action, bool pressed)
+inline void queue_action(Scene_t *scene, ActionType_t action)
 {
-    scene->action_function(scene, action, pressed);
+    sc_queue_add_last(&scene->action_queue, action);
 }
+

scene.h

@@ -10,15 +10,14 @@ 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;
@@ -26,12 +25,11 @@ 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 do_action(Scene_t *scene, ActionType_t action, bool pressed);
+extern void queue_action(Scene_t *scene, ActionType_t action);
 
-void init_scene(Scene_t *scene, SceneType_t scene_type, system_func_t render_func, action_func_t action_func);
+void init_scene(Scene_t *scene, SceneType_t scene_type, system_func_t render_func);
 void free_scene(Scene_t *scene);
 
 #endif // __SCENE_H

scene_impl.c

@@ -17,6 +17,7 @@ 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)
@@ -29,79 +30,18 @@ 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, &level_do_action);
+    init_scene(&scene->scene, LEVEL_SCENE, &level_scene_render_func);
     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,25 +5,10 @@
 #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;
-    TileGrid_t tilemap;
 }LevelSceneData_t ;
-
 typedef struct LevelScene
 {
     Scene_t scene;

scene_test.c

@@ -3,82 +3,36 @@
 #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);
+    SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
     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;
-    add_component(&scene.scene.ent_manager, p_ent, CTRANSFORM_COMP_T);
+    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;
     update_entity_manager(&scene.scene.ent_manager);
-    for (size_t step = 0; step < 6000; step++)
+    for (size_t step = 0; step < 120; step++)
     {
-
-        // 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;
-        }
-
+        puts("======");
         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);
 }