Finishing to move the sfml and adding a movable component

Makefile

@@ -32,6 +32,7 @@ SRC = src/engine/engine.c \
 	src/deserializer/prefab.c \
 	src/system.c \
 	src/systems/sfml_renderer_system.c \
+	src/systems/movable_system.c \
 	src/systems/parallax_system.c \
 	src/engine/engine_system_builder.c \
 	src/engine/engine_component_builder.c

include/components/movable_component.h

@@ -15,6 +15,7 @@ struct movable_component
     int left_key;
     int right_key;
     int jump_key;
+    int speed;
 };
 
 extern const struct movable_component movable_component;

include/engine.h

@@ -20,6 +20,8 @@ struct gc_engine
 {
     gc_scene *scene;
     bool (*is_open)(gc_engine *engine);
+    bool (*has_focus)(gc_engine *engine);
+    bool (*is_keypressed)(int key);
     void (*handle_events)(gc_engine *engine);
     int (*game_loop)(gc_engine *engine, float dtime);
     void (*draw)(gc_engine *engine);
@@ -37,6 +39,8 @@ struct gc_engine
 
 gc_engine *engine_create();
 bool engine_is_open(gc_engine *engine);
+bool engine_has_focus(gc_engine *engine);
+bool engine_is_keypressed(int key);
 void handle_events(gc_engine *engine);
 void engine_draw(gc_engine *engine);
 int change_scene(gc_engine *engine, gc_scene *scene);

include/prefab.h

@@ -10,5 +10,5 @@
 #include "entity.h"
 
 int prefab_load(gc_engine *engine, const char *path);
-
+int prefab_loadentities(node *n, gc_engine *engine);
 gc_entity *deserialize_entity(gc_engine *engine, node *n);

include/system.h

@@ -17,7 +17,7 @@ struct gc_system
     const char *name;
     const char *component_name;
     bool (*check_dependencies)(const gc_system *, const gc_entity *);
-    void (*update_entity)(void *system, gc_entity *entity, float dtime);
+    void (*update_entity)(gc_engine *, void *system, gc_entity *, float dtime);
     void (*destroy)(void *system);
 };
 

include/systems/movable_system.h

@@ -0,0 +1,12 @@
+/*
+** EPITECH PROJECT, 2019
+** MUL_my_runner_2019
+** File description:
+** movable_system
+*/
+
+#pragma once
+
+#include "system.h"
+
+extern const gc_system movable_system;

include/systems/sfml_renderer_system.h

@@ -21,5 +21,7 @@ struct sfml_renderer_system
 gc_system *gc_new_sfml_renderer(gc_engine *engine, \
 const char *title, int framerate);
 bool sfml_is_open(gc_engine *engine);
+bool sfml_has_focus(gc_engine *engine);
+bool sfml_is_keypressed(int key);
 void sfml_handle_events(gc_engine *engine);
 void sfml_draw(gc_engine *engine);

src/components/movable_component.c

@@ -18,15 +18,17 @@ static void movable_ctr(void *component, va_list args)
     cmp->left_key = va_arg(args, int);
     cmp->right_key = va_arg(args, int);
     cmp->jump_key = va_arg(args, int);
+    cmp->speed = va_arg(args, int);
 }
 
 static void movable_fdctr(gc_engine *engine, void *component, node *n)
 {
     struct movable_component *cmp = (struct movable_component *)component;
 
-    cmp->left_key = xml_getproperty(n, "left")[0];
-    cmp->right_key = xml_getproperty(n, "right")[0];
-    cmp->jump_key = xml_getproperty(n, "jump")[0];
+    cmp->left_key = xml_getintprop(n, "left");
+    cmp->right_key = xml_getintprop(n, "right");
+    cmp->jump_key = xml_getintprop(n, "jump");
+    cmp->speed = xml_getintprop(n, "speed");
     (void)engine;
 }
 
@@ -45,14 +47,15 @@ const struct movable_component movable_component = {
     base: {
         name: "MovableComponent",
         size: sizeof(struct movable_component),
-        dependencies: (char *[]){NULL},
+        dependencies: (char *[]){"TransformComponent", NULL},
         ctr: &movable_ctr,
         fdctr: &movable_fdctr,
         dtr: &movable_dtr,
         serialize: &movable_serialize,
         destroy: &component_destroy
     },
-    left_key: 'Q',
+    left_key: 16,
     right_key: 'D',
-    jump_key: ' '
+    jump_key: ' ',
+    speed: 10
 };

src/deserializer/prefab.c

@@ -17,13 +17,20 @@
 int prefab_load(gc_engine *engine, const char *path)
 {
     node *n;
-    gc_entity *entity;
 
     if (!engine || !engine->scene)
         return (-1);
     n = xml_parse(path);
-    if (!n)
+    if (!n || prefab_loadentities(n, engine) < 0)
         return (-1);
+    xml_destroy(n);
+    return (0);
+}
+
+int prefab_loadentities(node *n, gc_engine *engine)
+{
+    gc_entity *entity;
+
     n = xml_getnode(n, "gc_entities");
     if (!n)
         return (-1);
@@ -33,6 +40,5 @@ int prefab_load(gc_engine *engine, const char *path)
             return (-1);
         engine->scene->add_entity(engine->scene, entity);
     }
-    xml_destroy(n);
     return (0);
-}
+}

src/engine/engine.c

@@ -21,12 +21,14 @@ void update_system(gc_engine *engine, gc_system *sys, float dtime)
     entities = scene->get_entity_by_cmp(scene, sys->component_name);
     for (gc_list *entity = entities; entity; entity = entity->next) {
         if (sys->check_dependencies(sys, entity->data))
-            sys->update_entity(sys, entity->data, dtime);
+            sys->update_entity(engine, sys, entity->data, dtime);
     }
 }
 
 int game_loop(gc_engine *engine, float dtime)
 {
+    if (!engine->has_focus(engine))
+        return (0);
     engine->handle_events(engine);
     for (gc_list *sys = engine->systems; sys; sys = sys->next)
         update_system(engine, sys->data, dtime);
@@ -56,6 +58,8 @@ gc_engine *engine_create()
         return (NULL);
     engine->scene = NULL;
     engine->is_open = &engine_is_open;
+    engine->has_focus = &engine_has_focus;
+    engine->is_keypressed = &engine_is_keypressed;
     engine->handle_events = &handle_events;
     engine->game_loop = &game_loop;
     engine->draw = &engine_draw;

src/engine/engine_internal.c

@@ -14,6 +14,12 @@ bool engine_is_open(gc_engine *engine)
     return (false);
 }
 
+bool engine_has_focus(gc_engine *engine)
+{
+    (void)engine;
+    return (true);
+}
+
 void handle_events(gc_engine *engine)
 {
     (void)engine;
@@ -24,10 +30,8 @@ void engine_draw(gc_engine *engine)
     (void)engine;
 }
 
-int change_scene(gc_engine *engine, gc_scene *scene)
+bool engine_is_keypressed(int key)
 {
-    if (engine->scene)
-        engine->scene->destroy(engine->scene);
-    engine->scene = scene;
-    return (0);
+    (void)key;
+    return (false);
 }

src/engine/engine_system_builder.c

@@ -8,6 +8,7 @@
 #include "engine.h"
 #include "system.h"
 #include "systems/sfml_renderer_system.h"
+#include "systems/movable_system.h"
 #include "systems/parallax_system.h"
 #include <stdlib.h>
 
@@ -22,6 +23,7 @@ void engine_add_buildin_systems(gc_engine *engine)
     engine->add_system = &engine_add_system;
     engine->get_system = &engine_get_system;
     engine->add_system(engine, &parallax_system);
+    engine->add_system(engine, &movable_system);
 }
 
 int engine_use_sfml(gc_engine *engine, const char *title, int framerate)

src/renderer/sfml_functions.c

@@ -17,6 +17,19 @@ engine->get_system(engine, "SfmlRendererSystem");
     return (sfRenderWindow_isOpen(renderer->window));
 }
 
+bool sfml_has_focus(gc_engine *engine)
+{
+    sfml_renderer_system *renderer = (sfml_renderer_system *)\
+engine->get_system(engine, "SfmlRendererSystem");
+
+    return (sfRenderWindow_hasFocus(renderer->window));
+}
+
+bool sfml_is_keypressed(int key)
+{
+    return (sfKeyboard_isKeyPressed(key));
+}
+
 void sfml_handle_events(gc_engine *engine)
 {
     sfml_renderer_system *renderer = (sfml_renderer_system *)\

src/scene/scene.c

@@ -66,4 +66,12 @@ gc_scene *scene_create(const char **textures)
     scene->get_entity_by_cmp = &get_entity_by_cmp;
     scene->destroy = &scene_destroy;
     return (scene);
+}
+
+int change_scene(gc_engine *engine, gc_scene *scene)
+{
+    if (engine->scene)
+        engine->scene->destroy(engine->scene);
+    engine->scene = scene;
+    return (0);
 }

src/scene/scene_creator.c

@@ -1,8 +0,0 @@
-/*
-** EPITECH PROJECT, 2019
-** MUL_my_runner_2019
-** File description:
-** scene_creator
-*/
-
-int scene_create_fromxml()

src/systems/movable_system.c

@@ -0,0 +1,43 @@
+/*
+** EPITECH PROJECT, 2019
+** MUL_my_runner_2019
+** File description:
+** movable_system
+*/
+
+#include "entity.h"
+#include "system.h"
+#include "texture.h"
+#include "vector2.h"
+#include "components/movable_component.h"
+#include "components/transform_component.h"
+#include "components/renderer.h"
+#include <stddef.h>
+
+void movable_update_entity(gc_engine *engine, void *system,\
+gc_entity *entity, float dtime)
+{
+    struct movable_component *mov = (struct movable_component *)\
+entity->get_component(entity, "MovableComponent");
+    struct transform_component *pos = (struct transform_component *)\
+entity->get_component(entity, "TransformComponent");
+
+    if (engine->is_keypressed(mov->left_key))
+        pos->position.x -= mov->speed * dtime;
+    if (engine->is_keypressed(mov->right_key))
+        pos->position.x += mov->speed * dtime;
+    (void)system;
+}
+
+void movable_destroy(void *system)
+{
+    (void)system;
+}
+
+const gc_system movable_system = {
+    name: "MovableSystem",
+    component_name: "MovableComponent",
+    check_dependencies: &system_check_dependencies,
+    update_entity: &movable_update_entity,
+    destroy: &movable_destroy
+};

src/systems/parallax_system.c

@@ -13,7 +13,8 @@
 #include "components/renderer.h"
 #include <stddef.h>
 
-void parallax_update_entity(void *system, gc_entity *entity, float dtime)
+void parallax_update_entity(gc_engine *engine, void *system, \
+gc_entity *entity, float dtime)
 {
     struct renderer *text = \
 (struct renderer *)entity->get_component(entity, "Renderer");
@@ -24,6 +25,7 @@ void parallax_update_entity(void *system, gc_entity *entity, float dtime)
         return;
     text->sprite->rect.left += parallax->speed * dtime;
     (void)system;
+    (void)engine;
 }
 
 void parallax_destroy(void *system)

src/systems/sfml_renderer_system.c

@@ -35,7 +35,8 @@ void renderer_draw_texture(sfml_renderer_system *renderer, gc_sprite *sprite)
     sfRenderWindow_drawSprite(renderer->window, renderer->sprite, NULL);
 }
 
-void sfml_update_entity(void *system, gc_entity *entity, float dtime)
+void sfml_update_entity(gc_engine *engine, void *system,\
+gc_entity *entity, float dtime)
 {
     struct transform_component *pos = (struct transform_component *)\
 entity->get_component(entity, "TransformComponent");
@@ -49,6 +50,7 @@ entity->get_component(entity, "Renderer");
     if (text->type == GC_TEXTUREREND)
         renderer_draw_texture((sfml_renderer_system *)system, text->sprite);
     (void)dtime;
+    (void)engine;
 }
 
 void sfml_destroy(void *system)
@@ -87,6 +89,8 @@ const char *title, int framerate)
         return (NULL);
     sfRenderWindow_setFramerateLimit(renderer->window, framerate);
     engine->is_open = &sfml_is_open;
+    engine->has_focus = &sfml_has_focus;
+    engine->is_keypressed = &sfml_is_keypressed;
     engine->handle_events = &sfml_handle_events;
     engine->draw = &sfml_draw;
     return ((gc_system *)renderer);