Added Full House

include/dawn/poker/card.h

@@ -76,10 +76,10 @@
 ////////////////////////////////////////////////////////////////////////////////
 // Suits
 ////////////////////////////////////////////////////////////////////////////////
-#define CARD_SUIT_CLUBS 0x0D
+#define CARD_SUIT_CLUBS 0x00
-#define CARD_SUIT_DIAMONDS 0x1A
+#define CARD_SUIT_DIAMONDS 0x01
-#define CARD_SUIT_HEARTS 0x27
+#define CARD_SUIT_HEARTS 0x02
-#define CARD_SUIT_SPADES 0x34
+#define CARD_SUIT_SPADES 0x03
 
 ////////////////////////////////////////////////////////////////////////////////
 // Card numbers
@@ -101,6 +101,9 @@
 /** Count of cards in each suit */
 #define CARD_COUNT_PER_SUIT 13
 
+/** Count of suits */
+#define CARD_SUIT_COUNT 4
+
 /** Standard Card Deck Size */
 #define CARD_DECK_SIZE 52
 

include/dawn/util/array.h

@@ -15,4 +15,4 @@
  * @param right The right element in the array.
  * @return -1 for Left priority, 1 for Right and 0 for Equal.
  */
-typedef int32_t *arraysort_t(void const*, void const*);
+typedef int32_t *arraysort_t(void*, void*);

src/game/game.h

@@ -11,12 +11,6 @@
 #include "../poker/card.h"
 #include "../util/array.h"
 
-#include "../display/camera.h"
-#include "../display/shader.h"
-#include "../display/gui/font.h"
-#include "../display/primitives/quad.h"
-#include "../display/primitives/cube.h"
-
 /**
  * Initialize the game context.
  * 

src/poker/card.c

@@ -27,7 +27,7 @@ void cardHandSort(card_t *cards, uint8_t length) {
   arraySort(sizeof(card_t), cards, (int32_t)length, (arraysort_t *)&_cardSorter);
 }
 
-int32_t _cardSorter(const void* left, const void* right) {
+int32_t _cardSorter(void* left, void* right) {
   card_t cardL = *((card_t *)left);
   card_t cardR = *((card_t *)right);
 
@@ -43,11 +43,7 @@ int32_t _cardSorter(const void* left, const void* right) {
 }
 
 int32_t cardContains(card_t *hand, uint8_t length, card_t card) {
-  int32_t i;
+  return arrayFind(sizeof(card_t), hand, (int32_t)length, &card);
-  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) {
@@ -56,4 +52,20 @@ int32_t cardContainsNumber(card_t *hand, uint8_t length, uint8_t number) {
     if(cardGetNumber(hand[i]) == number) return i;
   }
   return -1;
+}
+
+uint8_t cardCountPairs(
+  card_t *in, uint8_t inCount, uint8_t number, int32_t out[CARD_SUIT_COUNT]
+) {
+  uint8_t i, count;
+  int32_t index;
+  
+  count = 0;
+  for(i = 0; i <= CARD_SUIT_COUNT; i++) {// "For each suit"
+    index = cardContains(in, inCount, cardGet(number, i));
+    if(index == -1) continue;
+    out[count++] = index;
+  }
+  
+  return count;
 }

src/poker/card.h

@@ -26,7 +26,7 @@
  * 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.
+ * @returns The card for this suit and number combo.
  */
 #define cardGet(number, suit) ((suit * CARD_COUNT_PER_SUIT) + number)
 
@@ -50,7 +50,7 @@ void cardDeal(card_t *source, uint8_t *sourceSize, card_t *dest,
  * @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(void* left, void* right);
 
 /**
  * Check if an array of cards contains a specific card.
@@ -70,4 +70,17 @@ int32_t cardContains(card_t *hand, uint8_t length, card_t card);
  * @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);
+int32_t cardContainsNumber(card_t *hand, uint8_t length, uint8_t number);
+
+/**
+ * Counts the amount of times a card's number appears within the given hand.
+ * 
+ * @param in The hand to check
+ * @param inCount How big the hand being checked is
+ * @param number The number to look for.
+ * @param out The indexes within the hand array for each card matching.
+ * @return How many cards in the pair, e.g. 3 for Three of a kind, 4 for full. 
+ */
+uint8_t cardCountPairs(
+  card_t *in, uint8_t inCount, uint8_t number, int32_t out[4]
+);

src/poker/round/winner.c

@@ -30,7 +30,8 @@ winning_t pokerWinnerGetStatus(poker_t *poker, pokerplayer_t *player) {
   uint8_t i, j, l;
   int32_t index;
   card_t card;
-  uint8_t number, suit;
+  uint8_t number, suit, pairCount;
+  int32_t pairs[CARD_SUIT_COUNT];
 
   // Get the full poker hand (should be a 7 card hand)
   winning.size = poker->cardsFacing + player->cardCount;
@@ -43,12 +44,14 @@ winning_t pokerWinnerGetStatus(poker_t *poker, pokerplayer_t *player) {
 
   // TESTING HAND
   winning.full[0] = CARD_CLUBS_ACE;
-  winning.full[1] = CARD_CLUBS_TWO;
+  winning.full[1] = CARD_SPADES_ACE;
-  winning.full[2] = CARD_CLUBS_THREE;
+
-  winning.full[3] = CARD_SPADES_FOUR;
+  winning.full[2] = CARD_HEARTS_TWO;
-  winning.full[4] = CARD_CLUBS_FOUR;
+  winning.full[3] = CARD_DIAMONDS_TWO;
-  winning.full[5] = CARD_CLUBS_FIVE;
+  winning.full[4] = CARD_SPADES_TWO;
-  winning.full[6] = CARD_CLUBS_JACK;
+
+  winning.full[5] = CARD_HEARTS_QUEEN;
+  winning.full[6] = CARD_HEARTS_JACK;
   
   //////////////////////// Now look for the winning set ////////////////////////
 
@@ -74,7 +77,7 @@ winning_t pokerWinnerGetStatus(poker_t *poker, pokerplayer_t *player) {
     if(winning.count < POKER_WINNING_SET_SIZE) continue;
 
     // Add self to array
-    winning.set[0] = card;
+    winning.set[0] = i;
     winning.type = (
       number == CARD_ACE ? POKER_WINNING_TYPE_ROYAL_FLUSH : 
       POKER_WINNING_TYPE_STRAIGHT_FLUSH
@@ -87,8 +90,43 @@ winning_t pokerWinnerGetStatus(poker_t *poker, pokerplayer_t *player) {
     return winning;
   }
 
-  // High card (worst)
+  // Four of a kind.
+  winning.count = 0;
+  for(i = 0; i < winning.size; i++) {
+    card = winning.full[i];
+    number = cardGetNumber(card);
+    pairCount = cardCountPairs(winning.full, winning.size, number, pairs);
+    if(pairCount < CARD_SUIT_COUNT) continue;
 
+    winning.count = pairCount;
+    arrayCopy(sizeof(int32_t), pairs, pairCount, winning.set);
+    winning.type = POKER_WINNING_TYPE_FOUR_OF_A_KIND;
+    printf("Four of a kind\n");
+    return winning;
+  }
+
+  // Full House
+  winning.count = 0;
+  for(i = 0; i < winning.size; i++) {
+    index = i;// Check we haven't already added this card.
+    if(arrayContains(sizeof(int32_t),winning.set,winning.count,&index))continue;
+
+    card = winning.full[i];
+    number = cardGetNumber(card);
+    pairCount = cardCountPairs(winning.full, winning.size, number, pairs);
+
+    // Did we find either two pair or three pair?
+    if(pairCount != 2 && pairCount != 3) continue;
+    if(winning.count == 3) pairCount = 2;//Clamp to 5 max.
+    arrayCopy(sizeof(int32_t), pairs, pairCount, winning.set+winning.count);
+    winning.count += pairCount;
+    if(winning.count != POKER_WINNING_SET_SIZE) continue;
+    winning.type = POKER_WINNING_TYPE_FULL_HOUSE;
+    printf("Full House\n");
+    return winning;
+  }
+
+  // High card (worst)
   return winning;
 }
 

src/poker/round/winner.h

@@ -12,6 +12,8 @@
 
 #define POKER_WINNING_TYPE_ROYAL_FLUSH 0x01
 #define POKER_WINNING_TYPE_STRAIGHT_FLUSH 0x02
+#define POKER_WINNING_TYPE_FOUR_OF_A_KIND 0x03
+#define POKER_WINNING_TYPE_FULL_HOUSE 0x04
 
 #define POKER_WINNING_SET_SIZE 5
 

src/util/array.c

@@ -8,9 +8,7 @@
 #include "array.h"
 
 void * arrayGet(size_t size, void *array, int32_t index) {
-  // Cast to char array
+  return (char *)array + (index * (size/sizeof(char)));
-  char *cArray = (char *)array;
-  return cArray + (index * (size/sizeof(char)));
 }
 
 void arrayShuffle(size_t size, void *array, int32_t arrayLength) {
@@ -44,34 +42,38 @@ int32_t arrayFind(size_t size, void *array, int32_t length, void *value) {
   void *item;
 
   for(i = 0; i < length; i++) {
-    // Get the item
+    // Get the item and compare.
     item = arrayGet(size, array, i);
-
+    if(memcmp(item, value, size) == 0) return i;
-    // Compare the bits directly.
-    if(memcmp(item, &value, size) == 0) return i;
   }
 
   // No find.
   return -1;
 }
 
+bool arrayContains(size_t size, void *array, int32_t length, void *value) {
+  int32_t i = arrayFind(size, array, length, value);
+  return i != -1;
+}
+
+void arrayCopy(size_t size, void *source, int32_t length, void *dest) {
+  memcpy(dest, source, size * length);
+}
 
 void arraySort(size_t size, void *array, int32_t length, arraysort_t *sort) {
-  qsort(array, length, size, sort);
+  qsort(array, length, size, (_CoreCrtNonSecureSearchSortCompareFunction)sort);
 }
 
 void arraySortInt32(int32_t *array, int32_t length) {
   arraySort(sizeof(int32_t), array, length, &_arraySorterInt32);
 }
-
+int32_t _arraySorterInt32(void* left, void* right) {
-int32_t _arraySorterInt32(const void* left, const void* right) {
   return *((int32_t *)left) - *((int32_t *)right);
 }
 
 void arraySortUint8(uint8_t *array, int32_t length) {
   arraySort(sizeof(uint8_t), array, length, &_arraySorterUint8);
 }
-
+int32_t _arraySorterUint8(void* left, void* right) {
-int32_t _arraySorterUint8(const void* left, const void* right) {
   return *((uint8_t *)left) - *((uint8_t *)right);
 }

src/util/array.h

@@ -28,16 +28,39 @@ void * arrayGet(size_t size, void *array, int32_t index);
 void arrayShuffle(size_t size, void *array, int32_t arrayLength);
 
 /**
- * Find the index within the array that matches the given value.
+ * Find the index within the array that matches the given pointer.
  * 
  * @param size Size of each element within the array.
  * @param array Array to get from.
  * @param length Max length to check to.
- * @param value Value to look for. This is a literal compare of value == value.
+ * @param value Pointer to the value to look for. This is memory compared.
  * @returns The index within the array that matches, or -1 if no match.
  */
 int32_t arrayFind(size_t size, void *array, int32_t length, void *value);
 
+/**
+ * Compares each item in an array with the specified value, and returns true if 
+ * found within the array. This is a shorthand for arrayFind without an int32_t 
+ * being returned.
+ * 
+ * @param size Size of each element within the array.
+ * @param array Array to get from.
+ * @param length Max length to check to.
+ * @param value Pointer to the value to look for. This is memory compared.
+ * @returns True if the array contains the value, otherwise false.
+ */
+bool arrayContains(size_t size, void *array, int32_t length, void *value);
+
+/**
+ * Copies the raw contents from the source array to the destination array.
+ * 
+ * @param size Size of each element within the array.
+ * @param source Source array.
+ * @param length Length of the source array.
+ * @param dest Destination array.
+ */
+void arrayCopy(size_t size, void *source, int32_t length, void *dest);
+
 /**
  * Sort an array based on the result of an array sort callback.
  * 
@@ -56,7 +79,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(const void *left, const void* right);
+int32_t _arraySorterInt32(void *left, void* right);
 
 /**
  * Sort a uint8_t array.
@@ -66,4 +89,4 @@ int32_t _arraySorterInt32(const void *left, const void* right);
  */
 void arraySortUint8(uint8_t *array, int32_t length);
 /** Internal uint8_t array sorter. */
-int32_t _arraySorterUint8(const void* left, const void* right);
+int32_t _arraySorterUint8(void* left, void* right);