What cards unblock what. Timing/dealing is nice.

deck.cpp

@@ -194,6 +194,31 @@ door::Panel *Deck::card(int c) { return cards[c]; }
 
 door::Panel *Deck::back(int level) { return backs[level]; }
 
+const std::array<std::pair<int, int>, 18> Deck::blocks = {
+    make_pair(3, 4),   make_pair(5, 6),   make_pair(7, 8), // end row 1
+    make_pair(9, 10),  make_pair(10, 11), make_pair(12, 13),
+    make_pair(13, 14), make_pair(15, 16), make_pair(16, 17),
+    make_pair(18, 19), // end row 2
+    make_pair(19, 20), make_pair(20, 21), make_pair(21, 22),
+    make_pair(22, 23), make_pair(23, 24), make_pair(24, 25),
+    make_pair(25, 26), make_pair(26, 27) // 27
+};
+
+/**
+ * @brief Which card (if any) is unblocked by this card
+ *
+ * @param c
+ * @return * int
+ */
+int Deck::unblocks(int c) {
+  for (size_t i = 0; i < blocks.size(); ++i) {
+    if ((blocks.at(i).first == c) || (blocks.at(i).second == c)) {
+      return i;
+    }
+  }
+  return -1;
+}
+
 /*
 Layout spacing 1:
 
@@ -284,12 +309,12 @@ int levels[4] = {3, 6, 9, 10};
   }
 }
 
-vector<int> card_shuffle(std::seed_seq &seed, int decks) {
+std::vector<int> card_shuffle(std::seed_seq &seed, int decks) {
   std::mt19937 gen;
 
   // build deck of cards
   int size = decks * 52;
-  vector<int> deck;
+  std::vector<int> deck;
   deck.reserve(size);
   for (int x = 0; x < size; ++x) {
     deck.push_back(x);
@@ -300,3 +325,10 @@ vector<int> card_shuffle(std::seed_seq &seed, int decks) {
   std::shuffle(deck.begin(), deck.end(), gen);
   return deck;
 }
+
+std::vector<int> card_states(int decks) {
+  // auto states = std::unique_ptr<std::vector<int>>(); // (decks * 52, 0)>;
+  std::vector<int> states;
+  states.assign(decks * 52, 0);
+  return states;
+}

deck.h

@@ -2,6 +2,7 @@
 
 #include <random>
 #include <string>
+#include <utility> // pair
 #include <vector>
 
 /*
@@ -42,6 +43,8 @@ public:
   door::Panel *card(int c);
   door::Panel *back(int level);
   void part(int x, int y, door::Door &d, int level, bool left);
+  int unblocks(int c);
+  const static std::array<std::pair<int, int>, 18> blocks;
 };
 
 /**
@@ -66,4 +69,6 @@ void cardgo(int pos, int space, int h, int &x, int &y, int &level);
  * @param decks
  * @return vector<int>
  */
-vector<int> card_shuffle(std::seed_seq &seed, int decks = 1);
+std::vector<int> card_shuffle(std::seed_seq &seed, int decks = 1);
+
+std::vector<int> card_states(int decks = 1);

main.cpp

@@ -499,8 +499,7 @@ int main(int argc, char *argv[]) {
         // it has moved.
       }
 
-      door << door::RestoreCursor;
-      door.previous = door::reset;
+      door << door::RestoreCursor << door::reset;
 
     } else {
       if (r < 0)
@@ -561,23 +560,33 @@ int main(int argc, char *argv[]) {
   int off_y = (my - 9) / 2;
 
   std::seed_seq s1{2021, 2, 27, 1};
-  vector<int> deck1 = card_shuffle(s1, 1);
-
-  std::uniform_int_distribution<int> rand_card(0, 51); // 0 - 51
-  std::uniform_int_distribution<int> rand_action(0, 100);
+  std::vector<int> deck1 = card_shuffle(s1, 1);
+  std::vector<int> state = card_states();
 
   for (int x = 0; x < 28; x++) {
     int cx, cy, level;
+    std::this_thread::sleep_for(std::chrono::milliseconds(75));
     cardgo(x, space, height, cx, cy, level);
-    if (rand_action(rng) > 80) {
-      c = d.back(level);
-    } else {
-      c = d.card(deck1[x]);
-      // c = d.card(rand_card(rng));
-    }
+    c = d.back(level);
+    c->set(cx + off_x, cy + off_y);
+    door << *c;
+  }
+
+  std::this_thread::sleep_for(
+      std::chrono::seconds(2)); // 3 secs seemed too long!
+
+  for (int x = 18; x < 28; x++) {
+    int cx, cy, level;
+    // usleep(1000 * 20);
+    std::this_thread::sleep_for(std::chrono::milliseconds(200));
+    state.at(x) = 1;
+    cardgo(x, space, height, cx, cy, level);
+
+    c = d.card(deck1.at(x));
     c->set(cx + off_x, cy + off_y);
     door << *c;
   }
+
   door << door::reset;
   door << door::nl << door::nl;