ulysse
/
2D_Engine_C
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

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.

This commit is contained in:
Ulysse Cura 2026-07-30 18:02:46 +02:00
parent 0092f9cbe3
commit b9805aaeb1
10 changed files with 163 additions and 105 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
SDL3_Core

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

89
src/components/animation_system.c
View File

@ -4,26 +4,28 @@
#include "memory_alloc.h" #include "memory_alloc.h"
#include "errors.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; 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; 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) int animation_system_update(component_t *component)
@ -32,23 +34,23 @@ int animation_system_update(component_t *component)
if(system_data->play) 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) 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->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) 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 else
{ {
@ -57,15 +59,15 @@ int animation_system_update(component_t *component)
} }
else 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) 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 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; 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; 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); free(system_data);
return EXIT_SUCCESS;
} }
int animation_system_create_frames_clips(animation_system_data_t *system_data) 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)->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; 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; 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; return EXIT_SUCCESS;
} }

10
src/components/headers/animation_system.h
View File

@ -10,8 +10,8 @@ typedef struct animation_system_data_t {
size_t nb_frames; size_t nb_frames;
linked_list_t 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_delay_ms;
float frame_timer_ms; float frame_timer_ms;
@ -21,14 +21,14 @@ typedef struct animation_system_data_t {
bool reverse :1; bool reverse :1;
} animation_system_data_t; } 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); 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_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 #endif // SPRITE_COMPONENT_H

8
src/components/headers/player_system.h
View File

@ -10,7 +10,7 @@
#define PLAYER_DEFAULT_RUN_SPEED 100.0f // px / s #define PLAYER_DEFAULT_RUN_SPEED 100.0f // px / s
#define PLAYER_DEFAULT_IDLE_ANIMATION_SPEED 500.0f // ms / frame #define PLAYER_DEFAULT_IDLE_ANIMATION_SPEED 500.0f // ms / frame
#define PLAYER_DEFAULT_WALK_ANIMATION_SPEED 160.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 { typedef enum player_state_t {
PLAYER_IDLE = 0x00, // 00000000 PLAYER_IDLE = 0x00, // 00000000
@ -32,10 +32,10 @@ typedef struct player_system_data_t {
player_state_t last_state; player_state_t last_state;
} player_system_data_t; } 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 #endif // PLAYER_SYSTEM_H

10
src/components/headers/sprite_component.h
View File

@ -16,12 +16,14 @@ typedef struct sprite_component_data_t {
bool flip; bool flip;
} sprite_component_data_t; } 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 #endif // SPRITE_COMPONENT_H

6
src/components/headers/transform_component.h
View File

@ -10,10 +10,10 @@ typedef struct transform_component_data_t {
float speed; float speed;
} transform_component_data_t; } 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 #endif // TRANSFORM_COMPONENT_H

53
src/components/player_system.c
View File

@ -7,15 +7,32 @@
#include "transform_component.h" #include "transform_component.h"
// No args // 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; 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->sprite_component_data = system_data->animation_system_data->sprite_component_data;
system_data->transform_component_data = system_data->sprite_component_data->transform_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->state = PLAYER_IDLE;
system_data->last_state = PLAYER_IDLE;
return EXIT_SUCCESS; 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) if(system_data->state & PLAYER_RUNNING)
{ {
transform_component_data->speed = PLAYER_DEFAULT_RUN_SPEED; 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->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 else
{ {
transform_component_data->speed = PLAYER_DEFAULT_WALK_SPEED; 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->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)) 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->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; return EXIT_SUCCESS;
@ -121,7 +148,11 @@ int player_system_update(component_t *component)
return EXIT_SUCCESS; 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;
} }

31
src/components/sprite_component.c
View File

@ -3,21 +3,20 @@
#include "game.h" #include "game.h"
// Arg : const char *name // 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; 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->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; return EXIT_SUCCESS;
} }
@ -37,7 +36,19 @@ inline int sprite_component_draw(component_t *component)
return EXIT_SUCCESS; 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;
} }

28
src/components/transform_component.c
View File

@ -3,15 +3,23 @@
#include "game.h" #include "game.h"
// Args : frect_t bounds, double speed // 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; return EXIT_SUCCESS;
} }
@ -26,7 +34,11 @@ int transform_component_update(component_t *component)
return EXIT_SUCCESS; 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;
} }

31
src/game.c
View File

@ -5,6 +5,7 @@
#include "asset_manager.h" #include "asset_manager.h"
#include "ecs.h" #include "ecs.h"
#include "components.h" #include "components.h"
#include "errors.h"
int game_init(void) int game_init(void)
{ {
@ -13,29 +14,23 @@ int game_init(void)
if(display_init()) return EXIT_FAILURE; if(display_init()) return EXIT_FAILURE;
if(asset_manager_init(&game.asset_manager)) 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_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}; 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; game.is_running = true;