Cleaned some code, drastically reduced memory footprint.

src/game/poker/pokergame.c

@@ -7,80 +7,60 @@
 
 #include "pokergame.h"
 
-bool pokerGameInit(game_t *game) {
-  pokergame_t *pokerGame = &game->pokerGame;
-
+bool pokerGameInit(pokergame_t *game) {
   // Load the Assets.
-  pokerGameAssetsInit(&pokerGame->assets);
+  pokerGameAssetsInit(&game->assets);
 
   // Initialize the Visual Novel Engine.
-  vnSceneInit(&pokerGame->scene,
-    &pokerGame->assets.font,
-    &pokerGame->assets.testTexture
+  vnSceneInit(&game->scene,
+    &game->assets.font,
+    &game->assets.testTexture
   );
 
   // Initialize the world
-  pokerWorldInit(pokerGame);
+  pokerWorldInit(game);
 
   // Initialize the UI.
-  pokerUiInit(pokerGame);
+  pokerUiInit(game);
 
   // Add the first action, the game action, and then start the action queue.
-  pokerGameActionStartAdd(pokerGame);
-  queueNext(&pokerGame->scene.conversation.actionQueue);
-
-  // Testing
-  dynArrayInit(&dynarr, sizeof(int32_t), 100);
-  int32_t i, count;
-  count = 32;
-  for(i = 0; i < count; i++) {
-    dynArrayPush(&dynarr, &i);
-    printf("Count i is %i\n", *((int32_t *)dynArrayGet(&dynarr, i)) );
-  }
-
-  dynArraySploice(&dynarr, 0, 16);
-  printf("Count 0 is %i\n", *((int32_t *)dynArrayGet(&dynarr, 0)) );
-  printf("Count 8 is %i\n", *((int32_t *)dynArrayGet(&dynarr, 8)) );
+  pokerGameActionStartAdd(game);
+  queueNext(&game->scene.conversation.actionQueue);
 
   return true;
 } 
 
-void pokerGameUpdate(game_t *game) {
-  pokergame_t *pokerGame;
-  pokerGame = &game->pokerGame;
+void pokerGameUpdate(pokergame_t *game, engine_t *engine) {
 
   // Update the VN Engine.
-  vnSceneUpdate(&pokerGame->scene, &game->engine);
+  vnSceneUpdate(&game->scene, engine);
 
   // Bind the shader.
-  shaderUse(&pokerGame->assets.shader);
+  shaderUse(&game->assets.shader);
 
   // Render the visual novel scene.
-  vnSceneRenderWorld(&pokerGame->scene,&game->engine,&pokerGame->assets.shader);
+  vnSceneRenderWorld(&game->scene, engine, &game->assets.shader);
 
-  pokerWorldRender(&pokerGame->world, &game->engine, &pokerGame->assets);
-  vnSceneRenderCharacters(&pokerGame->scene, &pokerGame->assets.shader);
+  pokerWorldRender(&game->world, engine, &game->assets);
+  vnSceneRenderCharacters(&game->scene, &game->assets.shader);
 
   // Render the UI
-  vnSceneRenderGui(&pokerGame->scene, &game->engine, &pokerGame->assets.shader);
-  pokerUiRender(pokerGame, &game->engine);
+  vnSceneRenderGui(&game->scene, engine, &game->assets.shader);
+  pokerUiRender(game, engine);
 }
 
-void pokerGameDispose(game_t *game) {
-  pokergame_t *pokerGame;
-  pokerGame = &game->pokerGame;
-
+void pokerGameDispose(pokergame_t *game) {
   //Cleanup the UI
-  pokerUiDispose(pokerGame);
+  pokerUiDispose(game);
 
   // Cleanup the world
-  pokerWorldDispose(pokerGame);
+  pokerWorldDispose(game);
 
   // Destroy the Visual Novel engine.
-  vnSceneDispose(&pokerGame->scene);
+  vnSceneDispose(&game->scene);
 
   // Unload all assets
-  pokerGameAssetsDispose(&pokerGame->assets);
+  pokerGameAssetsDispose(&game->assets);
 }
 
 void pokerGameQueueRestack(pokergame_t *pokerGame) {

src/game/poker/pokergame.h

@@ -23,19 +23,20 @@
  * @param game Game to initialize.
  * @returns True if successful, otherwise false.
  */
-bool pokerGameInit(game_t *game);
+bool pokerGameInit(pokergame_t *game);
 
 /**
  * Updates the poker game instance.
- * @param game Game to update for.
+ * @param game Poker game to update for.
+ * @param engine Engine to use during update.
  */
-void pokerGameUpdate(game_t *game);
+void pokerGameUpdate(pokergame_t *game, engine_t *engine);
 
 /**
  * Disposes a previously initialized poker game instance.
- * @param game Game to initialize for.
+ * @param game Game to dispose.
  */
-void pokerGameDispose(game_t *game);
+void pokerGameDispose(pokergame_t *game);
 
 /**
  * Restacks the poker game's stack.