check for BJs

src/base.h

 // TODO: base + daugthers, para diferenciar entre dealer y player y otros juegos
 class Hand {
   public:
+    int id = 0;
     bool insured = false;
     bool holeCardShown = false;
     int bet = 0;
     bool hasSplit = false;
     bool hasDoubled = false;
 
-    int flatBet = 0;
-    int currentBet = 0;
-    int n_hands = 0;  // this is different from the dealer's due to splitting
-    int n_insured_hands = 0;
+    unsigned int flatBet = 0;
+    unsigned int currentBet = 0;
+    unsigned int n_hands = 0;  // this is different from the dealer's due to splitting
+    unsigned int n_insured_hands = 0;
+    unsigned int player_blackjacks = 0;
 
+    unsigned int dealer_blackjacks = 0;
+    unsigned int insured_wins = 0;
+    unsigned int pushes = 0;
+    unsigned int losses = 0;
+    unsigned int wins = 0;
+    unsigned int blackjack_wins = 0;
+    // TODO: blackjack_pushes?
+    
     bool no_insurance = false;
     bool always_insure = false;
   
     double bankroll = 0;
+    double worst_bankroll = 0;
     double total_money_waged = 0;
     double current_result = 0;
     double mean = 0;

src/blackjack.cpp

 
 void Blackjack::deal(Player *player) {
   
+  int playerTotal = 0;
+  bool playerBlackack = false;
   // let's start by assuming the player does not need to do anything
   setInputNeeded(false);    
     
           player->actionRequired = PlayerActionRequired::Insurance;
           setNextAction(DealerAction::AskForInsurance);
           setInputNeeded(true);
+          std::cout << "next ask insurance" << std::endl;
           return;
         
         } else if (player->always_insure) {
       }
       
       // step 7.b. if either the dealer or the player has a chance to have a blackjack, check
-      if ((card[upCard].value == 10 || card[upCard].value == 11) || player->currentHand->total() == 21) {
+      playerTotal = player->currentHand->total();
+      if ((card[upCard].value == 10 || card[upCard].value == 11) || playerTotal == 21) {
         player->actionRequired = PlayerActionRequired::None;
         setNextAction(DealerAction::CheckforBlackjacks);
         setInputNeeded(false);
+        std::cout << "next check BJs" << std::endl;
         return;
       }
 
       player->actionRequired = PlayerActionRequired::Play;
       setNextAction(DealerAction::AskForPlay);
       setInputNeeded(true);
+      std::cout << "dealer upcard is " << card[upCard].utf8() << std::endl;
+      std::cout << "your total is " << playerTotal << std::endl;
+      std::cout << "play please" << std::endl;
       return;
     break;
     
     case DealerAction::AskForInsurance:
-      std::cout << "hola" << std::endl;  
+      std::cout << "next action do you want insurance?" << std::endl;  
+      return;
     break;
     
-/*    
     case DealerAction::CheckforBlackjacks:
+      // step 8. check if there are any blackjack
+      playerBlackack = player->currentHand->blackjack();
+      if (hand.blackjack()) {
+        std::cout << "card_dealer_hole" << card[holeCard].utf8() << std::endl;
+        std::cout << "blackjack_dealer" << std::endl;
+	player->dealer_blackjacks++;
+        // print_hand_art (blackjack.dealer_hand);
+
+        if (player->currentHand->insured) {
+          std::cout << "player_wins_insurance " << player->currentHand->bet << std::endl;
+          player->current_result += player->currentHand->bet;
+          player->bankroll += player->currentHand->bet;
+          player->insured_wins++;
+	}
+
+	if (playerBlackack) {
+          std::cout << "blackjack_player_also" << std::endl;
+          player->player_blackjacks++;
+	  if (player->hasSplit) {
+            std::cout << "player_pushes " << player->currentHand->bet << " #" << player->currentHand->id << std::endl;
+          } else {
+            std::cout << "player_pushes " << player->currentHand->bet << std::endl;
+          }
+          player->pushes++;
+          
+          //  print_hand_art (player->current_hand);
+        } else {
+	  if (player->hasSplit) {
+            std::cout << "player_losses " << player->currentHand->bet << " #" << player->currentHand->id << std::endl;
+          } else {
+            std::cout << "player_losses " << player->currentHand->bet << std::endl;
+          }
+	  player->current_result -= player->currentHand->bet;
+	  player->bankroll -= player->currentHand->bet;
+	  if (player->bankroll < player->worst_bankroll) {
+            player->worst_bankroll = player->bankroll;
+	  }
+	  player->losses++;
+	}
+
+        setNextAction(DealerAction::StartNewHand);
+        player->actionRequired = PlayerActionRequired::None;
+        setInputNeeded(false);
+        std::cout << "next start a new hand";
+        return;
+        
+      } else if (playerBlackack) {
+	std::cout << "blackjack_player" << std::endl;
+	player->current_result += blackjack_pays * player->currentHand->bet;
+	player->bankroll += blackjack_pays * player->currentHand->bet;
+	player->player_blackjacks++;
+          
+	std::cout << "player_wins " << blackjack_pays * player->currentHand->bet << std::endl;
+	player->wins++;
+        player->blackjack_wins++;
+
+        setNextAction(DealerAction::StartNewHand);
+        player->actionRequired = PlayerActionRequired::None;
+        setInputNeeded(false);
+        std::cout << "next start a new hand";
+        return;
+        
+      } else {
+	// only if the dealer had the chance to have a blackjack we say "no_blackjacks"
+	if (card[upCard].value == 10 || card[upCard].value == 11) {
+          std::cout << "no_blackjacks" << std::endl;
+        }
+        
+        setNextAction(DealerAction::AskForPlay);
+        player->actionRequired = PlayerActionRequired::Play;
+        setInputNeeded(true);
+        std::cout << "prepare to play";
+        return;
+      }        
     break;
+    
+/*
     case DealerAction::PayOrTakeInsuranceBets:
     break;
     case DealerAction::AskForPlay:
     break;
 
     case PlayerActionTaken::Insure:
+      // TODO: allow insurance for less than one half of the original bet
       player->currentHand->insured = true;
+      player->current_result -= 0.5 * player->currentHand->bet;
+      player->bankroll -= 0.5 * player->currentHand->bet;
+      player->n_insured_hands++;
+         
+      player->actionRequired = PlayerActionRequired::None;
+      setNextAction(DealerAction::CheckforBlackjacks);
+      setInputNeeded(false);
       return 1;
     break;
 
     case PlayerActionTaken::DontInsure:
       player->currentHand->insured = false;
+      player->actionRequired = PlayerActionRequired::None;
+      setNextAction(DealerAction::CheckforBlackjacks);
+      setInputNeeded(false);
       return 1;
     break;
       
 
 int Blackjack::dealCard(Hand *hand) {
     
-  int dealt_tag = 0;
+  unsigned int tag = 0;
 
   if (n_decks == -1) {
       
     // TODO: arranged cards
     int random_integer = random();
-    dealt_tag = (random_integer % 32) + (random_integer % 16) + (random_integer % 4);
+    tag = (random_integer % 32) + (random_integer % 16) + (random_integer % 4);
     
   } else {
-    dealt_tag = 1;
+    // TODO: shoes
+    tag = 0;
   }
     
   if (hand != nullptr) {
-      
+    hand->cards.push_back(tag);
   }
   
-  return dealt_tag;
+  return tag;
 }

src/blackjack.h

     unsigned int infinite_decks_card_number_for_arranged_ones = 0;
     
     double insurance = 0;
+    double blackjack_pays = 1.5;
       
 };
 #endif

src/tty.cpp

     break;
     
     case PlayerActionRequired::Play:
+        
+      // TODO: sort by higher-expected response first
       if (strcmp(input_buffer, "h") == 0 || strcmp(input_buffer, "hit") == 0) {
         actionTaken = PlayerActionTaken::Hit;
+      } else if (strcmp(input_buffer, "s") == 0 || strcmp(input_buffer, "stand") == 0) {
+        actionTaken = PlayerActionTaken::Stand;
+      } else if (strcmp(input_buffer, "d") == 0 || strcmp(input_buffer, "double") == 0) {
+        actionTaken = PlayerActionTaken::Stand;
+      } else if (strcmp(input_buffer, "p") == 0 || strcmp(input_buffer, "pair") == 0 || strcmp(input_buffer, "split") == 0) {
+        actionTaken = PlayerActionTaken::Split;
       } else {
         actionTaken = PlayerActionTaken::None;
       }