Working sort of deck and dealing.

deck.cpp

@@ -2,14 +2,23 @@
 
 #include <sstream>
 
-Deck::Deck() {
+Deck::Deck(int size) {
   cardback = door::ANSIColor(door::COLOR::RED);
+  card_height = size;
   init();
 }
 
-Deck::Deck(door::ANSIColor backcolor) : cardback{backcolor} { init(); }
+Deck::Deck(door::ANSIColor backcolor, int size) : cardback{backcolor} {
+  card_height = size;
+  init();
+}
 
 void Deck::init(void) {
+  if (card_height != 3) {
+    if (card_height != 5) {
+      card_height = 3;
+    }
+  }
   for (int i = 0; i < 52; ++i) {
     cards.push_back(card_of(i));
   }
@@ -34,28 +43,8 @@ int Deck::is_suit(int c) { return c / 13; }
 int Deck::is_rank(int c) { return c % 13; }
 
 char Deck::rank_symbol(int c) {
-  switch (c) {
-  case 0:
-    return 'A';
-  case 1:
-  case 2:
-  case 3:
-  case 4:
-  case 5:
-  case 6:
-  case 7:
-  case 8:
-    return char(c + 0x30 + 1);
-  case 9:
-    return 'T';
-  case 10:
-    return 'J';
-  case 11:
-    return 'Q';
-  case 12:
-    return 'K';
-  }
-  return '?';
+  const char symbols[] = "A23456789TJQK";
+  return symbols[c];
 }
 
 std::string Deck::suit_symbol(int c) {
@@ -110,11 +99,19 @@ door::Panel *Deck::card_of(int c) {
   p->addLine(std::make_unique<door::Line>(str, 5, color));
   oss.str(std::string());
   oss.clear();
+
+  if (card_height == 5)
+    p->addLine(std::make_unique<door::Line>("     ", 5, color));
+
   oss << "  " << s << "  ";
   str = oss.str();
   p->addLine(std::make_unique<door::Line>(str, 5, color));
   oss.str(std::string());
   oss.clear();
+
+  if (card_height == 5)
+    p->addLine(std::make_unique<door::Line>("     ", 5, color));
+
   oss << "   " << s << r;
   str = oss.str();
   p->addLine(std::make_unique<door::Line>(str, 5, color));
@@ -172,9 +169,11 @@ door::Panel *Deck::back_of(int level) {
   door::Panel *p = new door::Panel(0, 0, 5);
   std::string c = back_char(level);
   std::string l = c + c + c + c + c;
-  p->addLine(std::make_unique<door::Line>(l, 5, cardback));
-  p->addLine(std::make_unique<door::Line>(l, 5, cardback));
-  p->addLine(std::make_unique<door::Line>(l, 5, cardback));
+  for (int x = 0; x < card_height; ++x) {
+    p->addLine(std::make_unique<door::Line>(l, 5, cardback));
+  };
+  // p->addLine(std::make_unique<door::Line>(l, 5, cardback));
+  // p->addLine(std::make_unique<door::Line>(l, 5, cardback));
   return p;
 }
 
@@ -195,8 +194,10 @@ door::Panel *Deck::card(int c) { return cards[c]; }
 door::Panel *Deck::back(int level) { return backs[level]; }
 
 /*
-          1         2         3         4         5         6
-0123456789012345678901234567890123456789012345678901234567890
+Layout spacing 1:
+
+         1         2         3         4         5         6
+123456789012345678901234567890123456789012345678901234567890
          ░░░░░             ░░░░░             ░░░░░
          ░░░░░             ░░░░░             ░░░░░
       ▒▒▒▒▒░▒▒▒▒▒       #####░#####       #####░#####
@@ -206,8 +207,28 @@ door::Panel *Deck::back(int level) { return backs[level]; }
 █████▓█████▓█████▓#####=#####=#####=#####=#####=#####=#####
 █████ █████ █████ ##### ##### ##### ##### ##### ##### #####
 █████ █████ █████ ##### ##### ##### ##### ##### ##### #####
+
+width = 5 * 10 + (1*9) = 59   OK!
+
+Layout with spacing = 2:
+
+            EEEEE
+        ZZZZZ
+    yyyyyZZZyyyyy
+    yyyyy   yyyyy
+XXXXXyyyXXXXXyyyXXXXX
+XXXXX   XXXXX   XXXXX
+
+width = 5 * 10 + (2 * 9) = 50+18 = 68   !  I could do that!
 */
-void cardgo(int pos, int &x, int &y, int &level) {
+void cardgo(int pos, int space, int h, int &x, int &y, int &level) {
+  const int CARD_WIDTH = 5;
+  int HALF_WIDTH = 3;
+  // space = 1 or 3
+  // int space = 1;
+  // space = 3;
+  HALF_WIDTH += space / 2;
+
   /*
 int levels[4] = {3, 6, 9, 10};
 
@@ -221,37 +242,38 @@ int levels[4] = {3, 6, 9, 10};
       }
   }
 */
+  int between = CARD_WIDTH + space;
 
   if (pos < 3) {
     // top
     level = 1;
-    y = (level - 1) * 2 + 1;
-    x = (pos)*18 + 10;
+    y = (level - 1) * (h - 1) + 1;
+    x = pos * (between * 3) + between + HALF_WIDTH + space; // 10
     return;
   } else {
     pos -= 3;
   }
   if (pos < 6) {
     level = 2;
-    y = (level - 1) * 2 + 1;
+    y = (level - 1) * (h - 1) + 1;
     int group = (pos) / 2;
-    x = (pos)*6 + (group * 6) + 7;
+    x = pos * between + (group * between) + CARD_WIDTH + space * 2;
     return;
   } else {
     pos -= 6;
   }
   if (pos < 9) {
     level = 3;
-    y = (level - 1) * 2 + 1;
-    x = (pos)*6 + 4;
+    y = (level - 1) * (h - 1) + 1;
+    x = pos * between + HALF_WIDTH + space;
     return;
   } else {
     pos -= 9;
   }
   if (pos < 10) {
     level = 4;
-    y = (level - 1) * 2 + 1;
-    x = (pos)*6 + 1;
+    y = (level - 1) * (h - 1) + 1;
+    x = (pos)*between + space;
     return;
   } else {
     // something is wrong.

deck.h

@@ -3,6 +3,15 @@
 #include <string>
 #include <vector>
 
+/*
+I tried card_height = 5, but the cards looked a little too stretched out/tall.
+3 looks good.
+
+Spacing 1 or 3.  1 is what was used before, 3 looks better, takes up more
+screenspace.  And I have plenty, even on 80x23.
+
+ */
+
 class Deck {
 private:
   door::ANSIColor cardback;
@@ -16,12 +25,13 @@ private:
   void init(void);
   char rank_symbol(int c);
   std::string suit_symbol(int c);
+  int card_height;
 
 public:
   enum SUIT { HEART, DIAMOND, CLUBS, SPADE };
 
-  Deck();
-  Deck(door::ANSIColor backcolor);
+  Deck(int size = 3);
+  Deck(door::ANSIColor backcolor, int size = 3);
   ~Deck();
 
   door::Panel *card(int c);
@@ -29,4 +39,4 @@ public:
   void part(int x, int y, door::Door &d, int level, bool left);
 };
 
-void cardgo(int pos, int &x, int &y, int &level);
+void cardgo(int pos, int space, int h, int &x, int &y, int &level);

main.cpp

@@ -484,24 +484,41 @@ int main(int argc, char *argv[]) {
     break;
   }
 
-  Deck d(deck_color);
+  int height = 3;
+  Deck d(deck_color, height);
   door::Panel *c;
   door << door::reset << door::cls;
 
   // This displays the cards in the upper left corner.
   // We want them center, and down some.
 
-  // int cards_dealt_width = 59; int cards_delt_height = 9;
-  int off_x = (mx - 59) / 2;
+  int space = 3;
+
+  // int cards_dealt_width = 59; int cards_dealt_height = 9;
+  int game_width;
+  {
+    int cx, cy, level;
+    cardgo(27, space, height, cx, cy, level);
+    game_width = cx + 5; // card width
+  }
+  int off_x = (mx - game_width) / 2;
   int off_y = (my - 9) / 2;
 
+  std::uniform_int_distribution<int> rand_card(0, 51); // 0 - 51
+  std::uniform_int_distribution<int> rand_action(0, 100);
+
   for (int x = 0; x < 28; x++) {
     int cx, cy, level;
-    cardgo(x, cx, cy, level);
-    c = d.back(level);
+    cardgo(x, space, height, cx, cy, level);
+    if (rand_action(rng) > 25) {
+      c = d.back(level);
+    } else {
+      c = d.card(rand_card(rng));
+    }
     c->set(cx + off_x, cy + off_y);
     door << *c;
   }
+  door << door::reset;
   door << door::nl << door::nl;
 
   r = door.sleep_key(door.inactivity);