Moving collisions to it's own component

Makefile

@@ -13,6 +13,7 @@ SRC = src/engine/engine.c \
 	src/entity/entity_factory.c \
 	src/component.c \
 	src/components/movable_component.c \
+	src/components/collision_component.c \
 	src/components/transform_component.c \
 	src/components/renderer.c \
 	src/components/parallax_component.c \
@@ -29,6 +30,7 @@ SRC = src/engine/engine.c \
 	src/system.c \
 	src/systems/sfml_renderer_system.c \
 	src/systems/movable_system.c \
+	src/systems/collision_system.c \
 	src/systems/parallax_system.c \
 	src/systems/gravity_system.c \
 	src/systems/controllers/keyboard_controller_system.c \

include/components/collision_component.h

@@ -0,0 +1,19 @@
+/*
+** EPITECH PROJECT, 2020
+** Twac
+** File description:
+** collision_component
+*/
+
+#pragma once
+
+struct collision_component
+{
+    gc_component base;
+    int distance_down;
+    int distance_top;
+    int distance_left;
+    int distance_right;
+};
+
+extern const struct collision_component collision_component;

include/systems/collision_system.h

@@ -0,0 +1,20 @@
+/*
+** EPITECH PROJECT, 2019
+** MUL_my_runner_2019
+** File description:
+** movable_system
+*/
+
+#pragma once
+
+#include "system.h"
+#include "quadtree.h"
+
+typedef struct gc_collision_system
+{
+    gc_system base;
+    quadtree *tree;
+
+} gc_collision_system;
+
+extern const gc_collision_system collision_system;

include/systems/movable_system.h

@@ -10,11 +10,4 @@
 #include "system.h"
 #include "quadtree.h"
 
-typedef struct gc_movable_system
-{
-    gc_system base;
-    quadtree *tree;
-
-} gc_movable_system;
-
-extern const gc_movable_system movable_system;
+extern const gc_system movable_system;

src/components/collision_component.c

@@ -0,0 +1,58 @@
+/*
+** EPITECH PROJECT, 2020
+** Twac
+** File description:
+** collision_component
+*/
+
+#include "xml.h"
+#include "component.h"
+#include "components/collision_component.h"
+#include "utility.h"
+#include <stdlib.h>
+
+static void ctr(void *component, va_list args)
+{
+    struct collision_component *cmp = (struct collision_component *)component;
+
+    cmp->distance_down = 1024;
+    cmp->distance_top = 1024;
+    cmp->distance_left = 1024;
+    cmp->distance_right = 1024;
+    (void)args;
+}
+
+static void fdctr(gc_scene *scene, void *component, node *n)
+{
+    struct collision_component *cmp = (struct collision_component *)component;
+    cmp->distance_down = 1024;
+    cmp->distance_top = 1024;
+    cmp->distance_left = 1024;
+    cmp->distance_right = 1024;
+    (void)n;
+    (void)scene;
+}
+
+static void dtr(void *component)
+{
+    (void)component;
+}
+
+static char *serialize(void *component)
+{
+    (void)component;
+    return (NULL);
+}
+
+const struct collision_component collision_component = {
+    base: {
+        name: "collision_component",
+        size: sizeof(struct collision_component),
+        dependencies: (char *[]){"collision_component", NULL},
+        ctr: &ctr,
+        fdctr: &fdctr,
+        dtr: &dtr,
+        serialize: &serialize,
+        destroy: &component_destroy
+    }
+};

src/components/movable_component.c

@@ -44,7 +44,11 @@ const struct movable_component movable_component = {
     base: {
         name: "movable_component",
         size: sizeof(struct movable_component),
-        dependencies: (char *[]){"transform_component", NULL},
+        dependencies: (char *[]){
+            "transform_component", 
+            "collision_component",
+            NULL
+        },
         ctr: &movable_ctr,
         fdctr: &movable_fdctr,
         dtr: &movable_dtr,

src/engine/engine_component_builder.c

@@ -15,6 +15,7 @@
 #include "components/gravity_component.h"
 #include "components/controllers/keyboard_controller.h"
 #include "components/friction_component.h"
+#include "components/collision_component.h"
 #include <stdlib.h>
 
 void engine_add_component(gc_engine *engine, const void *component)
@@ -35,4 +36,5 @@ void engine_add_buildin_components(gc_engine *engine)
     engine->add_component(engine, &keyboard_controller);
     engine->add_component(engine, &gravity_component);
     engine->add_component(engine, &friction_component);
+    engine->add_component(engine, &collision_component);
 }

src/engine/engine_system_builder.c

@@ -13,6 +13,7 @@
 #include "systems/gravity_system.h"
 #include "systems/controllers/keyboard_controller_system.h"
 #include "systems/friction_system.h"
+#include "systems/collision_system.h"
 #include <stdlib.h>
 
 void engine_add_system(gc_engine *engine, const gc_system *system)
@@ -34,6 +35,7 @@ void engine_add_buildin_systems(gc_engine *engine)
     engine->add_system(engine, &parallax_system);
     engine->add_system(engine, &keyboard_controller_system);
     engine->add_system(engine, &friction_system);
+    engine->add_system(engine, new_system(&collision_system, engine->scene));
     engine->add_system(engine, &gravity_system);
 }
 

src/systems/collision_system.c

@@ -0,0 +1,78 @@
+/*
+** EPITECH PROJECT, 2020
+** Twac
+** File description:
+** collision_system
+*/
+
+#include "entity.h"
+#include "system.h"
+#include "texture.h"
+#include "vector2.h"
+#include "utility.h"
+#include "components/collision_component.h"
+#include "components/transform_component.h"
+#include "components/renderer.h"
+#include "systems/collision_system.h"
+#include <stddef.h>
+
+static void update_entity(gc_engine *engine __attribute__((unused)), \
+void *system, gc_entity *entity, float dtime __attribute__((unused)))
+{
+    gc_collision_system *sys = (gc_collision_system *)system;
+    struct collision_component *col = GETCMP(collision_component);
+    struct transform_component *pos = GETCMP(transform_component);
+    qt_object obj = (qt_object) {entity->id,
+        {pos->position.x, pos->position.y, pos->size.y, pos->size.x}
+    };
+    // if (GETCMP(movable_component) != NULL)
+        qt_update(sys->tree, obj);
+    qt_collision i = collision_get_info(sys->tree, entity->id);
+    col->distance_down = i.distance_down;
+    col->distance_top = i.distance_top;
+    col->distance_left = i.distance_left;
+    col->distance_right = i.distance_right;
+}
+
+static void ctr(void *system, va_list args)
+{
+    gc_collision_system *col = (gc_collision_system *)system;
+    // gc_scene *scene = va_arg(args, gc_scene *);
+    // struct transform_component *pos;
+    // gc_entity *entity;
+    // qt_object obj;
+
+    col->tree = qt_create((qt_intrect){-1000, -1000, 2000, 2000}, 25);
+    // for (gc_list *ent = scene->entities; ent; ent = ent->next) {
+    //     entity = (gc_entity *)ent->data;
+    //     pos = GETCMP(transform_component);
+    //     obj.id = entity->id;
+    //     obj.rect.x = pos->position.x;
+    //     obj.rect.y = pos->position.y;
+    //     obj.rect.w = pos->size.x;
+    //     obj.rect.h = pos->size.y;
+    //     qt_add(col->tree, obj);
+    // }
+}
+
+static void dtr(void *system)
+{
+    gc_collision_system *mov = (gc_collision_system *)system;
+
+    qt_destroy(mov->tree);
+    (void)system;
+}
+
+const gc_collision_system collision_system = {
+    base: {
+        name: "CollisionSystem",
+        component_name: "collision_component",
+        size: sizeof(gc_collision_system),
+        ctr: &ctr,
+        dtr: &dtr,
+        check_dependencies: &system_check_dependencies,
+        update_entity: &update_entity,
+        destroy: &system_destroy
+    },
+    tree: NULL
+};

src/systems/movable_system.c

@@ -11,45 +11,37 @@
 #include "vector2.h"
 #include "utility.h"
 #include "components/movable_component.h"
+#include "components/collision_component.h"
 #include "components/transform_component.h"
 #include "components/renderer.h"
 #include "systems/movable_system.h"
 #include <stddef.h>
 
-void move_entity(gc_entity *entity, struct movable_component *mov, \
-quadtree *tree, float dtime)
+void move_entity(gc_entity *entity, struct movable_component *mov, float dtime)
 {
     struct transform_component *pos = GETCMP(transform_component);
-    qt_collision i = collision_get_info(tree, entity->id);
-    qt_object obj = (qt_object) {entity->id,
-        {pos->position.x, pos->position.y, pos->size.y, pos->size.x}
-    };
+    struct collision_component *col = GETCMP(collision_component);
 
     if (mov->velocity.x < 0)
-        pos->position.x -= MIN(mov->velocity.x * -dtime, i.distance_left);
+        pos->position.x -= MIN(mov->velocity.x * -dtime, col->distance_left);
     else
-        pos->position.x += MIN(mov->velocity.x * dtime, i.distance_right);
+        pos->position.x += MIN(mov->velocity.x * dtime, col->distance_right);
     if (mov->velocity.y < 0)
-        pos->position.y -= MIN(mov->velocity.y * -dtime, i.distance_down);
+        pos->position.y -= MIN(mov->velocity.y * -dtime, col->distance_down);
     else
-        pos->position.y += MIN(mov->velocity.y * dtime, i.distance_top);
-    if (i.distance_left == 0 || i.distance_right == 0)
+        pos->position.y += MIN(mov->velocity.y * dtime, col->distance_top);
+    if (col->distance_left == 0 || col->distance_right == 0)
         mov->velocity.x = 0;
-    if (i.distance_down == 0 || i.distance_top == 0)
+    if (col->distance_down == 0 || col->distance_top == 0)
         mov->velocity.y = 0;
-    obj.rect.x = pos->position.x;
-    obj.rect.y = pos->position.y;
-    qt_update(tree, obj);
 }
 
 void movable_update_entity(gc_engine *engine __attribute__((unused)), \
 void *system __attribute__((unused)), gc_entity *entity, float dtime)
 {
     struct movable_component *mov = GETCMP(movable_component);
-    gc_movable_system *sys = (gc_movable_system *)system;
 
-    // if (mov->speed_x != 0 || mov->speed_y != 0) AND IS ALREADY INSIDE THE TREE
-    move_entity(entity, mov, sys->tree, dtime);
+    move_entity(entity, mov, dtime);
     mov->velocity.x += mov->acceleration.x * dtime;
     mov->velocity.y += mov->acceleration.y * dtime;
     mov->acceleration.x = 0;
@@ -57,30 +49,22 @@ void *system __attribute__((unused)), gc_entity *entity, float dtime)
 
 void movable_ctr(void *system, va_list args)
 {
-    gc_movable_system *mov = (gc_movable_system *)system;
-
-    mov->tree = qt_create((qt_intrect){-1000, -1000, 2000, 2000}, 25);
+    (void)system;
     (void)args;
 }
 
 void movable_dtr(void *system)
 {
-    gc_movable_system *mov = (gc_movable_system *)system;
-
-    qt_destroy(mov->tree);
     (void)system;
 }
 
-const gc_movable_system movable_system = {
-    base: {
-        name: "MovableSystem",
-        component_name: "movable_component",
-        size: sizeof(gc_movable_system),
-        ctr: &movable_ctr,
-        dtr: &movable_dtr,
-        check_dependencies: &system_check_dependencies,
-        update_entity: &movable_update_entity,
-        destroy: &system_destroy
-    },
-    tree: NULL
+const gc_system movable_system = {
+    name: "MovableSystem",
+    component_name: "movable_component",
+    size: sizeof(gc_system),
+    ctr: &movable_ctr,
+    dtr: &movable_dtr,
+    check_dependencies: &system_check_dependencies,
+    update_entity: &movable_update_entity,
+    destroy: &system_destroy
 };

src/systems/sfml_renderer_system.c

@@ -27,7 +27,7 @@ gc_sprite *sprite)
     };
 
     if (!sprite->texture)
-        return (NULL);
+        return;
     t = sfTexture_getSize(sprite->texture->texture);
     scale = (sfVector2f){sprite->size.x / t.x, sprite->size.y / t.y};
     sfSprite_setTexture(renderer->sprite, sprite->texture->texture, true);