Added Royal Flush checker.

src/game/game.c

@@ -13,16 +13,6 @@ bool gameInit(game_t *game) {
 
   // Init the engine and the rendering pipeline
   engineInit(&game->engine, game);
-
-  // Shufflemuh
-  card_t hand[CARD_DECK_SIZE];
-  for(uint8_t i = 0; i < CARD_DECK_SIZE; i++) {
-    hand[i] = i;
-  }
-  arrayShuffle(sizeof(card_t), hand, CARD_DECK_SIZE);
-
-  cardHandSort(hand, CARD_DECK_SIZE);
-  printf("Bruh moment\n");
   
   // Hand off to the poker logic.
   pokerInit(&game->poker, &game->engine);

src/poker/card.c

@@ -24,8 +24,7 @@ void cardDeal(card_t *source, uint8_t *sourceSize, card_t *dest,
 }
 
 void cardHandSort(card_t *cards, uint8_t length) {
-  // arraySortUint8(cards, length);
+  arraySort(sizeof(card_t), cards, (int32_t)length, (arraysort_t *)&_cardSorter);
-  arraySort(sizeof(card_t), cards, (int32_t)length, &_cardSorter);
 }
 
 int32_t _cardSorter(const void* left, const void* right) {
@@ -48,4 +47,20 @@ int32_t _cardSorter(const void* left, const void* right) {
 
   // Get the suit and the value of the card (reversed)
   return numberR - numberL;
+}
+
+int32_t cardContains(card_t *hand, uint8_t length, card_t card) {
+  int32_t i;
+  for(i = 0; i < length; i++) {
+    if(hand[i] == card) return i;
+  }
+  return -1;
+}
+
+int32_t cardContainsNumber(card_t *hand, uint8_t length, uint8_t number) {
+  int32_t i;
+  for(i = 0; i < length; i++) {
+    if(cardGetNumber(hand[i]) == number) return i;
+  }
+  return -1;
 }

src/poker/card.h

@@ -22,6 +22,14 @@
  */
 #define cardGetNumber(card) (card % CARD_COUNT_PER_SUIT)
 
+/**
+ * Returns the card number for a given suit.
+ * @param number The number to get.
+ * @param suit The suit to get.
+ * @returns The card number for.
+ */
+#define cardGet(number, suit) ((suit * CARD_COUNT_PER_SUIT) + number)
+
 /**
  * Deals a card from an array source to an array destination. Pointers to array
  * lengths will be updated.
@@ -36,11 +44,30 @@ void cardDeal(card_t *source, uint8_t *sourceSize, card_t *dest,
 );
 
 /**
- * Sort a hand of cards.
+ * Sort a hand of cards. Cards are ordered in descending weight, aces are high.
  * 
  * @param cards Hand of cards to sort.
  * @param length Length of the array of cards.
  */
 void cardHandSort(card_t *cards, uint8_t length);
+int32_t _cardSorter(const void* left, const void* right);
 
-int32_t _cardSorter(const void* left, const void* right);
+/**
+ * Check if an array of cards contains a specific card.
+ * 
+ * @param hand Hand/Array of cards to check.
+ * @param length Length of the array of cards.
+ * @param card Card to look for
+ * @returns The index within the array that the card is. -1 if not found.
+ */
+int32_t cardContains(card_t *hand, uint8_t length, card_t card);
+
+/**
+ * Check if the array of cards contains a specific number.
+ * 
+ * @param hand Array of cards to check
+ * @param length Length of the array.
+ * @param number The number to look for.
+ * @returns The index within the array that the first card is. -1 if not found.
+ */
+int32_t cardContainsNumber(card_t *hand, uint8_t length, uint8_t number);

src/poker/round/bet.c

@@ -36,6 +36,7 @@ void pokerBetPlayerInit(poker_t *poker, pokerplayer_t *player) {
   
   printf("Betting round player %u\n", poker->roundBetCurrent);
   if(pokerPlayerIsHuman(poker, player)) {
+    pokerBetPlayerNext(poker);
     return;
   }
 

src/poker/round/winner.c

@@ -11,15 +11,78 @@
 void pokerWinnerGetFullHand(poker_t *poker,pokerplayer_t *player,card_t *cards){
   uint8_t i;
 
+  // Add the dealer hand
   for(i = 0; i < poker->cardsFacing; i++) {
     cards[i] = poker->cards[i];
   }
 
+  // Add the player hand
   for(i = 0; i < player->cardCount; i++) {
     cards[i+poker->cardsFacing] = player->cards[i];
   }
 }
 
+winning_t pokerWinnerGetStatus(poker_t *poker, pokerplayer_t *player) {
+  winning_t winning;
+  uint8_t i, j;
+  int32_t index;
+  card_t card;
+  uint8_t number, suit;
+
+  // Get the full poker hand (should be a 7 card hand)
+  winning.size = poker->cardsFacing + player->cardCount;
+  pokerWinnerGetFullHand(poker, player, winning.full);
+
+  // Reset the winning status.
+  winning.count = 0;
+  winning.type = 0x00;
+  for(i = 0; i < POKER_WINNING_SET_SIZE; i++) winning.set[i] = -1;
+
+  // TESTING HAND
+  winning.full[0] = CARD_CLUBS_ACE;
+  winning.full[1] = CARD_CLUBS_QUEEN;
+  winning.full[2] = CARD_CLUBS_TEN;
+  winning.full[3] = CARD_SPADES_FOUR;
+  winning.full[4] = CARD_CLUBS_KING;
+  winning.full[5] = CARD_DIAMONDS_NINE;
+  winning.full[6] = CARD_CLUBS_JACK;
+  
+  //////////////////////// Now look for the winning set ////////////////////////
+
+  // Ace High Royal flush.
+  for(i = 0; i < winning.count; i++) {
+    // Look for Ace
+    card = winning.full[i];
+    number = cardGetNumber(card);
+    if(number != CARD_ACE) continue;
+    suit = cardGetSuit(card);
+
+    // Now look for the matching cards (Reverse order to order from A to 10)
+    for(j = 0; j < 4; j++) {
+      index = cardContains(winning.full,winning.size,cardGet(CARD_KING-j,suit));
+      if(index == -1) {
+        winning.count = 0;
+        break;
+      }
+      winning.set[j+1] = index;
+      winning.count++;
+    }
+
+    // Check if has all necessary cards. Adds the Ace to the array.
+    if(winning.count > 0) {
+      winning.set[0] = card;
+      winning.count++;
+      winning.type = POKER_WINNING_TYPE_ROYAL_FLUSH;
+      printf("Royal Flush\n");
+      return winning;
+    }
+  }
+
+  // High card (worst)
+
+  return winning;
+}
+
 void pokerWinnerInit(poker_t *poker) {
   uint8_t winners[POKER_PLAYER_COUNT];
   uint8_t winnerCount = 0;
@@ -31,7 +94,8 @@ void pokerWinnerInit(poker_t *poker) {
   for(uint8_t i = 0; i < POKER_PLAYER_COUNT; i++) {
     pokerplayer_t *player = poker->players + i;
     if(!pokerPlayerIsAlive(player)) continue;
-    
+
-    // Create a fll ahnd
+    // Get the players' full hand
+    pokerWinnerGetStatus(poker, player);
   }
 }

src/poker/round/winner.h

@@ -10,5 +10,22 @@
 #include "../player.h"
 #include "../card.h"
 
+#define POKER_WINNING_TYPE_ROYAL_FLUSH 0x01
+#define POKER_WINNING_TYPE_HIGH_CARD 0x00
+
+#define POKER_WINNING_SET_SIZE 5
+
+typedef struct {
+  card_t full[POKER_PLAYER_HAND + POKER_DEALER_HAND];
+  uint8_t size;
+
+  uint8_t count;
+  int32_t set[POKER_WINNING_SET_SIZE];
+
+  uint8_t type;
+} winning_t;
+
+
 void pokerWinnerGetFullHand(poker_t *poker,pokerplayer_t *player,card_t *cards);
+winning_t pokerWinnerGetStatus(poker_t *poker, pokerplayer_t *player);
 void pokerWinnerInit(poker_t *poker);

src/util/array.h

@@ -56,7 +56,7 @@ void arraySort(size_t size, void *array, int32_t length, arraysort_t *sort);
  */
 void arraySortInt32(int32_t *array, int32_t length);
 /** Internal int32_t array sorter. */
-int32_t _arraySorterInt32(void *left, void*right);
+int32_t _arraySorterInt32(const void *left, const void* right);
 
 /**
  * Sort a uint8_t array.