Cleaning poker code pt 1.

src/dawn/util/CMakeLists.txt

@@ -6,4 +6,5 @@
 target_sources(${DAWN_TARGET_NAME}
   PRIVATE
     String.cpp
+    Random.cpp
 )

src/dawn/util/Random.cpp

@@ -0,0 +1,16 @@
+// Copyright (c) 2024 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "Random.hpp"
+
+using namespace Dawn;
+
+void Random::seed(const uint64_t seed) {
+  srand(seed);
+}
+
+uint64_t Random::next() {
+  return rand();
+}

src/dawn/util/Random.hpp

@@ -0,0 +1,49 @@
+// Copyright (c) 2024 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "dawnlibs.hpp"
+
+namespace Dawn {
+  class Random final {
+    public:
+      /**
+       * Seeds the random number generator with the provided seed.
+       * 
+       * @param seed Seed to use for the random number generator.
+       */
+      static void seed(const uint64_t seed);
+
+      /**
+       * Returns the next random number from the generator.
+       * 
+       * @return The next random number.
+       */
+      static uint64_t next();
+
+      /**
+       * Returns a random number between the provided min and max values.
+       * 
+       * @param min Minimum value for the random number.
+       * @param max Maximum value for the random number.
+       * @return Random number between min and max.
+       */
+      static float_t random(float_t min, float_t max) {
+        return min + (float_t)next() / (float_t)RAND_MAX * (max - min);
+      }
+
+      /**
+       * Returns a random number between the provided min and max values.
+       * 
+       * @param min Minimum value for the random number.
+       * @param max Maximum value for the random number.
+       * @return Random number between min and max.
+       */
+      template<typename T>
+      static T random(T min, T max) {
+        return (T)(min + (next() % (max - min + 1)));
+      }
+  };
+}

src/dawnpoker/CMakeLists.txt

@@ -16,6 +16,7 @@ target_sources(${DAWN_TARGET_NAME}
 )
 
 # Subdirs
+add_subdirectory(poker)
 add_subdirectory(scenes)
 
 # Assets

src/dawnpoker/poker/Card.cpp

@@ -4,57 +4,75 @@
 // https://opensource.org/licenses/MIT
 
 #include "Card.hpp"
+#include "util/Random.hpp"
 
 using namespace Dawn;
 
-void Card::fillDeck(std::vector<struct Card> *deck) {
+void Card::shuffle(std::vector<struct Card> &deck) {
-  assertNotNull(deck);
+  for(uint8_t i = 0; i < deck.size(); i++) {
-  
+    uint8_t swap = Random::random<uint8_t>(0, deck.size() - 1);
-  for(uint8_t i = 0; i < CARD_DECK_SIZE; i++) {
+    struct Card tmp = deck[i];
-    deck->push_back(Card(i));
+    deck[i] = deck[swap];
+    deck[swap] = tmp;
   }
 }
 
-int32_t Card::contains(std::vector<struct Card> *deck, struct Card c) {
+void Card::fillDeck(std::vector<struct Card> &deck) {
-  assertNotNull(deck);
+  deck.clear();
-
+  for(uint8_t i = 0; i < CARD_DECK_SIZE; i++) {
-  auto it = deck->begin();
+    deck.push_back(Card(i));
-  while(it != deck->end()) {
-    if(it->cardValue == c.cardValue) return (int32_t)(it - deck->begin());
-    ++it;
   }
-  return -1;
+}
+
+int32_t Card::contains(
+  const std::vector<struct Card> &deck,
+  const struct Card c
+) {
+  if(deck.size() == 0) return -1;
+
+  return std::distance(
+    deck.begin(),
+    std::find_if(
+      deck.begin(),
+      deck.end(),
+      [c](struct Card card) {
+        return card.cardValue == c.cardValue;
+      }
+    )
+  );
 }
 
 int32_t Card::containsNumber(
-  std::vector<struct Card> *deck,
+  const std::vector<struct Card> &deck,
-  enum CardValue number
+  const enum CardValue number
 ) {
-  assertNotNull(deck);
+  if(deck.size() == 0) return -1;
-  assertTrue(number < CARD_COUNT_PER_SUIT);
 
-  auto it = deck->begin();
+  return std::distance(
-  while(it != deck->end()) {
+    deck.begin(),
-    if(it->getValue() == number) return (int32_t)(it - deck->begin());
+    std::find_if(
-    ++it;
+      deck.begin(),
-  }
+      deck.end(),
-  return -1;
+      [number](struct Card c) {
+        return c.getValue() == number;
+      }
+    )
+  );
 }
 
 std::vector<struct Card> Card::countPairs(
-  std::vector<struct Card> *deck,
+  const std::vector<struct Card> &deck,
-  enum CardValue val
+  const enum CardValue val
 ) {
   std::vector<struct Card> pairs;
-
-  assertNotNull(deck);
-  assertTrue(deck->size() > 0);
   
-  auto it = deck->begin();
+  std::for_each(
-  while(it != deck->end()) {
+    deck.begin(),
-    if(it->getValue() == val) pairs.push_back(*it);
+    deck.end(),
-    ++it;
+    [&pairs, val](struct Card c) {
-  }
+      if(c.getValue() == val) pairs.push_back(c);
+    }
+  );
 
   return pairs;
 }
@@ -63,8 +81,14 @@ bool_t Card::cardSorter(struct Card left, struct Card right) {
   return left.cardValue < right.cardValue;
 }
 
-void Card::sort(std::vector<struct Card> *deck) {
+void Card::sort(std::vector<struct Card> &deck) {
-  assertNotNull(deck);
+  std::sort(deck.begin(), deck.end(), &Card::cardSorter);
-  assertTrue(deck->size() > 1);
-  std::sort(deck->begin(), deck->end(), &Card::cardSorter);
 }
+
+enum CardValue Card::getValue() {
+  return (enum CardValue)(cardValue % CARD_COUNT_PER_SUIT);
+}
+
+enum CardSuit Card::getSuit() {
+  return (enum CardSuit)(cardValue / CARD_COUNT_PER_SUIT);
+}

src/dawnpoker/poker/Card.hpp

@@ -13,7 +13,6 @@ namespace Dawn {
     Diamonds = 1,
     Hearts = 2,
     Spades = 3,
-    Invalid = 0xFF
   };
 
   enum class CardValue : uint8_t {
@@ -30,7 +29,6 @@ namespace Dawn {
     Queen = 10,
     King = 11,
     Ace = 12,
-    Invalid = 0xFF
   };
 
   /** Count of cards in each suit */
@@ -51,14 +49,14 @@ namespace Dawn {
        * 
        * @param deck Array of cards to shuffle.
        */
-      static void shuffle(std::vector<struct Card> *deck);
+      static void shuffle(std::vector<struct Card> &deck);
 
       /**
        * Fills a vector with all of the cards in a deck, in order.
        * 
        * @param deck Deck to fill.
        */
-      static void fillDeck(std::vector<struct Card> *deck); 
+      static void fillDeck(std::vector<struct Card> &deck); 
 
       /**
        * Check if an array of cards contains a specific card.
@@ -67,7 +65,10 @@ namespace Dawn {
        * @param card Card to look for
        * @returns The index within the array that the card is. -1 if not found.
        */
-      static int32_t contains(std::vector<struct Card> *deck, struct Card card);
+      static int32_t contains(
+        const std::vector<struct Card> &deck,
+        const struct Card card
+      );
 
       /**
        * Check if the array of cards contains a specific number.
@@ -77,8 +78,8 @@ namespace Dawn {
        * @returns The index that the first card is. -1 if not found.
        */
       static int32_t containsNumber(
-        std::vector<struct Card> *deck,
+        const std::vector<struct Card> &deck,
-        enum CardValue number
+        const enum CardValue number
       );
 
       /**
@@ -90,10 +91,17 @@ namespace Dawn {
        * @return Card pairs in the deck.
        */
       static std::vector<struct Card> countPairs(
-        std::vector<struct Card> *deck,
+        const std::vector<struct Card> &deck,
-        enum CardValue val
+        const enum CardValue val
       );
 
+      /**
+       * Sorter for the cardSorter function.
+       * 
+       * @param left Left card to compare.
+       * @param right Right card to compare.
+       * @returns True if left is less than right.
+       */
       static bool_t cardSorter(struct Card left, struct Card right);
 
       /**
@@ -103,35 +111,41 @@ namespace Dawn {
        * 
        * @param deck Hand of cards to sort.
        */
-      static void sort(std::vector<struct Card> *deck);
+      static void sort(std::vector<struct Card> &deck);
 
-      Card(CardSuit suit, CardValue num) :
+      /**
-        cardValue(((uint8_t)suit * CARD_COUNT_PER_SUIT) + num)
+       * Constructor for the Card class.
+       * 
+       * @param suit Suit of the card.
+       * @param num Number of the card.
+       */
+      Card(const CardSuit suit, const CardValue num) :
+        Card(
+          ((uint8_t)suit * CARD_COUNT_PER_SUIT) + (uint8_t)num
+        )
       {
-        if(suit == CardSuit::Invalid || num == CardValue::Invalid) {
-          this->cardValue = 0xFF;
-        }
       }
 
-      Card(uint8_t cv) : cardValue(cv) {
+      /**
-        // assertTrue(cv < CARD_DECK_SIZE);
+       * Constructor for the Card class.
+       * 
+       * @param cv Card value.
+       */
+      Card(const uint8_t cv) : cardValue(cv) {
+        assertTrue(cv < CARD_DECK_SIZE, "Card value out of range");
       }
 
       /**
        * Returns the number of a given card.
        * @returns The card number.
        */
-      CardValue getValue() {
+      enum CardValue getValue();
-        return (CardValue)(cardValue % CARD_COUNT_PER_SUIT);
-      }
 
       /**
        * Returns the suit of a given card.
        * @returns The suit.
        */
-      CardSuit getSuit() {
+      enum CardSuit getSuit();
-        return (CardSuit)(cardValue / CARD_COUNT_PER_SUIT);
-      }
   };
 
 }

src/dawnpoker/poker/PokerGame.cpp

@@ -7,18 +7,6 @@
 
 using namespace Dawn;
 
-PokerGame::PokerGame(SceneItem *item) : SceneItemComponent(item) {
-  
-}
-
-void PokerGame::onStart() {
-  SceneItemComponent::onStart();
-
-  this->players = this->getScene()->findComponents<PokerPlayer>();
-  assertTrue(this->players.size() > 0);
-  this->newGame();
-}
-
 void PokerGame::newGame() {
   this->newRound();
 

src/dawnpoker/poker/PokerGame.hpp

@@ -17,7 +17,7 @@
 #define POKER_RIVER_CARD_COUNT 1
 
 namespace Dawn {
-  class PokerGame : public SceneItemComponent {
+  class PokerGame {
     protected:
       std::vector<struct Card> deck;
       std::vector<struct Card> grave;
@@ -33,10 +33,6 @@ namespace Dawn {
       std::vector<struct PokerPot> pots;
       uint8_t betterIndex;
 
-      PokerGame(SceneItem *item);
-
-      void onStart() override;
-
       void newGame();
       void newRound();
       void newBettingRound();
@@ -53,7 +49,5 @@ namespace Dawn {
       void turn(uint8_t count);
       uint8_t getCountOfCardsToTurn();
       uint8_t getRemainingPlayersCount();
-
-      friend class PokerPlayer;
   };
 }

src/dawnpoker/poker/PokerPlayer.cpp

@@ -5,27 +5,25 @@
 
 #include "PokerPlayer.hpp"
 #include "PokerGame.hpp"
+#include "util/Math.hpp"
 
 using namespace Dawn;
 
-PokerPlayer::PokerPlayer(SceneItem *item) : SceneItemComponent(item) {
+PokerPlayer::PokerPlayer(std::weak_ptr<PokerGame> pokerGame) {
-  
+  this->pokerGame = pokerGame;
+  this->chips = POKER_PLAYER_CHIPS_DEFAULT;
 }
 
-void PokerPlayer::onStart() {
+void PokerPlayer::addChips(const int32_t chips) {
-  SceneItemComponent::onStart();
+  assertTrue(chips > 0, "Must add a positive amount of chips.");
-  this->pokerGame = this->getScene()->findComponent<PokerGame>();
-}
-
-void PokerPlayer::addChips(int32_t chips) {
-  assertTrue(chips > 0);
 
   this->chips += chips;
   if(this->chips > 0) this->isOut = false;
-  eventChipsChanged.invoke();
+  
+  this->eventChipsChanged.emit();
 }
 
-void PokerPlayer::setChips(int32_t chips) {
+void PokerPlayer::setChips(const int32_t chips) {
   this->chips = 0;
   this->addChips(chips);
 }
@@ -34,15 +32,21 @@ bool_t PokerPlayer::needsToBetThisRound() {
   if(this->isFolded) return false;
   if(this->chips <= 0) return false;
   if(!this->hasBetThisRound) return true;
-  if(this->currentBet < this->pokerGame->getCurrentCallValue()) return true;
+  auto pg = this->pokerGame.lock();
+  assertNotNull(pg, "PokerGame has become invalid.");
+  if(this->currentBet < pg->getCurrentCallValue()) return true;
   return false;
 }
 
-void PokerPlayer::bet(struct PokerPot *pot, int32_t chips) {
+void PokerPlayer::bet(
-  assertNotNull(pot);
+  struct PokerPot &pot,
-  assertTrue(chips >= 0);
+  const int32_t chips
-  assertTrue(!this->isFolded);
+) {
-  assertTrue(!this->isOut);
+  assertNotNull(pot, "Pot must be valid.");
+  assertTrue(chips >= 0, "Chips must be a positive value.");
+  assertTrue(!this->isFolded, "Cannot bet if player is folded.");
+  assertTrue(!this->isOut, "Cannot bet if player is out.");
+
   this->setChips(this->chips - chips);
   this->currentBet += chips;
   this->hasBetThisRound = true;
@@ -52,16 +56,19 @@ void PokerPlayer::bet(struct PokerPot *pot, int32_t chips) {
     this->timesRaised = 0;
   }
 
-  pot->chips += chips;
+  pot.chips += chips;
-  pot->call = mathMax<int32_t>(pot->call, this ->currentBet);
+  pot.call = Math::max<int32_t>(pot.call, this ->currentBet);
 
-  auto existing = std::find(pot->players.begin(), pot->players.end(), this);
+  auto existing = std::find(pot.players.begin(), pot.players.end(), this);
-  if(existing == pot->players.end()) pot->players.push_back(this);
+  if(existing == pot.players.end()) pot.players.push_back(this);
 }
 
-void PokerPlayer::bet(int32_t chips) {
+void PokerPlayer::bet(const int32_t chips) {
-  assertTrue(this->pokerGame->pots.size() > 0);
+  auto pg = this->pokerGame.lock();
-  this->bet(&this->pokerGame->pots.back(), chips);
+  assertNotNull(pg, "PokerGame has become invalid.");
+  assertTrue(pg->pots.size() > 0, "PokerGame has no pots?");
+  assertUnreachable("Bugged");
+  // this->bet(&this->pokerGame->pots.back(), chips);
 }
 
 void PokerPlayer::fold() {
@@ -71,7 +78,12 @@ void PokerPlayer::fold() {
 }
 
 bool_t PokerPlayer::canCheck() {
-  return this->pokerGame->getCurrentCallValue() <= this->currentBet;
+  if(this->isFolded) return false;
+  if(this->isOut) return false;
+
+  auto pg = this->pokerGame.lock();
+  assertNotNull(pg, "PokerGame has become invalid.");
+  return pg->getCurrentCallValue() == this->currentBet;
 }
 
 struct PokerTurn PokerPlayer::getAITurn() {

src/dawnpoker/poker/PokerPlayer.hpp

@@ -4,14 +4,11 @@
 // https://opensource.org/licenses/MIT
 
 #pragma once
-#include "scene/SceneItemComponent.hpp"
 #include "Card.hpp"
 #include "PokerPot.hpp"
-#include "util/mathutils.hpp"
-#include "display/animation/Easing.hpp"
 #include "PokerWinning.hpp"
 #include "PokerTurn.hpp"
-#include "util/random.hpp"
+#include "event/Event.hpp"
 
 #define POKER_PLAYER_CHIPS_DEFAULT 10000
 
@@ -23,9 +20,9 @@
 namespace Dawn {
   class PokerGame;
 
-  class PokerPlayer : public SceneItemComponent {
+  class PokerPlayer {
     public:
-      PokerGame *pokerGame;
+      std::weak_ptr<PokerGame> pokerGame;
       int32_t chips = 0;
       int32_t currentBet = 0;
       uint8_t timesRaised = 0;
@@ -39,28 +36,25 @@ namespace Dawn {
       Event<> eventChipsChanged;
 
       /**
-       * Creates a PokerPlayer instance.
+       * Constructor for the PokerPlayer class.
        * 
-       * @param item Item that this poker player belongs to.
+       * @param pokerGame Poker game this player is a part of.
        */
-      PokerPlayer(SceneItem *item);
+      PokerPlayer(std::weak_ptr<PokerGame> pokerGame);
-
-      /** Override for scene item component event for init */
-      void onStart() override;
 
       /**
        * Adds chips to the player. This will also update the players' state.
        * 
        * @param chips Count of chips to add.
        */
-      void addChips(int32_t chips);
+      void addChips(const int32_t chips);
 
       /**
        * Sets the chips a player has.
        * 
        * @param chips Chips to set to the player.
        */
-      void setChips(int32_t chips);
+      void setChips(const int32_t chips);
 
       /**
        * Returns true if the player still needs to bet this betting round.
@@ -75,14 +69,14 @@ namespace Dawn {
        * @param pot Poker pot to bet in to.
        * @param amount The amount of chips the player is betting.
        */
-      void bet(struct PokerPot *pot, int32_t amount);
+      void bet(struct PokerPot pot, const int32_t amount);
 
       /**
        * Let a player bet chips into the current pot.
        * 
        * @param amount The amount of chips the player is betting.
        */
-      void bet(int32_t amount);
+      void bet(const int32_t amount);
 
       /**
        * Player folds.