Fixed betting bugs.

src/game/poker/actions/bet.c

@@ -86,11 +86,8 @@ void _pokerGameActionBetOnUpdate(
 void _pokerGameActionBetOnEnd(
   queue_t *queue, queueaction_t *action, uint8_t i
 ) {
-  queueaction_t *next;
-  pokerdiscussiondata_t discussion;
   pokergame_t *game = (pokergame_t *)action->data;
 
-
   // Get which player is remaining to move.
   game->poker.bet.better = pokerBetGetRemainingPlayer(
     &game->poker.bet, game->poker.players, game->poker.roundSmallBlind
@@ -101,47 +98,14 @@ void _pokerGameActionBetOnEnd(
 
   // Are we waiting on any players?
   if(game->poker.bet.better != 0xFF) {
-    if(game->poker.bet.better == POKER_PLAYER_HUMAN_INDEX) {
+    pokerGameActionLookAdd(game, game->poker.bet.better);
-      pokerGameActionLookAdd(game, POKER_DEALER_INDEX);
-    } else {
-      pokerGameActionLookAdd(game, game->poker.bet.better);
-    }
     pokerGameActionBetAdd(game);
     return;
   }
 
-  // Prep convo
+  // Not waiting, do next action.
-  discussion.poker = game;
-
-  // Not waiting, restack and do next action.
   printf("Not waiting on anything!\n");
-
+  pokerGameActionFlopAdd(game);
-  // Is there a next round, or did someone just win?
-  if(pokerBetGetRemainingPlayerCount(&game->poker.bet,game->poker.players) > 1){
-    // No! Begin the next flop.
-    next = pokerActionNextFlopAdd(queue, &game->poker);
-    if(next != NULL) {
-      discussion.reason = POKER_DISCUSSION_REASON_FLOP;
-      pokerDiscussionQueue(&discussion);
-
-      pokerBetResetBetter(
-        &game->poker.bet, game->poker.players, game->poker.roundSmallBlind
-      );
-      pokerGameActionRestackAdd(game);
-      pokerGameActionLookAdd(game, game->poker.bet.better);
-      pokerGameActionBetAdd(game);
-      return;
-    }
-  }
-
-  
-  // Done betting
-  printf("All betting is done, reveal\n");
-  discussion.reason = POKER_DISCUSSION_REASON_BETTING_DONE;
-  discussion.poker = game;
-  pokerDiscussionQueue(&discussion);
-  pokerGameActionRestackAdd(game);
-  pokerGameActionWinnerAdd(game);
 }
 
 queueaction_t * pokerGameActionBetAdd(pokergame_t *game) {

src/game/poker/actions/bet.h

@@ -14,6 +14,7 @@
 #include "action.h"
 #include "restack.h"
 #include "winner.h"
+#include "flop.h"
 
 /** Callback when the bet action is updated. */
 void _pokerGameActionBetOnUpdate(

src/game/poker/actions/flop.h

@@ -0,0 +1,25 @@
+/**
+ * Copyright (c) 2021 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "../../../libs.h"
+#include "../../../poker/actions/flop.h"
+#include "../../../poker/turn.h"
+#include "../../../poker/bet.h"
+#include "../pokerdiscussion.h"
+#include "action.h"
+#include "restack.h"
+#include "winner.h"
+#include "bet.h"
+
+/**
+ * Queues a flop action on to the queue.
+ * 
+ * @param game Game to queue on to.
+ * @return queueaction_t* 
+ */
+queueaction_t * pokerGameActionFlopAdd(pokergame_t *game);

src/game/poker/actions/winner.c

@@ -10,7 +10,10 @@
 void _pokerGameActionWinnerOnStart(
   queue_t *queue, queueaction_t *action, uint8_t i
 ) {
+  pokerdiscussiondata_t discussion;
   pokergame_t *game = (pokergame_t *)action->data;
+
+  // Calculate the winners
   printf("Winner start action");
   pokerWinnerCalculate(
     &game->poker.winner,
@@ -18,12 +21,22 @@ void _pokerGameActionWinnerOnStart(
     game->poker.players
   );
 
+  // Action
+  pokerGameWin(&game->poker);
+
+  // Debug printing.
   printf("Winner Count %u\n", game->poker.winner.winnerCount);
   for(uint8_t i = 0; i < game->poker.winner.winnerCount; i++) {
     uint8_t winner = game->poker.winner.winners[i];
     printf("Winner %u\n", winner);
   }
 
+  // Say stuff
+  discussion.reason = POKER_DISCUSSION_REASON_BETTING_DONE;
+  discussion.poker = game;
+  pokerDiscussionQueue(&discussion);
+  
+  // Begin next round.
   pokerGameActionRoundAdd(game);
   queueNext(queue);
 }

src/game/poker/actions/winner.h

@@ -8,6 +8,7 @@
 #pragma once
 #include "../../../libs.h"
 #include "../../../poker/winner.h"
+#include "../../../poker/poker.h"
 #include "../pokerdiscussion.h"
 #include "action.h"
 #include "round.h"

src/game/poker/pokerdiscussion.c

@@ -106,8 +106,10 @@ void pokerDiscussionQueue(pokerdiscussiondata_t *data) {
   pokerdiscussion_t discussion;
   uint8_t i, player;
 
+  // Fetch the discussion item for the given data.
   pokerDiscussionGet(&discussion, data);
 
+  // Now for each discussion item, queue a task.
   for(i = 0; i < discussion.count; i++) {
     player = discussion.players[i];
     

src/game/poker/pokergameaction.h

@@ -8,6 +8,7 @@
 #pragma once
 #include "../../libs.h"
 
+/** Representation of data that poker game actions can have access to. */
 typedef struct {
   uint8_t lookAtPlayer;
 } pokergameactiondata_t;

src/poker/actions/blinds.c

@@ -10,9 +10,7 @@
 void _pokerActionBlindsOnStart(queue_t *queue,queueaction_t *action,uint8_t i) {
   poker_t *poker;
   poker = (poker_t *)action->data;
-
   poker->state = POKER_STATE_TAKING_BLINDS;
-
   pokerBetTakeBlinds(
     &poker->bet,
     poker->players, 

src/poker/actions/deal.c

@@ -11,9 +11,9 @@ void _pokerActionDealOnStart(queue_t *queue, queueaction_t *action, uint8_t i) {
   poker_t *poker;
   poker = (poker_t *)action->data;
 
-  poker->state = POKER_STATE_DEALING;
 
   // Shuffle the deck
+  poker->state = POKER_STATE_DEALING;
   cardShuffle(poker->dealer.deck, CARD_DECK_SIZE);
 
   // Deal 2 card to each player

src/poker/actions/round.c

@@ -30,13 +30,14 @@ void _pokerActionRoundOnStart(queue_t *queue, queueaction_t *action ,uint8_t i){
   // Decide on the dealer
   poker->roundDealer = (poker->roundDealer+1) % POKER_PLAYER_COUNT;
 
-  // Find the players.
+  // Find (and kill) the players.
   j = poker->roundDealer;
   foundDealer = false;
   foundSmallBlind = false;
   while(true) {
     player = poker->players + j;
-    if(!pokerPlayerIsAlive(player)) continue;
+
+    if(!pokerPlayerIsInRound(player)) continue;
     if(!foundDealer) {
       indexDealer = j;
       foundDealer = true;

src/poker/bet.c

@@ -42,10 +42,17 @@ void pokerBetResetBetter(
 }
 
 bool pokerBetPlayerCanBet(pokerbet_t *bet, pokerplayer_t *player) {
-  if(!pokerPlayerIsAlive(player)) return false;
+  // Is the player out?
+  if(!pokerPlayerIsInRound(player)) return false;
+
+  // Is the player broke?
+  if(player->chips <= 0) return false;
+
+  // Does the player still need to act yet?
   if(player->state & POKER_PLAYER_STATE_ROUND_MOVE) {
-    if(player->currentBet >= bet->currentBet && player) return false;
+    if(player->currentBet >= bet->currentBet) return false;
   }
+
   return true;
 }
 
@@ -66,7 +73,7 @@ uint8_t pokerBetGetRemainingPlayerCount(pokerbet_t *bet,pokerplayer_t *players){
   uint8_t i, c;
   c = 0;
   for(i = 0; i < POKER_PLAYER_COUNT; i++) {
-    if(!pokerPlayerIsAlive(players + i)) continue;
+    if(!pokerBetPlayerCanBet(bet, players + i)) continue;
     c++;
   }
   return c;

src/poker/bet.h

@@ -7,6 +7,7 @@
 #include "../libs.h"
 #include "player.h"
 #include "../util/math.h"
+#include "../util/array.h"
 
 /** How many chips each player has by defautl */
 #define POKER_BET_PLAYER_CHIPS_DEFAULT 10000
@@ -41,7 +42,7 @@ void pokerBetInit(pokerbet_t *bet);
 /**
  * Resets the bet state (for a new round).
  * 
- * @param bet 
+ * @param bet Betting stating.
  */
 void pokerBetReset(pokerbet_t *bet);
 
@@ -97,8 +98,7 @@ uint8_t pokerBetGetRemainingPlayer(
 );
 
 /**
- * Returns the count of players who are still available to bet. This does not
+ * Returns the count of players who are still needing to bet.
- * consider any round logic, simply whether or not they COULD bet.
  * 
  * @param bet Betting instance
  * @param players Players array.

src/poker/dealer.c

@@ -48,7 +48,7 @@ void pokerDealerDealAll(
   for(y = 0; y < count; y++) {
     for(x = 0; x < POKER_PLAYER_COUNT; x++) {
       player = players + x;
-      if(!pokerPlayerIsAlive(player)) continue;
+      if(!pokerPlayerIsInRound(player)) continue;
       pokerDealerDeal(dealer, player);
     }
   }

src/poker/player.c

@@ -7,8 +7,19 @@
 
 #include "player.h"
 
-bool pokerPlayerIsAlive(pokerplayer_t *player) {
+bool pokerPlayerIsInRound(pokerplayer_t *player) {
-  return !(player->state & (POKER_PLAYER_STATE_FOLDED|POKER_PLAYER_STATE_OUT));
+  return !(
+    player->state & (POKER_PLAYER_STATE_FOLDED|POKER_PLAYER_STATE_OUT)
+  );
+}
+
+uint8_t pokerPlayerGetCountInRound(pokerplayer_t *players) {
+  return (uint8_t)arraySum(
+    sizeof(pokerplayer_t),
+    players,
+    POKER_PLAYER_COUNT,
+    (arraysumcallback_t *)(&pokerPlayerIsInRound)
+  );
 }
 
 void pokerPlayerReset(pokerplayer_t *player) {

src/poker/player.h

@@ -8,6 +8,7 @@
 #pragma once
 #include "../libs.h"
 #include "../util/flags.h"
+#include "../util/array.h"
 #include "card.h"
 
 /** How many cards a player can hold in their hand */
@@ -59,13 +60,24 @@ typedef struct {
 } pokerplayer_t;
 
 /**
- * Returns true if the player is still alive and in the current game/
+ * Returns whether or not the player is in the current round. This does not 
- * Defined as: Not out, not folded.
+ * consider anything about whether they can/have bet or not, simply whether or
+ * not they can even partake in the round.
  * 
- * @param player Player to check
+ * @param player 
- * @returns True if alive/in teh current game.
+ * @return true 
+ * @return false 
  */
-bool pokerPlayerIsAlive(pokerplayer_t *player);
+bool pokerPlayerIsInRound(pokerplayer_t *player);
+
+/**
+ * Returns the count of players who remain in the current round. This is a sum
+ * of pokerPlayerIsInRound.
+ * 
+ * @param players 
+ * @return uint8_t 
+ */
+uint8_t pokerPlayerGetCountInRound(pokerplayer_t *players);
 
 /**
  * Resets a poker player's state (for a new round).

src/poker/poker.c

@@ -6,3 +6,32 @@
  */
 
 #include "poker.h"
+
+void pokerGameWin(poker_t *poker) {
+  uint8_t i;
+  pokerplayerwinning_t *winning;
+  pokerplayer_t *player;
+  int32_t chipsRounded, chipsDifferent;
+  float chipsEach;
+
+  // Get the chips each.
+  chipsEach = poker->bet.pot / ((float)poker->winner.winnerCount);
+
+  // Now work out the rounded offset chips.
+  chipsRounded = (int32_t)mathFloor(chipsEach);
+  chipsDifferent = poker->bet.pot - chipsRounded;
+
+  // Let's start by rewarding the winnings to the players.
+  for(i = 0; i < poker->winner.winnerCount; i++) {
+    player = poker->players + poker->winner.winners[i];
+    winning = poker->winner.winnings + i;
+    player->chips += chipsRounded;
+    if(i == 0) player->chips += chipsDifferent;
+  }
+
+  // Now kill the players who are terrible low life gamblers.
+  for(i = 0; i < POKER_PLAYER_COUNT; i++) {
+    player = poker->players + i;
+    if(player->chips <= 0) player->state &= POKER_PLAYER_STATE_OUT;
+  }
+}

src/poker/poker.h

@@ -50,4 +50,6 @@ typedef struct {
   uint8_t roundBigBlind;
 
   uint8_t state;
-} poker_t;
+} poker_t;
+
+void pokerGameWin(poker_t *poker);

src/poker/winner.c

@@ -336,7 +336,7 @@ void pokerWinnerCalculate(
     left = winner->winnings + i;
     left->type = POKER_WINNING_TYPE_NULL;
     player = players + i;
-    if(!pokerPlayerIsAlive(player)) continue;
+    if(!pokerPlayerIsInRound(player)) continue;
 
     // Get the players' winning state.
     pokerWinnerPlayerGet(dealer, player, left);

src/util/array.c

@@ -123,4 +123,17 @@ void arraySplice(
   // Now copy it back into the original array
   arrayCopy(size, temporary, takeLength, arrayGet(size, array, start));
   free(temporary);
+}
+
+
+int32_t arraySum(
+  size_t size, void *array, int32_t length, arraysumcallback_t *callback
+) {
+  int32_t i, count;
+  count = 0;
+  for(i = 0; i < length; i++) {
+    if(!callback(arrayGet(size, array, i))) continue;
+    count++;
+  }
+  return count;
 }

src/util/array.h

@@ -18,6 +18,13 @@
  */
 typedef int32_t arraysort_t(const void*, const void*);
 
+/**
+ * Callback used when calculating the sum of an array that match a state.
+ * @param item Item within the array.
+ * @return True if counted, otherwise false.
+ */
+typedef bool arraysumcallback_t(void*);
+
 /**
  * Retreive the pointer to an elment within the array of unknown type.
  * 
@@ -149,4 +156,18 @@ void arrayRewind(size_t size, void *source, int32_t length, int32_t start,
  */
 void arraySplice(
   size_t size, void *array, int32_t start, int32_t count, int32_t length
+);
+
+/**
+ * Sums the count of items that match a given filter in an array. The filter
+ * is a callback method that the user can define.
+ * 
+ * @param size Size of each element within the array.
+ * @param array Array itself.
+ * @param length Length of the array.
+ * @param callback Callback that will return true/false when called.
+ * @return The count of items that matched the callback invokation.
+ */
+int32_t arraySum(
+  size_t size, void *array, int32_t length, arraysumcallback_t *callback
 );

src/util/math.h

@@ -73,4 +73,11 @@
  * @param n Number to sign.
  * @returns The signed number.
  */
-#define mathSign(n) (n>=0 ? 1.0f : -1.0f)
+#define mathSign(n) (n>=0 ? 1.0f : -1.0f)
+
+/**
+ * Round a number down to the nearest whole number.
+ * @param n Floating number to round down.
+ * @returns The floor of the input.
+ */
+#define mathFloor(n) (floorf(n))

src/vn/vnscene.c

@@ -135,7 +135,6 @@ void vnSceneLookAt(vnscene_t *scene,
 
 void vnSceneLookAtCharacter(vnscene_t *scene, uint8_t c, float distance) {
   vncharacter_t *character = scene->characters + c;
-
   vnSceneLookAt(scene,
     -distance * sinf(character->yaw) + character->x,
     scene->cameraLook.y,