messages through info

src/base.h

   Hit,
 };
 
+enum class Info {
+  None,
+  NewHand,
+  Shuffle,
+  Bye,
+};
+
 // alphabetically-sorted
 enum class Suit {
   Clubs    = 0,
     std::string singleUTF8;
 };
 
-
+// TODO: static inside a class
 extern Card card[52];
 
-
-// TODO: base + daugthers, para diferenciar entre dealer y player y otros juegos
 class Hand {
   public:
     std::list<unsigned int> cards;
     }
 */    
     virtual int play() = 0;
+    virtual void info(Info = Info::None, int = 0) = 0;
     
     PlayerActionRequired actionRequired = PlayerActionRequired::None;
     PlayerActionTaken    actionTaken    = PlayerActionTaken::None;

src/blackjack.cpp

 
   bool explicit_seed = conf.set(&rng_seed, {"rng_seed", "seed"});
   
-  // TODO: seed instead of dev_random
   if (explicit_seed) {
     rng = std::mt19937(rng_seed);
   }
 }
 
 Blackjack::~Blackjack() {
-  std::cout << "Bye bye! We'll play Blackjack again next time." << std::endl;
+  return;    
 }
 
 void Blackjack::deal(Player *player) {
       // clear dealer's hand
       hand.holeCardShown = false;
       hand.cards.clear();
-      for (auto card : hand.cards) {
-        std::cout << card << std::endl;
-      }
-      std::cout << hand.cards.size() << std::endl;
 
       // erase all the player's hands, create one, add and make it the current one
       for (auto playerHand : player->hands) {
 //      player->hasDoubled = 0;
       
       if (lastPass) {
-        // TODO: send informative messages to the player
-        // tell people we are shuffling
-        //  bjcall (blackjack.current_player->write (player, "shuffling"));
+        player->info(Info::Shuffle);
           
         // shuffle the cards          
         shuffle();        
           
-        // TODO: reset card counting systems
         // burn as many cards as asked
         for (int i = 0; i < number_of_burnt_cards; i++) {
-//          drawCard();
+          drawCard();
         }
         lastPass = false;
       }
         nextAction = DealerAction::AskForBets;
       }
 
-      std::cout << "new_hand" << std::endl;
+      player->info(Info::NewHand, n_hand);
       return;
       
     break;
     // -------------------------------------------------------------------------  
     case DealerAction::AskForBets:
       // step 1. ask for bets
-      // TODO: use an output buffer to re-ask in case no number comes back
-      std::cout << "bet?" << std::endl;
-      // TODO: setter
       player->actionRequired = PlayerActionRequired::Bet;
       return;
     break;

src/blackjack.h

 #include "base.h"
 #include "conf.h"
 
+
 class Blackjack : public Dealer {
   public:  
     Blackjack(Configuration &);
     ~Blackjack();
     
     void shuffle() override;
-    unsigned int drawCard(Hand *) override;
+    unsigned int drawCard(Hand * = nullptr) override;
     void deal(Player *) override;
     int process(Player *) override;
     

src/stdinout.cpp

 StdInOut::StdInOut(void) {
 }
 
+void StdInOut::info(Info msg, int data) {
+  return;
+}
 
 int StdInOut::play() {
   

src/stdinout.h

     ~StdInOut() { };
     
     int play(void) override;
+    void info(Info = Info::None, int = 0) override;
     
   private:
     std::string input_buffer;

src/tty.cpp

 #include <iostream>
 #include <cstring>
+#include <thread>
+#include <chrono>
 
 #ifdef HAVE_LIBREADLINE
 #include <readline/readline.h>
 
 Tty::Tty(Configuration &conf) {
     
-  if (conf.exists("flat_bet")) {
-    flat_bet = conf.getInt("flat_bet");
-  } else if (conf.exists("flat_bet")) {
-    flat_bet = conf.getInt("flat_bet");
-  }
-    
+  conf.set(&flat_bet, {"flat_bet", "flatbet"});  
+  conf.set(&no_insurance, {"no_insurance", "dont_insure"});  
+
 #ifdef HAVE_LIBREADLINE
   prompt = cyan + " > " + reset;
 #endif
 }
 
+void Tty::info(Info msg, int intData) {
+  std::string s;  
+  switch (msg) {
+    case Info::NewHand:
+//      s = "new_hand";  
+      s = "Starting new hand #" + std::to_string(intData);
+    break;
+    case Info::Shuffle:
+//      s = "shuffle";  
+      s = "Deck needs to be shuffled.";
+    break;
+    case Info::Bye:
+//      s = "bye";  
+      s = "Bye bye! We'll play Blackjack again next time.";
+    break;
+  }
+  
+  if (delay > 0) {
+    std::this_thread::sleep_for(std::chrono::milliseconds(delay));
+  }  
+  std::cout << green << s << reset << std::endl;
+  return;
+}
+
 int Tty::play() {
   
 #ifdef HAVE_LIBREADLINE

src/tty.h

 class Tty : public Player {
   public:  
     Tty(Configuration &);
-    ~Tty() {
-      std::cout << "bye!" << std::endl;
-    };
+    ~Tty() { };
     
     int play() override;
+    void info(Info = Info::None, int = 0) override;
+
     
   private:
     
 #else
   std::string input_buffer;
 #endif
-  
+
+    std::string arrow;
     std::string prompt;
+    
+    int delay = 200;
 
     std::string black   = "\x1B[0m";
     std::string red     = "\x1B[31m";