Fixed some bugs with AI

src/dawn/poker/PokerGame.hpp

@@ -26,12 +26,12 @@ namespace Dawn {
       uint8_t dealerIndex;
       uint8_t smallBlindIndex;
       uint8_t bigBlindIndex;
-      uint8_t betterIndex;
       int32_t smallBlind = POKER_BLIND_SMALL_DEFAULT;
       int32_t bigBlind = POKER_BLIND_BIG_DEFAULT;
 
     public:
       std::vector<PokerPlayer*> players;
+      uint8_t betterIndex;
 
       PokerGame(SceneItem *item);
 

src/dawn/poker/PokerPlayer.cpp

@@ -42,7 +42,11 @@ void PokerPlayer::bet(struct PokerPot *pot, int32_t chips) {
   this->chips -= chips;
   this->currentBet += chips;
   this->hasBetThisRound = true;
-  if(chips > 0) this->timesRaised++;
+  if(chips > 0) {
+    this->timesRaised++;
+  } else {
+    this->timesRaised = 0;
+  }
 
   pot->chips += chips;
   pot->call = mathMax<int32_t>(pot->call, this ->currentBet);
@@ -56,6 +60,12 @@ void PokerPlayer::bet(int32_t chips) {
   this->bet(&this->pokerGame->pots.back(), chips);
 }
 
+void PokerPlayer::fold() {
+  this->isFolded = true;
+  this->hasBetThisRound = true;
+  this->timesRaised = 0;
+}
+
 bool_t PokerPlayer::canCheck() {
   return this->pokerGame->getCurrentCallValue() <= this->currentBet;
 }
@@ -96,7 +106,7 @@ struct PokerTurn PokerPlayer::getAITurn() {
     );
 
     // Get card weight
-    float_t confidence = (float_t)cardNumber0 + (float_t)cardNumber1;
+    confidence = (float_t)cardNumber0 + (float_t)cardNumber1;
     if(cardNumber0 == cardNumber1) {// Pairs
       confidence += 6;
     } else if(suitNumber0 == suitNumber1) {// Same suit
@@ -214,7 +224,7 @@ struct PokerTurn PokerPlayer::getAITurn() {
     turn = PokerTurn::bet(this, 0);
     turn.confidence = 1;
   } else {
-    turn = PokerTurn::fold();
+    turn = PokerTurn::fold(this);
     turn.confidence = 1 - confidence;
   }
 

src/dawn/poker/PokerPlayer.hpp

@@ -76,6 +76,11 @@ namespace Dawn {
        */
       void bet(int32_t amount);
 
+      /**
+       * Player folds.
+       */
+      void fold();
+
       /**
        * Returns the AI result for a turn done by a non human player.
        * 

src/dawn/poker/PokerTurn.cpp

@@ -16,6 +16,7 @@ struct PokerTurn PokerTurn::bet(PokerPlayer *player, int32_t chips) {
   assertNotNull(player);
   assertTrue(chips >= 0);
 
+  turn.player = player;
   turn.confidence = 1;
 
   if(chips == 0) {
@@ -37,10 +38,35 @@ struct PokerTurn PokerTurn::bet(PokerPlayer *player, int32_t chips) {
   return turn;
 }
 
-struct PokerTurn PokerTurn::fold() {
+struct PokerTurn PokerTurn::fold(PokerPlayer *player) {
   struct PokerTurn turn;
+  turn.player = player;
   turn.chips = 0;
   turn.confidence = 1;
   turn.type = POKER_TURN_TYPE_FOLD;
   return turn;
+}
+
+void PokerTurn::action() {
+  assertNotNull(this->player);
+
+  switch(this->type) {
+    case POKER_TURN_TYPE_BET:
+    case POKER_TURN_TYPE_CALL:
+    case POKER_TURN_TYPE_ALL_IN:
+      this->player->bet(this->chips);
+      break;
+
+    case POKER_TURN_TYPE_CHECK:
+      player->bet(0);
+      break;
+
+    case POKER_TURN_TYPE_FOLD:
+      player->fold();
+      break;
+    
+    default:
+      assertUnreachable();
+      break;
+  }
 }

src/dawn/poker/PokerTurn.hpp

@@ -26,6 +26,8 @@ namespace Dawn {
       int32_t chips;
       /** How confident the AI is about their turn. 0 = none, 1 = full */
       float_t confidence;
+      /** Player that this action belongs to */
+      PokerPlayer *player;
 
       /**
        * Generate a turn action for betting as a player.
@@ -41,6 +43,11 @@ namespace Dawn {
        * 
        * @return A turn for a fold action.
        */
-      static struct PokerTurn fold();
+      static struct PokerTurn fold(PokerPlayer *player);
+
+      /**
+       * Actions / Performs this turn against the defined player.
+       */
+      void action();
   };
 }

src/dawn/poker/visualnovel/PokerAIBetEvent.hpp

@@ -9,14 +9,16 @@
 #define POKER_DEAL_EVENT_CARD_COUNT 2
 
 namespace Dawn {
-  class PokerDealEvent : public PokerGameEvent {
+  class PokerAIBetEvent : public PokerGameEvent {
     protected:
-      void onStart() override {
-        PokerGameEvent::onStart();
+      void onStart(IVisualNovelEvent *previous) override {
+        PokerGameEvent::onStart(previous);
         
         auto better = this->pokerGame->getNextBetterIndex();
-        this->pokerGame->better = better;
+        this->pokerGame->betterIndex = better;
         auto player = this->pokerGame->players[better];
+        this->turn = player->getAITurn();
+        this->turn.action();
       }
 
       bool_t onUpdate() override {
@@ -28,8 +30,9 @@ namespace Dawn {
 
     public:
       uint8_t better;
+      struct PokerTurn turn;
 
-      PokerDealEvent(VisualNovelManager *manager) : PokerGameEvent(manager) {
+      PokerAIBetEvent(VisualNovelManager *manager) : PokerGameEvent(manager) {
       }
   };
 }

src/dawn/poker/visualnovel/PokerDealEvent.hpp

@@ -11,8 +11,9 @@
 namespace Dawn {
   class PokerDealEvent : public PokerGameEvent {
     protected:
-      void onStart() override {
-        PokerGameEvent::onStart();
+      void onStart(IVisualNovelEvent *previous) override {
+        PokerGameEvent::onStart(previous);
+        std::cout << "Dealing to everyone" << std::endl;
         this->pokerGame->dealToEveryone(POKER_DEAL_EVENT_CARD_COUNT);
       }
 

src/dawn/poker/visualnovel/PokerDetermineBetterEvent.cpp

@@ -10,32 +10,44 @@ using namespace Dawn;
 PokerDetermineBetterEvent::PokerDetermineBetterEvent(VisualNovelManager *man) :
   PokerGameEvent(man)
 {
-
+  std::cout << "Inited determine better" << std::endl << std::endl;
 }
 
-void PokerDetermineBetterEvent::onStart() {
-  PokerGameEvent::onStart();
+void PokerDetermineBetterEvent::onStart(IVisualNovelEvent *previous) {
+  PokerGameEvent::onStart(previous);
+
+  std::cout << "better evt" << std::endl;
 
   if(this->pokerGame->getRemainingPlayersCount() <= 1) {
-    this->doNext = this->eventEveryoneFolded;
+    this->then(this->eventEveryoneFolded);
+    this->eventEveryoneFolded = nullptr;
+    std::cout << "Everyone folded" << std::endl;
     return;
   }
 
   uint8_t nextBetterIndex = this->pokerGame->getNextBetterIndex();
   if(nextBetterIndex == 0xFF) {
     if(this->pokerGame->getCountOfCardsToTurn() == 0xFF) {
-      this->doNext = this->eventBettingFinished;
+      this->then(this->eventBettingFinished);
+      this->eventBettingFinished = nullptr;
+      std::cout << "Betting Finished" << std::endl;
     } else {
-      this->doNext = this->eventTurn;
+      this->then(this->eventTurn);
+      this->eventTurn = nullptr;
+      std::cout << "Turn Time?" << std::endl;
     }
     return;
   }
   
   auto nextBetter = this->pokerGame->players[nextBetterIndex];
   if(nextBetter->isHuman) {
-    this->doNext = this->eventHumanBet;
+    this->then(this->eventHumanBet);
+    this->eventHumanBet = nullptr;
+    std::cout << "Human Better" << std::endl;
   } else {
-    this->doNext = this->eventAiBet;
+    this->then(this->eventAiBet);
+    this->eventAiBet = nullptr;
+    std::cout << "AI Better" << std::endl;
   }
 }
 
@@ -47,28 +59,9 @@ void PokerDetermineBetterEvent::onEnd() {
 }
 
 PokerDetermineBetterEvent::~PokerDetermineBetterEvent() {
-  if(
-    this->eventEveryoneFolded != nullptr &&
-    this->eventEveryoneFolded != this->doNext
-  ) delete this->eventEveryoneFolded;
-  
-  if(
-    this->eventBettingFinished != nullptr &&
-    this->eventBettingFinished != this->doNext
-  ) delete this->eventBettingFinished;
-  
-  if(
-    this->eventTurn != nullptr &&
-    this->eventTurn != this->doNext
-  ) delete this->eventTurn;
-  
-  if(
-    this->eventAiBet != nullptr &&
-    this->eventAiBet != this->doNext
-  ) delete this->eventAiBet;
-  
-  if(
-    this->eventHumanBet != nullptr &&
-    this->eventHumanBet != this->doNext
-  ) delete this->eventHumanBet;
+  if(this->eventEveryoneFolded != nullptr) delete this->eventEveryoneFolded;
+  if(this->eventBettingFinished != nullptr) delete this->eventBettingFinished;
+  if(this->eventTurn != nullptr) delete this->eventTurn;
+  if(this->eventAiBet != nullptr) delete this->eventAiBet;
+  if(this->eventHumanBet != nullptr) delete this->eventHumanBet;
 }

src/dawn/poker/visualnovel/PokerDetermineBetterEvent.hpp

@@ -15,7 +15,7 @@ namespace Dawn {
       IVisualNovelEvent * eventAiBet = nullptr;
       IVisualNovelEvent * eventHumanBet = nullptr;
 
-      void onStart() override;
+      void onStart(IVisualNovelEvent *previous) override;
       bool_t onUpdate() override;
       void onEnd() override;
 
@@ -37,7 +37,6 @@ namespace Dawn {
       T * whenEveryoneFolded(T *event) {
         assertNotNull(event);
         this->eventEveryoneFolded = event;
-        event->previous = this;
         return event;
       }
 
@@ -51,7 +50,6 @@ namespace Dawn {
       T * whenBettingFinished(T *event) {
         assertNotNull(event);
         this->eventBettingFinished = event;
-        event->previous = this;
         return event;
       }
 
@@ -66,7 +64,6 @@ namespace Dawn {
       T * whenTurn(T *event) {
         assertNotNull(event);
         this->eventTurn = event;
-        event->previous = this;
         return event;
       }
 
@@ -80,7 +77,6 @@ namespace Dawn {
       T * whenAiBet(T *event) {
         assertNotNull(event);
         this->eventAiBet = event;
-        event->previous = this;
         return event;
       }
 
@@ -94,7 +90,6 @@ namespace Dawn {
       T * whenHumanBet(T *event) {
         assertNotNull(event);
         this->eventHumanBet = event;
-        event->previous = this;
         return event;
       }
 

src/dawn/poker/visualnovel/PokerGameEvent.hpp

@@ -12,7 +12,7 @@ namespace Dawn {
     protected:
       PokerGame *pokerGame;
       
-      void onStart() override {
+      void onStart(IVisualNovelEvent *previous) override {
         pokerGame = this->manager->getScene()->findComponent<PokerGame>();
         assertNotNull(pokerGame);
       }

src/dawn/poker/visualnovel/PokerNewGameEvent.hpp

@@ -9,8 +9,9 @@
 namespace Dawn {
   class PokerNewGameEvent : public PokerGameEvent {
     protected:
-      void onStart() override {
-        PokerGameEvent::onStart();
+      void onStart(IVisualNovelEvent *previous) override {
+        PokerGameEvent::onStart(previous);
+        std::cout << "New Game" << std::endl;
         this->pokerGame->newGame();
       }
 

src/dawn/poker/visualnovel/PokerNewRoundEvent.hpp

@@ -9,8 +9,9 @@
 namespace Dawn {
   class PokerNewRoundEvent : public PokerGameEvent {
     protected:
-      void onStart() override {
-        PokerGameEvent::onStart();
+      void onStart(IVisualNovelEvent *previous) override {
+        PokerGameEvent::onStart(previous);
+        std::cout << "New Round" << std::endl;
         this->pokerGame->newRound();
       }
 

src/dawn/poker/visualnovel/PokerTakeBlindsEvent.hpp

@@ -9,8 +9,9 @@
 namespace Dawn {
   class PokerTakeBlindsEvent : public PokerGameEvent {
     protected:
-      void onStart() override {
-        PokerGameEvent::onStart();
+      void onStart(IVisualNovelEvent *previous) override {
+        PokerGameEvent::onStart(previous);
+        std::cout << "Take Blinds" << std::endl;
         this->pokerGame->takeBlinds();
       }
 

src/dawn/poker/visualnovel/PokerTurnEvent.hpp

@@ -9,8 +9,8 @@
 namespace Dawn {
   class PokerTurnEvent : public PokerGameEvent {
     protected:
-      void onStart() override {
-        PokerGameEvent::onStart();
+      void onStart(IVisualNovelEvent *previous) override {
+        PokerGameEvent::onStart(previous);
         
         this->cardsTurned = this->pokerGame->getCountOfCardsToTurn();
         assertTrue(this->cardsTurned != 0xFF);