Replace director with manager

director.c

@@ -1,58 +0,0 @@
-#include "director.h"
-#include "director_i.h"
-#include "level_manager.h"
-#include <stdlib.h>
-#include <string.h>
-
-struct Director {
-    RunningGameEngine* engine;
-    LevelManager* level_manager;
-    InputState input;
-    void* game_context;
-};
-
-Director* director_alloc() {
-    Director* director = malloc(sizeof(Director));
-    memset(director, 0, sizeof(Director));
-    return director;
-}
-
-void director_free(Director* director) {
-    free(director);
-}
-
-void director_input_set(Director* director, InputState input) {
-    director->input = input;
-}
-
-void director_engine_set(Director* director, RunningGameEngine* engine) {
-    director->engine = engine;
-}
-
-void director_level_manager_set(Director* director, LevelManager* level_manager) {
-    director->level_manager = level_manager;
-}
-
-InputState director_input_get(Director* director) {
-    return director->input;
-}
-
-RunningGameEngine* director_engine_get(Director* director) {
-    return director->engine;
-}
-
-LevelManager* director_level_manager_get(Director* director) {
-    return director->level_manager;
-}
-
-Level* director_level_get(Director* director) {
-    return level_manager_current_level_get(director->level_manager);
-}
-
-void* director_game_context_get(Director* director) {
-    return director->game_context;
-}
-
-void director_game_context_set(Director* director, void* context) {
-    director->game_context = context;
-}

director.h

@@ -1,25 +0,0 @@
-#pragma once
-#include "game_engine.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef struct Director Director;
-typedef struct RunningGameEngine RunningGameEngine;
-typedef struct LevelManager LevelManager;
-typedef struct Level Level;
-
-InputState director_input_get(Director* director);
-
-RunningGameEngine* director_engine_get(Director* director);
-
-LevelManager* director_level_manager_get(Director* director);
-
-Level* director_level_get(Director* director);
-
-void* director_game_context_get(Director* director);
-
-#ifdef __cplusplus
-}
-#endif

director_i.h

@@ -1,22 +0,0 @@
-#pragma once
-#include "director.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-Director* director_alloc();
-
-void director_free(Director* director);
-
-void director_input_set(Director* director, InputState input);
-
-void director_engine_set(Director* director, RunningGameEngine* engine);
-
-void director_level_manager_set(Director* director, LevelManager* level_manager);
-
-void director_game_context_set(Director* director, void* context);
-
-#ifdef __cplusplus
-}
-#endif

engine.h

@@ -2,12 +2,11 @@
 #include <furi.h>
 #include "game_engine.h"
 #include "level.h"
-#include "level_manager.h"
-#include "director.h"
 #include "entity.h"
+#include "game_manager.h"
 
 typedef struct {
-    void (*start)(LevelManager* level_manager, void* context);
+    void (*start)(GameManager* game_manager, void* context);
     void (*stop)(void* context);
     size_t context_size;
 } Game;

entity.c

@@ -126,21 +126,21 @@ void entity_call_stop(Level* level, Entity* entity) {
     }
 }
 
-void entity_call_update(Entity* entity, Director* director) {
+void entity_call_update(Entity* entity, GameManager* manager) {
     if(entity->description && entity->description->update) {
-        entity->description->update(entity, director, entity->context);
+        entity->description->update(entity, manager, entity->context);
     }
 }
 
-void entity_call_render(Entity* entity, Director* director, Canvas* canvas) {
+void entity_call_render(Entity* entity, GameManager* manager, Canvas* canvas) {
     if(entity->description && entity->description->render) {
-        entity->description->render(entity, director, canvas, entity->context);
+        entity->description->render(entity, manager, canvas, entity->context);
     }
 }
 
-void entity_call_collision(Entity* entity, Entity* other, Director* director) {
+void entity_call_collision(Entity* entity, Entity* other, GameManager* manager) {
     if(entity->description && entity->description->collision) {
-        entity->description->collision(entity, other, director, entity->context);
+        entity->description->collision(entity, other, manager, entity->context);
     }
 }
 

entity.h

@@ -1,6 +1,5 @@
 #pragma once
 #include "game_engine.h"
-#include "director.h"
 #include <stdlib.h>
 
 #ifdef __cplusplus
@@ -9,6 +8,8 @@ extern "C" {
 
 typedef struct Entity Entity;
 
+typedef struct Level Level;
+
 typedef struct {
     float x;
     float y;
@@ -27,13 +28,16 @@ typedef struct {
     EntityEventValue value;
 } EntityEvent;
 
+typedef struct Level Level;
+typedef struct GameManager GameManager;
+
 typedef struct {
     void (*start)(Entity* self, Level* level, void* context);
     void (*stop)(Entity* self, Level* level, void* context);
-    void (*update)(Entity* self, Director* director, void* context);
-    void (*render)(Entity* self, Director* director, Canvas* canvas, void* context);
-    void (*collision)(Entity* self, Entity* other, Director* director, void* context);
-    void (*event)(Entity* self, Director* director, EntityEvent event, void* context);
+    void (*update)(Entity* self, GameManager* manager, void* context);
+    void (*render)(Entity* self, GameManager* manager, Canvas* canvas, void* context);
+    void (*collision)(Entity* self, Entity* other, GameManager* manager, void* context);
+    void (*event)(Entity* self, GameManager* manager, EntityEvent event, void* context);
     size_t context_size;
 } EntityDescription;
 

entity_i.h

@@ -1,6 +1,6 @@
 #pragma once
 #include "entity.h"
-#include "director.h"
+#include "game_manager.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -14,11 +14,11 @@ void entity_call_start(Level* level, Entity* entity);
 
 void entity_call_stop(Level* level, Entity* entity);
 
-void entity_call_update(Entity* entity, Director* director);
+void entity_call_update(Entity* entity, GameManager* manager);
 
-void entity_call_render(Entity* entity, Director* director, Canvas* canvas);
+void entity_call_render(Entity* entity, GameManager* manager, Canvas* canvas);
 
-void entity_call_collision(Entity* entity, Entity* other, Director* director);
+void entity_call_collision(Entity* entity, Entity* other, GameManager* manager);
 
 bool entity_collider_check_collision(Entity* entity, Entity* other);
 

game_manager.c

@@ -0,0 +1,101 @@
+#include "game_manager.h"
+#include "level_i.h"
+#include <furi.h>
+#include <m-list.h>
+
+LIST_DEF(LevelList, Level*, M_POD_OPLIST);
+
+struct GameManager {
+    LevelList_t levels;
+    Level* current_level;
+    Level* next_level;
+
+    RunningGameEngine* engine;
+    InputState input;
+    void* game_context;
+};
+
+GameManager* game_manager_alloc() {
+    GameManager* manager = malloc(sizeof(GameManager));
+    LevelList_init(manager->levels);
+    manager->current_level = NULL;
+    manager->next_level = NULL;
+    manager->engine = NULL;
+    manager->game_context = NULL;
+    memset(&manager->input, 0, sizeof(InputState));
+    return manager;
+}
+
+void game_manager_free(GameManager* manager) {
+    level_call_stop(manager->current_level);
+
+    LevelList_it_t it;
+    LevelList_it(it, manager->levels);
+    while(!LevelList_end_p(it)) {
+        level_call_free(*LevelList_cref(it));
+        level_free(*LevelList_cref(it));
+        LevelList_next(it);
+    }
+
+    LevelList_clear(manager->levels);
+    free(manager);
+}
+
+Level* game_manager_add_level(GameManager* manager, const LevelBehaviour* behaviour) {
+    UNUSED(manager);
+    Level* level = level_alloc(behaviour);
+    LevelList_push_back(manager->levels, level);
+    level_call_alloc(level);
+    if(!manager->current_level) {
+        manager->current_level = level;
+        level_call_start(level);
+    }
+    return level;
+}
+
+void game_manager_next_level_set(GameManager* manager, Level* next_level) {
+    manager->next_level = next_level;
+}
+
+Level* game_manager_current_level_get(GameManager* manager) {
+    return manager->current_level;
+}
+
+void game_manager_update(GameManager* manager) {
+    if(manager->next_level) {
+        level_call_stop(manager->current_level);
+        manager->current_level = manager->next_level;
+        level_call_start(manager->current_level);
+        manager->next_level = NULL;
+    }
+
+    level_update(manager->current_level, manager);
+}
+
+void game_manager_render(GameManager* manager, Canvas* canvas) {
+    level_render(manager->current_level, manager, canvas);
+}
+
+void game_manager_engine_set(GameManager* manager, RunningGameEngine* engine) {
+    manager->engine = engine;
+}
+
+void game_manager_input_set(GameManager* manager, InputState input) {
+    manager->input = input;
+}
+
+void game_manager_game_context_set(GameManager* manager, void* context) {
+    manager->game_context = context;
+}
+
+RunningGameEngine* game_manager_engine_get(GameManager* manager) {
+    return manager->engine;
+}
+
+InputState game_manager_input_get(GameManager* manager) {
+    return manager->input;
+}
+
+void* game_manager_game_context_get(GameManager* manager) {
+    return manager->game_context;
+}

game_manager.h

@@ -0,0 +1,25 @@
+#pragma once
+#include "level.h"
+#include "game_engine.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct GameManager GameManager;
+
+Level* game_manager_add_level(GameManager* manager, const LevelBehaviour* behaviour);
+
+void game_manager_next_level_set(GameManager* manager, Level* level);
+
+Level* game_manager_current_level_get(GameManager* manager);
+
+RunningGameEngine* game_manager_engine_get(GameManager* manager);
+
+InputState game_manager_input_get(GameManager* manager);
+
+void* game_manager_game_context_get(GameManager* manager);
+
+#ifdef __cplusplus
+}
+#endif

game_manager_i.h

@@ -0,0 +1,24 @@
+#pragma once
+#include "game_manager.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+GameManager* game_manager_alloc(void);
+
+void game_manager_free(GameManager* manager);
+
+void game_manager_update(GameManager* manager);
+
+void game_manager_render(GameManager* manager, Canvas* canvas);
+
+void game_manager_engine_set(GameManager* manager, RunningGameEngine* engine);
+
+void game_manager_input_set(GameManager* manager, InputState input);
+
+void game_manager_game_context_set(GameManager* manager, void* context);
+
+#ifdef __cplusplus
+}
+#endif

level.c

@@ -122,13 +122,13 @@ void level_remove_entity(Level* level, Entity* entity) {
     entity_call_stop(level, entity);
 }
 
-static void level_process_update(Level* level, Director* director) {
+static void level_process_update(Level* level, GameManager* manager) {
     FOREACH(item, level->entities) {
-        entity_call_update(*item, director);
+        entity_call_update(*item, manager);
     }
 }
 
-static void level_process_collision(Level* level, Director* director) {
+static void level_process_collision(Level* level, GameManager* manager) {
     EntityList_it_t it_first;
     EntityList_it_t it_second;
 
@@ -144,8 +144,8 @@ static void level_process_collision(Level* level, Director* director) {
                     Entity* first = *EntityList_ref(it_first);
                     Entity* second = *EntityList_ref(it_second);
                     if(entity_collider_check_collision(first, second)) {
-                        entity_call_collision(first, second, director);
-                        entity_call_collision(second, first, director);
+                        entity_call_collision(first, second, manager);
+                        entity_call_collision(second, first, manager);
                     }
                 }
                 EntityList_next(it_second);
@@ -155,16 +155,16 @@ static void level_process_collision(Level* level, Director* director) {
     }
 }
 
-void level_update(Level* level, Director* director) {
+void level_update(Level* level, GameManager* manager) {
     level_process_add(level);
     level_process_remove(level);
-    level_process_update(level, director);
-    level_process_collision(level, director);
+    level_process_update(level, manager);
+    level_process_collision(level, manager);
 }
 
-void level_render(Level* level, Director* director, Canvas* canvas) {
+void level_render(Level* level, GameManager* manager, Canvas* canvas) {
     FOREACH(item, level->entities) {
-        entity_call_render(*item, director, canvas);
+        entity_call_render(*item, manager, canvas);
     }
 }
 

level.h

@@ -1,13 +1,11 @@
 #pragma once
+#include <stddef.h>
 #include "entity.h"
-#include "director.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-typedef struct Level Level;
-
 typedef struct {
     void (*alloc)(Level* level, void* context);
     void (*free)(Level* level, void* context);

level_i.h

@@ -9,9 +9,9 @@ Level* level_alloc(const LevelBehaviour* behaviour);
 
 void level_free(Level* level);
 
-void level_update(Level* level, Director* director);
+void level_update(Level* level, GameManager* manager);
 
-void level_render(Level* level, Director* director, Canvas* canvas);
+void level_render(Level* level, GameManager* manager, Canvas* canvas);
 
 void level_call_alloc(Level* level);
 

level_manager.c

@@ -1,70 +0,0 @@
-#include "level_manager.h"
-#include "level_i.h"
-#include <furi.h>
-#include <m-list.h>
-
-LIST_DEF(LevelList, Level*, M_POD_OPLIST);
-
-struct LevelManager {
-    LevelList_t levels;
-    Level* current_level;
-    Level* next_level;
-};
-
-LevelManager* level_manager_alloc() {
-    LevelManager* lm = malloc(sizeof(LevelManager));
-    lm->current_level = NULL;
-    lm->next_level = NULL;
-    LevelList_init(lm->levels);
-    return lm;
-}
-
-void level_manager_free(LevelManager* lm) {
-    level_call_stop(lm->current_level);
-
-    LevelList_it_t it;
-    LevelList_it(it, lm->levels);
-    while(!LevelList_end_p(it)) {
-        level_call_free(*LevelList_cref(it));
-        level_free(*LevelList_cref(it));
-        LevelList_next(it);
-    }
-
-    LevelList_clear(lm->levels);
-    free(lm);
-}
-
-Level* level_manager_add_level(LevelManager* lm, const LevelBehaviour* behaviour) {
-    UNUSED(lm);
-    Level* level = level_alloc(behaviour);
-    LevelList_push_back(lm->levels, level);
-    level_call_alloc(level);
-    if(!lm->current_level) {
-        lm->current_level = level;
-        level_call_start(level);
-    }
-    return level;
-}
-
-void level_manager_next_level_set(LevelManager* lm, Level* next_level) {
-    lm->next_level = next_level;
-}
-
-Level* level_manager_current_level_get(LevelManager* lm) {
-    return lm->current_level;
-}
-
-void level_manager_update(LevelManager* lm, Director* director) {
-    if(lm->next_level) {
-        level_call_stop(lm->current_level);
-        lm->current_level = lm->next_level;
-        level_call_start(lm->current_level);
-        lm->next_level = NULL;
-    }
-
-    level_update(lm->current_level, director);
-}
-
-void level_manager_render(LevelManager* lm, Director* director, Canvas* canvas) {
-    level_render(lm->current_level, director, canvas);
-}

level_manager.h

@@ -1,18 +0,0 @@
-#pragma once
-#include "level.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef struct LevelManager LevelManager;
-
-Level* level_manager_add_level(LevelManager* manager, const LevelBehaviour* behaviour);
-
-void level_manager_next_level_set(LevelManager* manager, Level* level);
-
-Level* level_manager_current_level_get(LevelManager* manager);
-
-#ifdef __cplusplus
-}
-#endif

level_manager_i.h

@@ -1,18 +0,0 @@
-#pragma once
-#include "level_manager.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-LevelManager* level_manager_alloc(void);
-
-void level_manager_free(LevelManager* manager);
-
-void level_manager_update(LevelManager* level, Director* director);
-
-void level_manager_render(LevelManager* level, Director* director, Canvas* canvas);
-
-#ifdef __cplusplus
-}
-#endif

main.c

@@ -1,48 +1,42 @@
 #include <furi.h>
 #include "engine.h"
 #include "game_engine.h"
-#include "director_i.h"
-#include "level_manager_i.h"
+#include "game_manager_i.h"
 #include "level_i.h"
 #include "entity_i.h"
 
 static void frame_cb(RunningGameEngine* engine, Canvas* canvas, InputState input, void* context) {
-    Director* director = context;
-    director_input_set(director, input);
-    director_engine_set(director, engine);
-
-    LevelManager* level_manager = director_level_manager_get(director);
-    level_manager_update(level_manager, director);
-    level_manager_render(level_manager, director, canvas);
+    GameManager* game_manager = context;
+    game_manager_input_set(game_manager, input);
+    game_manager_engine_set(game_manager, engine);
+    game_manager_update(game_manager);
+    game_manager_render(game_manager, canvas);
 }
 
 int32_t game_app(void* p) {
     UNUSED(p);
 
-    Director* director = director_alloc();
-    LevelManager* level_manager = level_manager_alloc();
-    director_level_manager_set(director, level_manager);
+    GameManager* game_manager = game_manager_alloc();
 
     void* game_context = NULL;
     if(game.context_size > 0) {
         game_context = malloc(game.context_size);
-        director_game_context_set(director, game_context);
+        game_manager_game_context_set(game_manager, game_context);
     }
-    game.start(level_manager, NULL);
+    game.start(game_manager, NULL);
 
     GameEngineSettings settings = game_engine_settings_init();
     settings.fps = 60.0f;
     settings.show_fps = true;
     settings.always_backlight = true;
     settings.frame_callback = frame_cb;
-    settings.context = director;
+    settings.context = game_manager;
 
     GameEngine* engine = game_engine_alloc(settings);
     game_engine_run(engine);
     game_engine_free(engine);
 
-    level_manager_free(level_manager);
-    director_free(director);
+    game_manager_free(game_manager);
 
     game.stop(game_context);
     if(game_context) {