Implement test scene

Internal Changelog:
- Update BBox component to use Vector2
- Add new CTransform component
- Implement level scene movement system and render system
- Implement scene test procedure

CMakeLists.txt

@@ -7,8 +7,6 @@ set(CMAKE_C_STANDARD 99)
 set(RAYLIB_DIR $ENV{HOME}/Documents/Coding/raylib/out/)
 
 
-
-
 add_subdirectory(sc)
 add_executable(${PROJECT_NAME}
     main.c

components.h

@@ -1,20 +1,25 @@
 #ifndef __COMPONENTS_H
 #define __COMPONENTS_H
-
+#include "raylib.h"
 // TODO: Look at sc to use macros to auto generate functions
 
-#define N_COMPONENTS 1
+#define N_COMPONENTS 2
 enum ComponentEnum
 {
     CBBOX_COMP_T,
+    CTRANSFORM_COMP_T,
 };
 typedef enum ComponentEnum ComponentEnum_t;
 
 typedef struct _CBBox_t
 {
-    int x;
+    Vector2 size;
-    int y;
-    int width;
-    int height;
 }CBBox_t;
+
+typedef struct _CTransform_t
+{
+    Vector2 position;
+    Vector2 velocity;
+    Vector2 accel;
+}CTransform_t;
 #endif // __COMPONENTS_H

entManager_test.c

@@ -13,10 +13,10 @@ int main(void)
     puts("Creating two entities");
     Entity_t *p_ent = add_entity(&manager, PLAYER_ENT_TAG);
     CBBox_t * p_bbox = (CBBox_t *)add_component(&manager, p_ent, CBBOX_COMP_T);
-    p_bbox->x = 15;
+    p_bbox->size.x = 15;
     p_ent = add_entity(&manager, ENEMY_ENT_TAG);
     p_bbox = (CBBox_t *)add_component(&manager, p_ent, CBBOX_COMP_T);
-    p_bbox->x = 40;
+    p_bbox->size.y = 40;
     update_entity_manager(&manager);
 
     puts("Print and remove the entities");
@@ -24,7 +24,7 @@ int main(void)
     sc_map_foreach(&manager.entities, idx, p_ent)
     {
         p_bbox = (CBBox_t *)get_component(&manager, p_ent, CBBOX_COMP_T);
-        printf("BBOX x: %d\n", p_bbox->x);
+        printf("BBOX: %f,%f\n", p_bbox->size.x, p_bbox->size.y);
         remove_entity(&manager, idx);
     }
     puts("");
@@ -34,7 +34,7 @@ int main(void)
     sc_map_foreach(&manager.entities, idx, p_ent)
     {
         p_bbox = (CBBox_t *)get_component(&manager, p_ent, CBBOX_COMP_T);
-        printf("BBOX x: %d\n", p_bbox->x);
+        printf("BBOX: %f,%f\n", p_bbox->size.x, p_bbox->size.y);
         remove_entity(&manager, idx);
     }
     puts("");

lsan_supp.txt

@@ -0,0 +1 @@
+leak:X11

mempool.c

@@ -2,6 +2,8 @@
 #include "sc/queue/sc_queue.h"
 #include "sc/map/sc_map.h"
 
+// BIG TODO: REWORK THE MEMPOOL FOR COMPONENT AS IT IS NOT SCALABLE
+
 // Use hashmap as a Set
 // Use list will be used to check if an object exist
 // The alternative method to check the free list if idx is not there
@@ -22,18 +24,32 @@ static struct BBoxMemPool
     struct sc_queue_uint free_list;
 }bbox_mem_pool;
 
+static struct CTransformMemPool
+{
+    CBBox_t ctransform_buffer[MAX_COMP_POOL_SIZE];
+    struct sc_map_64 use_list;
+    struct sc_queue_uint free_list;
+}ctransform_mem_pool;
+
 static bool pool_inited = false;
 void init_memory_pools(void)
 {
     if (!pool_inited)
     {
         memset(bbox_mem_pool.bbox_buffer, 0, sizeof(bbox_mem_pool.bbox_buffer));
+        memset(ctransform_mem_pool.ctransform_buffer, 0, sizeof(ctransform_mem_pool.ctransform_buffer));
         memset(entity_mem_pool.entity_buffer, 0, sizeof(entity_mem_pool.entity_buffer));
+
         sc_queue_init(&bbox_mem_pool.free_list);
         for (int i=0;i<MAX_COMP_POOL_SIZE;++i)
         {
             sc_queue_add_last(&(bbox_mem_pool.free_list), i);
         }
+        sc_queue_init(&ctransform_mem_pool.free_list);
+        for (int i=0;i<MAX_COMP_POOL_SIZE;++i)
+        {
+            sc_queue_add_last(&(ctransform_mem_pool.free_list), i);
+        }
         sc_queue_init(&entity_mem_pool.free_list);
         for (int i=0;i<MAX_COMP_POOL_SIZE;++i)
         {
@@ -41,7 +57,9 @@ void init_memory_pools(void)
             sc_map_init_64(&entity_mem_pool.entity_buffer[i].components, 16 ,0);
             sc_queue_add_last(&(entity_mem_pool.free_list), i);
         }
+
         sc_map_init_64(&bbox_mem_pool.use_list, MAX_COMP_POOL_SIZE ,0);
+        sc_map_init_64(&ctransform_mem_pool.use_list, MAX_COMP_POOL_SIZE ,0);
         sc_map_init_64(&entity_mem_pool.use_list, MAX_COMP_POOL_SIZE ,0);
         pool_inited = true;
     }
@@ -52,9 +70,13 @@ void free_memory_pools(void)
     if (pool_inited)
     {
         sc_map_term_64(&bbox_mem_pool.use_list);
+        sc_map_term_64(&ctransform_mem_pool.use_list);
         sc_map_term_64(&entity_mem_pool.use_list);
+
         sc_queue_term(&bbox_mem_pool.free_list);
+        sc_queue_term(&ctransform_mem_pool.free_list);
         sc_queue_term(&entity_mem_pool.free_list);
+
         for (int i=0;i<MAX_COMP_POOL_SIZE;++i)
         {
             sc_map_term_64(&entity_mem_pool.entity_buffer[i].components);
@@ -104,6 +126,13 @@ void* new_component_from_mempool(ComponentEnum_t comp_type, unsigned long *idx)
             comp = bbox_mem_pool.bbox_buffer + *idx;
             memset(comp, 0, sizeof(CBBox_t));
         break;
+        case CTRANSFORM_COMP_T:
+            if(sc_queue_empty(&ctransform_mem_pool.free_list)) break;
+            *idx = sc_queue_del_first(&ctransform_mem_pool.free_list);
+            sc_map_put_64(&ctransform_mem_pool.use_list, *idx, *idx);
+            comp = ctransform_mem_pool.ctransform_buffer + *idx;
+            memset(comp, 0, sizeof(CTransform_t));
+        break;
         default:
         break;
     }
@@ -120,6 +149,11 @@ void* get_component_wtih_id(ComponentEnum_t comp_type, unsigned long idx)
             if (!sc_map_found(&bbox_mem_pool.use_list)) break;
             comp = bbox_mem_pool.bbox_buffer + idx;
         break;
+        case CTRANSFORM_COMP_T:
+            sc_map_get_64(&ctransform_mem_pool.use_list, idx);
+            if (!sc_map_found(&ctransform_mem_pool.use_list)) break;
+            comp = ctransform_mem_pool.ctransform_buffer + idx;
+        break;
         default:
         break;
     }
@@ -138,6 +172,13 @@ void free_component_to_mempool(ComponentEnum_t comp_type, unsigned long idx)
                 sc_queue_add_first(&bbox_mem_pool.free_list, idx);
             }
         break;
+        case CTRANSFORM_COMP_T:
+            sc_map_del_64(&ctransform_mem_pool.use_list, idx);
+            if (sc_map_found(&ctransform_mem_pool.use_list))
+            {
+                sc_queue_add_first(&ctransform_mem_pool.free_list, idx);
+            }
+        break;
         default:
         break;
     }

scene_impl.c

@@ -1,14 +1,37 @@
 #include "scene_impl.h"
 #include "raylib.h"
+#include "raymath.h"
+#include <stdio.h>
 
 static void level_scene_render_func(Scene_t* scene)
 {
+    Entity_t *p_ent;
+    sc_map_foreach_value(&scene->ent_manager.entities, p_ent)
+    {
+        CTransform_t* p_ct = get_component(&scene->ent_manager, p_ent, CTRANSFORM_COMP_T);
+        CBBox_t* p_bbox = get_component(&scene->ent_manager, p_ent, CBBOX_COMP_T);
+        DrawRectangle(p_ct->position.x, p_ct->position.y, p_bbox->size.x, p_bbox->size.y, RED);
+    }
     return;
 }
 
 static void movement_update_system(Scene_t* scene)
 {
-    return;
+    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)
+    {
+        p_ctransform->velocity = Vector2Add(
+            p_ctransform->velocity,
+            Vector2Scale(p_ctransform->accel, delta_time)
+        );
+        p_ctransform->position = Vector2Add(
+            p_ctransform->position,
+            Vector2Scale(p_ctransform->velocity, delta_time)
+        );
+
+    }
 }
 void init_level_scene(LevelScene_t *scene)
 {

scene_test.c

@@ -1,11 +1,38 @@
 #include "mempool.h"
 #include "scene_impl.h"
 #include <stdio.h>
+#include <unistd.h>
 
 int main(void)
 {
+    InitWindow(320, 240, "raylib");
+    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);
+    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;
+    update_entity_manager(&scene.scene.ent_manager);
+    for (size_t step = 0; step < 120; step++)
+    {
+        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();
+    } 
+    CloseWindow();
     free_level_scene(&scene);
 }