Added a reserve function to linked lists. This came along an allocator function and better memory management. Elements and error handling has exploded everywere, that's why there is so much changes.

SDL3_Core

@@ -1 +1 @@
-Subproject commit 457de07ecb02822d5e309c188bdcdba1ce2cdc59
+Subproject commit b1dd9baf98ba5496a606cced00ca7ccde0df36db

TODO.md

@@ -0,0 +1,26 @@
+# What to do for the 2D Engine
+
+### Todo
+
+- [ ] Create tilemap management and display
+  - [ ] Find tilemap building format
+  - [ ] Add building support for tilemaps in asset builder
+  - [ ] Add loading support in asset manager
+  - [ ] Display tilemaps
+    - [ ] Work on optimizations !
+  - [ ] Create camera
+
+- [ ] Create entities management
+  - [ ] Find entities building format
+  - [ ] Add building support for entities in asset builder
+  - [ ] Add loading support in asset manager
+
+- [ ] Change the way default values are defined across components and systems
+  - [ ] Remove the need of a dummy texture
+
+### In progress
+
+
+### Done
+
+- [x] Work on linked lists optimizations

assets/Makefile

@@ -1,4 +1,5 @@
 ASSETS := \
+  misc/dummy_sheet.png \
   player_sheets/player_idle_sheet.png \
   player_sheets/player_walk_sheet.png \
   player_sheets/player_run_sheet.png\

src/components/animation_system.c

@@ -4,26 +4,28 @@
 #include "memory_alloc.h"
 #include "errors.h"
 
-// Args : size_t nb_frames, size_t actual_frame, float frame_delay_ms, bool play, bool loop, bool reverse
+// Args : size_t nb_frames, size_t current_frame, float frame_delay_ms, bool play, bool loop, bool reverse
-int animation_system_init(component_t *component, va_list args)
+int animation_system_init(component_t *component)
 {
     animation_system_data_t *system_data = component->component_data;
 
-    system_data->sprite_component_data = get_component(component->entity, SPRITE_COMPONENT)->component_data;
+    system_data->sprite_component_data = entity_get_component(component->entity, SPRITE_COMPONENT)->component_data;
     if(!system_data->sprite_component_data) return EXIT_FAILURE;
 
-    system_data->nb_frames = va_arg(args, size_t);
+    system_data->nb_frames = 1;
-    system_data->actual_frame_nb= va_arg(args, size_t);
+    linked_list_init(&system_data->frames, sizeof(rect_t), NULL, NULL);
-    system_data->frame_delay_ms = (float)va_arg(args, double);
-    system_data->play = (bool)va_arg(args, int);
-    system_data->loop = (bool)va_arg(args, int);
-    system_data->reverse = (bool)va_arg(args, int);
 
-    system_data->frame_timer_ms = 0;
+    system_data->current_frame_nb = 0;
+    animation_system_create_frames_clips(system_data);
 
-    linked_list_init(&system_data->frames, sizeof(rect_t), NULL);
+    system_data->frame_delay_ms = 0.0f;
+    system_data->frame_timer_ms = 0.0f;
 
-    return animation_system_create_frames_clips(system_data);
+    system_data->play = false;
+    system_data->loop = false;
+    system_data->reverse = false;
+
+    return EXIT_SUCCESS;
 }
 
 int animation_system_update(component_t *component)
@@ -32,23 +34,23 @@ int animation_system_update(component_t *component)
 
     if(system_data->play)
     {
-        system_data->frame_timer_ms += (float)game.delta_time_ms;
+        system_data->frame_timer_ms += game.delta_time_ms;
 
         if(system_data->frame_timer_ms >= system_data->frame_delay_ms)
         {
-            system_data->frame_timer_ms = 0;
+            system_data->frame_timer_ms = 0.0f;
 
             if(system_data->reverse)
             {
-                if(system_data->actual_frame->prev)
+                if(system_data->current_frame->prev)
                 {
-                    system_data->actual_frame = system_data->actual_frame->prev;
+                    system_data->current_frame = system_data->current_frame->prev;
-                    system_data->actual_frame_nb--;
+                    system_data->current_frame_nb--;
                 }
                 else if(system_data->loop)
                 {
-                    system_data->actual_frame = system_data->frames.last;
+                    system_data->current_frame = system_data->frames.last;
-                    system_data->actual_frame_nb = system_data->frames.size - 1;
+                    system_data->current_frame_nb = system_data->frames.size - 1;
                 }
                 else
                 {
@@ -57,15 +59,15 @@ int animation_system_update(component_t *component)
             }
             else
             {
-                if(system_data->actual_frame->next)
+                if(system_data->current_frame->next)
                 {
-                    system_data->actual_frame = system_data->actual_frame->next;
+                    system_data->current_frame = system_data->current_frame->next;
-                    system_data->actual_frame_nb++;
+                    system_data->current_frame_nb++;
                 }
                 else if(system_data->loop)
                 {
-                    system_data->actual_frame = system_data->frames.first;
+                    system_data->current_frame = system_data->frames.first;
-                    system_data->actual_frame_nb = 0;
+                    system_data->current_frame_nb = 0;
                 }
                 else
                 {
@@ -74,52 +76,57 @@ int animation_system_update(component_t *component)
             }
         }
 
-        system_data->sprite_component_data->src_rect = *(rect_t *)system_data->actual_frame->data;
+        system_data->sprite_component_data->src_rect = *(rect_t *)system_data->current_frame->data;
     }
 
     return EXIT_SUCCESS;
 }
 
-inline void animation_system_destroy(component_t *component)
+inline int animation_system_destroy(component_t *component)
 {
     animation_system_data_t *system_data = component->component_data;
 
-    linked_list_clear(&system_data->frames);
+    if(linked_list_clear(&system_data->frames)) return EXIT_FAILURE;
+
     free(system_data);
+
+    return EXIT_SUCCESS;
 }
 
 int animation_system_create_frames_clips(animation_system_data_t *system_data)
 {
-    linked_list_clear(&system_data->frames);
+    sprite_component_data_t *sprite_component_data = system_data->sprite_component_data;
 
-    rect_t *sprite_srcR = &system_data->sprite_component_data->src_rect;
+    if(linked_list_clear(&system_data->frames)) return EXIT_FAILURE;
 
-    for(size_t actual_frame_nb = 0; actual_frame_nb < system_data->nb_frames; actual_frame_nb++)
+    if(linked_list_reserve(&system_data->frames, system_data->nb_frames)) return EXIT_FAILURE;
+
+    for(size_t current_frame_nb = 0; current_frame_nb < system_data->nb_frames; current_frame_nb++)
     {
-        elem_t *frame = elem_create(&system_data->frames);
+        elem_t *frame = create_elem(&system_data->frames);
+        if(!frame) return EXIT_FAILURE;
 
-        ((rect_t *)frame->data)->x = sprite_srcR->w * (float)actual_frame_nb;
+        ((rect_t *)frame->data)->x = sprite_component_data->src_rect.w * (float)current_frame_nb;
         ((rect_t *)frame->data)->y = 0;
-        ((rect_t *)frame->data)->w = sprite_srcR->w;
+        ((rect_t *)frame->data)->w = sprite_component_data->src_rect.w;
-        ((rect_t *)frame->data)->h = sprite_srcR->h;
+        ((rect_t *)frame->data)->h = sprite_component_data->src_rect.h;
 
-        if(linked_list_push_back_elem(&system_data->frames, frame)) return EXIT_FAILURE;
+        if(linked_list_push_back(&system_data->frames, frame)) return EXIT_FAILURE;
     }
 
-    system_data->actual_frame = linked_list_get_elem(&system_data->frames, system_data->actual_frame_nb);
+    system_data->current_frame = linked_list_get(&system_data->frames, system_data->current_frame_nb);
-    if(!system_data->actual_frame) return EXIT_FAILURE;
+    if(!system_data->current_frame) return EXIT_FAILURE;
 
     return EXIT_SUCCESS;
 }
 
-inline int animation_system_change_animation(animation_system_data_t *system_data, const char *name, size_t nb_frames)
+inline int animation_system_apply_changes(animation_system_data_t *system_data)
 {
-    system_data->sprite_component_data->texture = asset_manager_get_texture(&game.asset_manager, name);
+    sprite_component_data_t *sprite_component_data = system_data->sprite_component_data;
 
-    system_data->nb_frames = nb_frames;
     if(animation_system_create_frames_clips(system_data)) return EXIT_FAILURE;
 
-    system_data->sprite_component_data->src_rect = *(rect_t *)system_data->actual_frame->data;
+    sprite_component_data->src_rect = *(rect_t *)system_data->current_frame->data;
 
     return EXIT_SUCCESS;
 }

src/components/headers/animation_system.h

@@ -10,8 +10,8 @@ typedef struct animation_system_data_t {
     size_t nb_frames;
     linked_list_t frames;
 
-    elem_t *actual_frame;
+    size_t current_frame_nb;
-    size_t actual_frame_nb;
+    elem_t *current_frame;
 
     float frame_delay_ms;
     float frame_timer_ms;
@@ -21,14 +21,14 @@ typedef struct animation_system_data_t {
     bool reverse    :1;
 } animation_system_data_t;
 
-int animation_system_init(component_t *component, va_list args);
+int animation_system_init(component_t *component);
 
 int animation_system_update(component_t *component);
 
-void animation_system_destroy(component_t *component);
+int animation_system_destroy(component_t *component);
 
 int animation_system_create_frames_clips(animation_system_data_t *system_data);
 
-int animation_system_change_animation(animation_system_data_t *system_data, const char *name, size_t nb_frames);
+int animation_system_apply_changes(animation_system_data_t *system_data);
 
 #endif // SPRITE_COMPONENT_H

src/components/headers/player_system.h

@@ -10,7 +10,7 @@
 #define PLAYER_DEFAULT_RUN_SPEED 100.0f // px / s
 #define PLAYER_DEFAULT_IDLE_ANIMATION_SPEED 500.0f // ms / frame
 #define PLAYER_DEFAULT_WALK_ANIMATION_SPEED  160.0f // ms / frame
-#define PLAYER_DEFAULT_RUN_ANIMATION_SPEED  100.0f // ms / frame
+#define PLAYER_DEFAULT_RUN_ANIMATION_SPEED  110.0f // ms / frame
 
 typedef enum player_state_t {
     PLAYER_IDLE         = 0x00, // 00000000
@@ -32,10 +32,10 @@ typedef struct player_system_data_t {
     player_state_t last_state;
 } player_system_data_t;
 
-int player_system_init(component_t *, va_list);
+int player_system_init(component_t *component);
 
-int player_system_update(component_t *);
+int player_system_update(component_t *component);
 
-void player_system_destroy(component_t *);
+int player_system_destroy(component_t *component);
 
 #endif // PLAYER_SYSTEM_H

src/components/headers/sprite_component.h

@@ -16,12 +16,14 @@ typedef struct sprite_component_data_t {
     bool flip;
 } sprite_component_data_t;
 
-int sprite_component_init(component_t *, va_list);
+int sprite_component_init(component_t *component);
 
-int sprite_component_update(component_t *);
+int sprite_component_update(component_t *component);
 
-int sprite_component_draw(component_t *);
+int sprite_component_draw(component_t *component);
 
-void sprite_component_destroy(component_t *);
+int sprite_component_destroy(component_t *component);
+
+int sprite_component_set_texture(sprite_component_data_t *component_data, const char *texture_name);
 
 #endif // SPRITE_COMPONENT_H

src/components/headers/transform_component.h

@@ -10,10 +10,10 @@ typedef struct transform_component_data_t {
     float speed;
 } transform_component_data_t;
 
-int transform_component_init(component_t *, va_list);
+int transform_component_init(component_t *component);
 
-int transform_component_update(component_t *);
+int transform_component_update(component_t *component);
 
-void transform_component_destroy(component_t *);
+int transform_component_destroy(component_t *component);
 
 #endif // TRANSFORM_COMPONENT_H

src/components/player_system.c

@@ -7,15 +7,32 @@
 #include "transform_component.h"
 
 // No args
-int player_system_init(component_t *component, va_list args __attribute__((unused)))
+int player_system_init(component_t *component)
 {
     player_system_data_t *system_data = component->component_data;
 
-    system_data->animation_system_data = get_component(component->entity, ANIMATION_SYSTEM)->component_data;
+    system_data->animation_system_data = entity_get_component(component->entity, ANIMATION_SYSTEM)->component_data;
+    if(!system_data->animation_system_data) return EXIT_FAILURE;
     system_data->sprite_component_data = system_data->animation_system_data->sprite_component_data;
     system_data->transform_component_data = system_data->sprite_component_data->transform_component_data;
 
+    transform_component_data_t *transform_component_data = system_data->transform_component_data;
+    sprite_component_data_t *sprite_component_data = system_data->sprite_component_data;
+    animation_system_data_t *animation_system_data = system_data->animation_system_data;
+
+    transform_component_data->bounds.x = 10.0f;
+    transform_component_data->bounds.y = 10.0f;
+
+    sprite_component_set_texture(sprite_component_data, "player_idle_sheet");
+
+    animation_system_data->nb_frames = 4;
+    animation_system_data->frame_delay_ms = PLAYER_DEFAULT_IDLE_ANIMATION_SPEED;
+    animation_system_apply_changes(animation_system_data);
+    animation_system_data->loop = true;
+    animation_system_data->play = true;
+
     system_data->state = PLAYER_IDLE;
+    system_data->last_state = PLAYER_IDLE;
 
     return EXIT_SUCCESS;
 }
@@ -87,24 +104,34 @@ static inline int player_system_set_animation_and_speed(player_system_data_t *sy
         if(system_data->state & PLAYER_RUNNING)
         {
             transform_component_data->speed = PLAYER_DEFAULT_RUN_SPEED;
+
+            sprite_component_set_texture(sprite_component_data, "player_run_sheet");
+
+            animation_system_data->nb_frames = 8;
+            animation_system_data->current_frame_nb = 0;
             animation_system_data->frame_delay_ms = PLAYER_DEFAULT_RUN_ANIMATION_SPEED;
-            animation_system_data->actual_frame_nb = 0;
+            if(animation_system_apply_changes(animation_system_data)) return EXIT_FAILURE;
-            if(animation_system_change_animation(animation_system_data, "player_run_sheet", 8)) return EXIT_FAILURE;
         }
         else
         {
             transform_component_data->speed = PLAYER_DEFAULT_WALK_SPEED;
+
+            sprite_component_set_texture(sprite_component_data, "player_walk_sheet");
+
+            animation_system_data->nb_frames = 4;
+            animation_system_data->current_frame_nb = 0;
             animation_system_data->frame_delay_ms = PLAYER_DEFAULT_WALK_ANIMATION_SPEED;
-            animation_system_data->actual_frame_nb = 0;
+            if(animation_system_apply_changes(animation_system_data)) return EXIT_FAILURE;
-            if(animation_system_change_animation(animation_system_data, "player_walk_sheet", 4)) return EXIT_FAILURE;
         }
     }
     else if(!(system_data->state & PLAYER_MOVING) && (system_data->last_state & PLAYER_MOVING))
     {
-        animation_system_data->actual_frame_nb = 0;
+        sprite_component_set_texture(sprite_component_data, "player_idle_sheet");
+
+        animation_system_data->nb_frames = 4;
+        animation_system_data->current_frame_nb = 0;
         animation_system_data->frame_delay_ms = PLAYER_DEFAULT_IDLE_ANIMATION_SPEED;
-        animation_system_data->actual_frame_nb = 0;
+        if(animation_system_apply_changes(animation_system_data)) return EXIT_FAILURE;
-        if(animation_system_change_animation(animation_system_data, "player_idle_sheet", 4)) return EXIT_FAILURE;
     }
 
     return EXIT_SUCCESS;
@@ -121,7 +148,11 @@ int player_system_update(component_t *component)
     return EXIT_SUCCESS;
 }
 
-void player_system_destroy(component_t *component)
+int player_system_destroy(component_t *component)
 {
-    free(component->component_data);
+    player_system_data_t *component_data = component->component_data;
+
+    free(component_data);
+
+    return EXIT_SUCCESS;
 }

src/components/sprite_component.c

@@ -3,21 +3,20 @@
 #include "game.h"
 
 // Arg : const char *name
-int sprite_component_init(component_t *component, va_list args)
+int sprite_component_init(component_t *component)
 {
     sprite_component_data_t *component_data = component->component_data;
 
-    component_data->transform_component_data = get_component(component->entity, TRANSFORM_COMPONENT)->component_data;
+    component_data->transform_component_data = entity_get_component(component->entity, TRANSFORM_COMPONENT)->component_data;
+    if(!component_data->transform_component_data) return EXIT_FAILURE;
 
-    frect_to_rect(&component_data->transform_component_data->bounds, &component_data->src_rect);
+    transform_component_data_t *transform_component_data = component_data->transform_component_data;
-    component_data->src_rect.x = 0;
-    component_data->src_rect.y = 0;
 
+    sprite_component_set_texture(component_data, "dummy_sheet");
+    frect_to_rect(&transform_component_data->bounds, &component_data->src_rect);
+    frect_to_rect(&transform_component_data->bounds, &component_data->dst_rect);
     component_data->flip = false;
 
-    component_data->texture = asset_manager_get_texture(&game.asset_manager, va_arg(args, const char *));
-    if(!component_data->texture) return EXIT_FAILURE;
-
     return EXIT_SUCCESS;
 }
 
@@ -37,7 +36,19 @@ inline int sprite_component_draw(component_t *component)
     return EXIT_SUCCESS;
 }
 
-inline void sprite_component_destroy(component_t *component)
+inline int sprite_component_destroy(component_t *component)
 {
-    free(component->component_data);
+    sprite_component_data_t *component_data = component->component_data;
+
+    free(component_data);
+
+    return EXIT_SUCCESS;
+}
+
+inline int sprite_component_set_texture(sprite_component_data_t *component_data, const char *texture_name)
+{
+    component_data->texture = asset_manager_get_texture(&game.asset_manager, texture_name);
+    if(!component_data->texture) return EXIT_FAILURE;
+
+    return EXIT_SUCCESS;
 }

src/components/transform_component.c

@@ -3,15 +3,23 @@
 #include "game.h"
 
 // Args : frect_t bounds, double speed
-int transform_component_init(component_t *component, va_list args)
+int transform_component_init(component_t *component)
 {
-    transform_component_data_t *const component_data = component->component_data;
+    transform_component_data_t *component_data = component->component_data;
 
-    component_data->bounds = va_arg(args, frect_t);
+    component_data->bounds = (frect_t) {
-    component_data->speed = (float)va_arg(args, double);
+        .x = 0.0f,
+        .y = 0.0f,
+        .w = 32.0f,
+        .h = 32.0f
+    };
 
-    component_data->velocity.x = 0.0f;
+    component_data->velocity = (fvector2d_t) {
-    component_data->velocity.y = 0.0f;
+        .x = 0.0f,
+        .y = 0.0f
+    };
+
+    component_data->speed = 0.0f;
 
     return EXIT_SUCCESS;
 }
@@ -26,7 +34,11 @@ int transform_component_update(component_t *component)
     return EXIT_SUCCESS;
 }
 
-inline void transform_component_destroy(component_t *component)
+inline int transform_component_destroy(component_t *component)
 {
-    free(component->component_data);
+    transform_component_data_t *component_data = component->component_data;
+
+    free(component_data);
+
+    return EXIT_SUCCESS;
 }

src/game.c

@@ -5,6 +5,7 @@
 #include "asset_manager.h"
 #include "ecs.h"
 #include "components.h"
+#include "errors.h"
 
 int game_init(void)
 {
@@ -13,29 +14,23 @@ int game_init(void)
     if(display_init()) return EXIT_FAILURE;
 
     if(asset_manager_init(&game.asset_manager)) return EXIT_FAILURE;
+
+    if(asset_manager_load_asset(&game.asset_manager, "dummy_sheet",       ASSET_TEXTURE)) return EXIT_FAILURE;
+    if(asset_manager_load_asset(&game.asset_manager, "player_idle_sheet", ASSET_TEXTURE)) return EXIT_FAILURE;
+    if(asset_manager_load_asset(&game.asset_manager, "player_walk_sheet", ASSET_TEXTURE)) return EXIT_FAILURE;
+    if(asset_manager_load_asset(&game.asset_manager, "player_run_sheet",  ASSET_TEXTURE)) return EXIT_FAILURE;
+
     entity_manager_init(&game.entity_manager);
 
-    entity_t *player = create_entity(0);
+    entity_t *player = entity_manager_new_entity(&game.entity_manager, 0);
-
+    if(!player) return EXIT_FAILURE;
-    if(entity_manager_add_entity(&game.entity_manager, player)) return EXIT_FAILURE;
 
     frect_t player_bounds = {10.0f, 10.0f, 32.0f, 32.0f};
 
-    if(asset_manager_load_asset(&game.asset_manager, "player_idle_sheet", ASSET_TEXTURE)) return EXIT_FAILURE;
+    if(!entity_new_component(player, TRANSFORM_COMPONENT)) return EXIT_FAILURE;
-    if(asset_manager_load_asset(&game.asset_manager, "player_walk_sheet", ASSET_TEXTURE)) return EXIT_FAILURE;
+    if(!entity_new_component(player, SPRITE_COMPONENT)) return EXIT_FAILURE;
-    if(asset_manager_load_asset(&game.asset_manager, "player_run_sheet", ASSET_TEXTURE)) return EXIT_FAILURE;
+    if(!entity_new_component(player, ANIMATION_SYSTEM)) return EXIT_FAILURE;
-
+    if(!entity_new_component(player, PLAYER_SYSTEM)) return EXIT_FAILURE;
-    component_t *component = create_component(TRANSFORM_COMPONENT); if(!component) return EXIT_FAILURE;
-    add_component(player, component, player_bounds, PLAYER_DEFAULT_WALK_SPEED);
-
-    component = create_component(SPRITE_COMPONENT);                 if(!component) return EXIT_FAILURE;
-    add_component(player, component, "player_idle_sheet");
-
-    component = create_component(ANIMATION_SYSTEM);                 if(!component) return EXIT_FAILURE;
-    add_component(player, component, 4, 0, PLAYER_DEFAULT_IDLE_ANIMATION_SPEED, true, true, false);
-
-    component = create_component(PLAYER_SYSTEM);                    if(!component) return EXIT_FAILURE;
-    add_component(player, component);
 
     game.is_running = true;