Added FLOP action

include/dawn/game/game.h

@@ -6,7 +6,10 @@
 #pragma once
 #include "../libs.h"
 #include "../engine/engine.h"
-#include "poker/pokergame.h"
+
+#if SETTING_GAME == SETTING_GAME_POKER
+  #include "poker/pokergame.h"
+#endif
 
 /** Describes the current game */
 typedef struct {
@@ -15,6 +18,7 @@ typedef struct {
   /** Engine for the game */
   engine_t engine;
 
-  /** Poker Game */
+  #if SETTING_GAME == SETTING_GAME_POKER
-  pokergame_t pokerGame;
+    pokergame_t pokerGame;
+  #endif
 } game_t;

include/dawn/settings.h

@@ -4,7 +4,10 @@
  * This software is released under the MIT License.
  * https://opensource.org/licenses/MIT
  */
-
 #pragma once
 
-#define SETTING_GAME "poker"
+// Game Definitions
+#define SETTING_GAME_POKER 1
+
+// Settings
+#define SETTING_GAME SETTING_GAME_POKER

src/game/game.c

@@ -12,21 +12,29 @@ bool gameInit(game_t *game) {
   engineInit(&game->engine, game);
 
   // Send off to the game instance
-  return pokerGameInit(game);
+  #if SETTING_GAME == SETTING_GAME_POKER
+    return pokerGameInit(game);
+  #endif
 }
 
 bool gameUpdate(game_t *game, float platformDelta) {
   // Let the engine do its thing.
   engineUpdateStart(&game->engine, game, platformDelta);
 
-  // Hand off to the poker logic
+  // Hand off to the game's logic
-  pokerGameUpdate(game);
+  #if SETTING_GAME == SETTING_GAME_POKER
+    pokerGameUpdate(game);
+  #endif
 
   // Hand back to the engine.
   return engineUpdateEnd(&game->engine, game);
 }
 
 void gameDispose(game_t *game) {
-  pokerGameDispose(game);
+  // Cleanup the game
+  #if SETTING_GAME == SETTING_GAME_POKER
+    pokerGameDispose(game);
+  #endif
+
   engineDispose(&game->engine, game);
 }

src/game/game.h

@@ -6,7 +6,10 @@
 #pragma once
 #include <dawn/dawn.h>
 #include "../engine/engine.h"
-#include "poker/pokergame.h"
+
+#if SETTING_GAME == SETTING_GAME_POKER
+  #include "poker/pokergame.h"
+#endif
 
 /**
  * Initialize the game context.

src/game/poker/pokergame.c

@@ -25,6 +25,9 @@ bool pokerGameInit(game_t *game) {
   pokerActionRoundAdd(&pokerGame->scene.conversation.actionQueue, &pokerGame->poker);
   vnConversationTalk(&pokerGame->scene.conversation, "Betting Round", NULL);
 
+  vnConversationTalk(&pokerGame->scene.conversation, "Flop Round", NULL);
+  pokerActionFlopAdd(&pokerGame->scene.conversation.actionQueue, &pokerGame->poker);
+
   // Begin the VN conversation queue.
   queueNext(&pokerGame->scene.conversation.actionQueue);
 

src/game/poker/pokergame.h

@@ -14,6 +14,7 @@
 
 #include "../../poker/actions/match.h"
 #include "../../poker/actions/round.h"
+#include "../../poker/actions/flop.h"
 
 /**
  * Initializes the game state for the poker game.

src/poker/actions/flop.c

@@ -0,0 +1,55 @@
+/**
+ * Copyright (c) 2021 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "flop.h"
+
+void _pokerActionFlopDo(queue_t *queue, queueaction_t *action, uint8_t count) {
+  poker_t *poker;
+  poker = (poker_t *)action->data;
+
+  pokerDealerBurn(&poker->dealer, 1);
+  pokerDealerTurn(&poker->dealer, count);
+
+  printf("Turned %u cards\n", count);
+  queueNext(queue);
+}
+
+void _pokerActionFlopOnStart(queue_t *queue, queueaction_t *action, uint8_t i) {
+  _pokerActionFlopDo(queue, action, POKER_FLOP_CARD_COUNT);
+}
+
+void _pokerActionTurnOnStart(queue_t *queue, queueaction_t *action, uint8_t i) {
+  _pokerActionFlopDo(queue, action, POKER_TURN_CARD_COUNT);
+}
+
+void _pokerActionRiverOnStart(queue_t *queue, queueaction_t *action, uint8_t i) {
+  _pokerActionFlopDo(queue, action, POKER_RIVER_CARD_COUNT);
+}
+
+queueaction_t * pokerActionFlopAdd(queue_t *queue, poker_t *poker) {
+  queueaction_t *action;
+  action = queueAdd(queue);
+  action->data = (void *)poker;
+  action->onStart = &_pokerActionFlopOnStart;
+  return action;
+}
+
+queueaction_t * pokerActionTurnAdd(queue_t *queue, poker_t *poker) {
+  queueaction_t *action;
+  action = queueAdd(queue);
+  action->data = (void *)poker;
+  action->onStart = &_pokerActionTurnOnStart;
+  return action;
+}
+
+queueaction_t * pokerActionRiverAdd(queue_t *queue, poker_t *poker) {
+  queueaction_t *action;
+  action = queueAdd(queue);
+  action->data = (void *)poker;
+  action->onStart = &_pokerActionRiverOnStart;
+  return action;
+}

src/poker/actions/flop.h

@@ -0,0 +1,53 @@
+/**
+ * Copyright (c) 2021 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include <dawn/dawn.h>
+#include "../../display/animation/queue.h"
+#include "../dealer.h"
+
+/**
+ * Shorthand action callback parser. Takes the queue, action and the intended
+ * turn count to complete the action.
+ * 
+ * @param queue Queue that fired the action.
+ * @param action Action that was fired.
+ * @param count Count of cards to turn over from the deck.
+ */
+void _pokerActionFlopDo(queue_t *queue, queueaction_t *action, uint8_t count);
+
+/** Callbacks for River, Turn and Flop Actions */
+void _pokerActionFlopOnStart(queue_t *queue, queueaction_t *action, uint8_t i);
+void _pokerActionTurnOnStart(queue_t *queue, queueaction_t *action, uint8_t i);
+void _pokerActionRiverOnStart(queue_t *queue, queueaction_t *action, uint8_t i);
+
+/**
+ * Queues a flop action onto the queue.
+ * 
+ * @param queue Queue to add to.
+ * @param poker Poker game instance to flop.
+ * @return The queued action.
+ */
+queueaction_t * pokerActionFlopAdd(queue_t *queue, poker_t *poker);
+
+/**
+ * Queues a turn action onto the queue.
+ * 
+ * @param queue Queue to add to.
+ * @param poker Poker game instance to turn.
+ * @return The queued action.
+ */
+queueaction_t * pokerActionTurnAdd(queue_t *queue, poker_t *poker);
+
+/**
+ * Queues a river action onto the queue.
+ * 
+ * @param queue Queue to add to.
+ * @param poker Poker game instance to river.
+ * @return The queued action.
+ */
+queueaction_t * pokerActionRiverAdd(queue_t *queue, poker_t *poker);