test/blue.c

   1 /****************************************************************************
   2  * Copyright 2019,2020 Thomas E. Dickey                                     *
   3  * Copyright 1998-2016,2017 Free Software Foundation, Inc.                  *
   4  *                                                                          *
   5  * Permission is hereby granted, free of charge, to any person obtaining a  *
   6  * copy of this software and associated documentation files (the            *
   7  * "Software"), to deal in the Software without restriction, including      *
   8  * without limitation the rights to use, copy, modify, merge, publish,      *
   9  * distribute, distribute with modifications, sublicense, and/or sell       *
  10  * copies of the Software, and to permit persons to whom the Software is    *
  11  * furnished to do so, subject to the following conditions:                 *
  12  *                                                                          *
  13  * The above copyright notice and this permission notice shall be included  *
  14  * in all copies or substantial portions of the Software.                   *
  15  *                                                                          *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
  17  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
  18  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
  19  * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
  20  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
  21  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
  22  * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
  23  *                                                                          *
  24  * Except as contained in this notice, the name(s) of the above copyright   *
  25  * holders shall not be used in advertising or otherwise to promote the     *
  26  * sale, use or other dealings in this Software without prior written       *
  27  * authorization.                                                           *
  28  ****************************************************************************/
  29 /*****************************************************************************
  30  *                                                                           *
  31  *                         B l u e   M o o n                                 *
  32  *                         =================                                 *
  33  *                               V2.2                                        *
  34  *                   A patience game by T.A.Lister                           *
  35  *            Integral screen support by Eric S. Raymond                     *
  36  *                                                                           *
  37  *****************************************************************************/
  38
  39 /*
  40  * $Id: blue.c,v 1.53 2020/02/02 23:34:34 tom Exp $
  41  */
  42
  43 #include <test.priv.h>
  44
  45 #include <time.h>
  46
  47 #if HAVE_LANGINFO_CODESET
  48 #include <langinfo.h>
  49 #endif
  50
  51 #define NOCARD          (-1)
  52
  53 #define ACE             0
  54 #define KING            12
  55 #define SUIT_LENGTH     13
  56
  57 #define HEARTS          0
  58 #define SPADES          1
  59 #define DIAMONDS        2
  60 #define CLUBS           3
  61 #define NSUITS          4
  62
  63 #define GRID_WIDTH      14      /*    13+1  */
  64 #define GRID_LENGTH     56      /* 4*(13+1) */
  65 #define PACK_SIZE       52
  66
  67 #define BASEROW         1
  68 #define PROMPTROW       11
  69
  70 #define RED_ON_WHITE    1
  71 #define BLACK_ON_WHITE  2
  72 #define BLUE_ON_WHITE   3
  73
  74 static void die(int onsig) GCC_NORETURN;
  75
  76 static int deck_size = PACK_SIZE;       /* initial deck */
  77 static int deck[PACK_SIZE];
  78
  79 static int grid[GRID_LENGTH];   /* card layout grid */
  80 static int freeptr[4];          /* free card space pointers */
  81
  82 static int deal_number = 0;
  83
  84 static chtype ranks[SUIT_LENGTH][2] =
  85 {
  86     {' ', 'A'},
  87     {' ', '2'},
  88     {' ', '3'},
  89     {' ', '4'},
  90     {' ', '5'},
  91     {' ', '6'},
  92     {' ', '7'},
  93     {' ', '8'},
  94     {' ', '9'},
  95     {'1', '0'},
  96     {' ', 'J'},
  97     {' ', 'Q'},
  98     {' ', 'K'}
  99 };
 100
 101 static int letters[4] =
 102 {
 103     'h',                        /* hearts */
 104     's',                        /* spades */
 105     'd',                        /* diamonds */
 106     'c',                        /* clubs */
 107 };
 108
 109 #if HAVE_LANGINFO_CODESET
 110
 111 #if HAVE_TIGETSTR
 112 static int glyphs[] =
 113 {
 114     '\003',                     /* hearts */
 115     '\006',                     /* spades */
 116     '\004',                     /* diamonds */
 117     '\005',                     /* clubs */
 118 };
 119 #endif
 120
 121 #if USE_WIDEC_SUPPORT
 122 static int uglyphs[] =
 123 {
 124     0x2665,                     /* hearts */
 125     0x2660,                     /* spades */
 126     0x2666,                     /* diamonds */
 127     0x2663                      /* clubs */
 128 };
 129 #endif
 130 #endif /* HAVE_LANGINFO_CODESET */
 131
 132 static int *suits = letters;    /* this may change to glyphs below */
 133
 134 static void
 135 die(int onsig)
 136 {
 137     (void) signal(onsig, SIG_IGN);
 138     endwin();
 139     ExitProgram(EXIT_SUCCESS);
 140 }
 141
 142 static void
 143 init_vars(void)
 144 {
 145     int i;
 146
 147     deck_size = PACK_SIZE;
 148     for (i = 0; i < PACK_SIZE; i++)
 149         deck[i] = i;
 150     for (i = 0; i < 4; i++)
 151         freeptr[i] = i * GRID_WIDTH;
 152 }
 153
 154 static void
 155 shuffle(int size)
 156 {
 157     int numswaps, swapnum;
 158
 159     numswaps = size * 10;       /* an arbitrary figure */
 160
 161     for (swapnum = 0; swapnum < numswaps; swapnum++) {
 162         int i = rand() % size;
 163         int j = rand() % size;
 164         int temp = deck[i];
 165         deck[i] = deck[j];
 166         deck[j] = temp;
 167     }
 168 }
 169
 170 static void
 171 deal_cards(void)
 172 {
 173     int card = 0, value, csuit, crank, suit, aces[4];
 174
 175     memset(aces, 0, sizeof(aces));
 176     for (suit = HEARTS; suit <= CLUBS; suit++) {
 177         int ptr = freeptr[suit];
 178         grid[ptr++] = NOCARD;   /* 1st card space is blank */
 179         while ((ptr % GRID_WIDTH) != 0) {
 180             value = deck[card++];
 181             crank = value % SUIT_LENGTH;
 182             csuit = value / SUIT_LENGTH;
 183             if (crank == ACE)
 184                 aces[csuit] = ptr;
 185             grid[ptr++] = value;
 186         }
 187     }
 188
 189     if (deal_number == 1)       /* shift the aces down to the 1st column */
 190         for (suit = HEARTS; suit <= CLUBS; suit++) {
 191             grid[suit * GRID_WIDTH] = suit * SUIT_LENGTH;
 192             grid[aces[suit]] = NOCARD;
 193             freeptr[suit] = aces[suit];
 194         }
 195 }
 196
 197 static void
 198 printcard(int value)
 199 {
 200     AddCh(' ');
 201     if (value == NOCARD) {
 202         (void) addstr("   ");
 203     } else {
 204         int which = (value / SUIT_LENGTH);
 205         int isuit = (value % SUIT_LENGTH);
 206         chtype color = (chtype) COLOR_PAIR(((which % 2) == 0)
 207                                            ? RED_ON_WHITE
 208                                            : BLACK_ON_WHITE);
 209
 210         AddCh(ranks[isuit][0] | (chtype) COLOR_PAIR(BLUE_ON_WHITE));
 211         AddCh(ranks[isuit][1] | (chtype) COLOR_PAIR(BLUE_ON_WHITE));
 212
 213 #ifdef NCURSES_VERSION
 214         (attron) ((int) color); /* quieter compiler warnings */
 215 #else
 216         attron(color);          /* PDCurses, etc., either no macro or wrong */
 217 #endif
 218 #if USE_WIDEC_SUPPORT
 219         {
 220             wchar_t values[2];
 221             values[0] = (wchar_t) suits[which];
 222             values[1] = 0;
 223             addwstr(values);
 224         }
 225 #else
 226         AddCh(suits[which]);
 227 #endif
 228 #ifdef NCURSES_VERSION
 229         (attroff) ((int) color);
 230 #else
 231         attroff(color);
 232 #endif
 233     }
 234     AddCh(' ');
 235 }
 236
 237 static void
 238 display_cards(int deal)
 239 {
 240     int row, card;
 241
 242     clear();
 243     (void) printw(
 244                      "Blue Moon 2.1 - by Tim Lister & Eric Raymond - Deal %d.\n",
 245                      deal);
 246     for (row = HEARTS; row <= CLUBS; row++) {
 247         move(BASEROW + row + row + 2, 1);
 248         for (card = 0; card < GRID_WIDTH; card++)
 249             printcard(grid[row * GRID_WIDTH + card]);
 250     }
 251
 252     move(PROMPTROW + 2, 0);
 253     refresh();
 254 #define P(x)    (void)printw("%s\n", x)
 255     P("   This 52-card solitaire starts with  the entire deck shuffled and dealt");
 256     P("out in four rows.  The aces are then moved to the left end of the layout,");
 257     P("making 4 initial free spaces.  You may move to a space only the card that");
 258     P("matches the left neighbor in suit, and is one greater in rank.  Kings are");
 259     P("high, so no cards may be placed to their right (they create dead spaces).");
 260     P("  When no moves can be made,  cards still out of sequence are  reshuffled");
 261     P("and dealt face up after the ends of the partial sequences, leaving a card");
 262     P("space after each sequence, so that each row looks like a partial sequence");
 263     P("followed by a space, followed by enough cards to make a row of 14.       ");
 264     P("  A moment's reflection will show that this game cannot take more than 13");
 265     P("deals. A good score is 1-3 deals, 4-7 is average, 8 or more is poor.     ");
 266 #undef P
 267     refresh();
 268 }
 269
 270 static int
 271 find(int card)
 272 {
 273     int i;
 274
 275     if ((card < 0) || (card >= PACK_SIZE))
 276         return (NOCARD);
 277     for (i = 0; i < GRID_LENGTH; i++)
 278         if (grid[i] == card)
 279             return i;
 280     return (NOCARD);
 281 }
 282
 283 static void
 284 movecard(int src, int dst)
 285 {
 286     grid[dst] = grid[src];
 287     grid[src] = NOCARD;
 288
 289     move(BASEROW + (dst / GRID_WIDTH) * 2 + 2, (dst % GRID_WIDTH) * 5 + 1);
 290     printcard(grid[dst]);
 291
 292     move(BASEROW + (src / GRID_WIDTH) * 2 + 2, (src % GRID_WIDTH) * 5 + 1);
 293     printcard(grid[src]);
 294
 295     refresh();
 296 }
 297
 298 static void
 299 play_game(void)
 300 {
 301     int dead = 0, i, j;
 302     char c;
 303     int selection[4], card;
 304
 305     while (dead < 4) {
 306         dead = 0;
 307         for (i = 0; i < 4; i++) {
 308             card = grid[freeptr[i] - 1];
 309
 310             if (((card % SUIT_LENGTH) == KING)
 311                 ||
 312                 (card == NOCARD))
 313                 selection[i] = NOCARD;
 314             else
 315                 selection[i] = find(card + 1);
 316
 317             if (selection[i] == NOCARD)
 318                 dead++;
 319         };
 320
 321         if (dead < 4) {
 322             char live[NSUITS + 1], *lp = live;
 323
 324             for (i = 0; i < 4; i++) {
 325                 if (selection[i] != NOCARD) {
 326                     move(BASEROW + (selection[i] / GRID_WIDTH) * 2 + 3,
 327                          (selection[i] % GRID_WIDTH) * 5);
 328                     (void) printw("   %c ", (*lp++ = (char) ('a' + i)));
 329                 }
 330             };
 331             *lp = '\0';
 332
 333             if (strlen(live) == 1) {
 334                 move(PROMPTROW, 0);
 335                 (void) printw(
 336                                  "Making forced moves...                                 ");
 337                 refresh();
 338                 (void) sleep(1);
 339                 c = live[0];
 340             } else {
 341                 char buf[BUFSIZ];
 342
 343                 _nc_SPRINTF(buf, _nc_SLIMIT(sizeof(buf))
 344                             "Type [%s] to move, r to redraw, q or INTR to quit: ",
 345                             live);
 346
 347                 do {
 348                     move(PROMPTROW, 0);
 349                     (void) addstr(buf);
 350                     move(PROMPTROW, (int) strlen(buf));
 351                     clrtoeol();
 352                     AddCh(' ');
 353                 } while
 354                     (((c = (char) getch()) < 'a' || c > 'd')
 355                      && (c != 'r')
 356                      && (c != 'q'));
 357             }
 358
 359             for (j = 0; j < 4; j++)
 360                 if (selection[j] != NOCARD) {
 361                     move(BASEROW + (selection[j] / GRID_WIDTH) * 2 + 3,
 362                          (selection[j] % GRID_WIDTH) * 5);
 363                     (void) printw("     ");
 364                 }
 365
 366             if (c == 'r')
 367                 display_cards(deal_number);
 368             else if (c == 'q')
 369                 die(SIGINT);
 370             else {
 371                 i = c - 'a';
 372                 if (selection[i] == NOCARD)
 373                     beep();
 374                 else {
 375                     movecard(selection[i], freeptr[i]);
 376                     freeptr[i] = selection[i];
 377                 }
 378             }
 379         }
 380     }
 381
 382     move(PROMPTROW, 0);
 383     (void) standout();
 384     (void) printw("Finished deal %d - type any character to continue...", deal_number);
 385     (void) standend();
 386     (void) getch();
 387 }
 388
 389 static int
 390 collect_discards(void)
 391 {
 392     int row, col, cardno = 0, gridno;
 393
 394     for (row = HEARTS; row <= CLUBS; row++) {
 395         int finish = 0;
 396         for (col = 1; col < GRID_WIDTH; col++) {
 397             gridno = row * GRID_WIDTH + col;
 398
 399             if ((grid[gridno] != (grid[gridno - 1] + 1)) && (finish == 0)) {
 400                 finish = 1;
 401                 freeptr[row] = gridno;
 402             };
 403
 404             if ((finish != 0) && (grid[gridno] != NOCARD))
 405                 deck[cardno++] = grid[gridno];
 406         }
 407     }
 408     return cardno;
 409 }
 410
 411 static void
 412 game_finished(int deal)
 413 {
 414     clear();
 415     (void) printw("You finished the game in %d deals. This is ", deal);
 416     (void) standout();
 417     if (deal < 2)
 418         (void) addstr("excellent");
 419     else if (deal < 4)
 420         (void) addstr("good");
 421     else if (deal < 8)
 422         (void) addstr("average");
 423     else
 424         (void) addstr("poor");
 425     (void) standend();
 426     (void) addstr(".         ");
 427     refresh();
 428 }
 429
 430 #if HAVE_LANGINFO_CODESET
 431 /*
 432  * This program first appeared in ncurses in January 1995.  At that point, the
 433  * Linux console was able to display CP437 graphic characters, e.g., in the
 434  * range 0-31.  As of 2016, most Linux consoles are running with the UTF-8
 435  * (partial) support.  Incidentally, that makes all of the cards diamonds.
 436  */
 437 static void
 438 use_pc_display(void)
 439 {
 440     char *check = nl_langinfo(CODESET);
 441     if (!strcmp(check, "UTF-8")) {
 442 #if USE_WIDEC_SUPPORT
 443         suits = uglyphs;
 444 #endif
 445     } else {
 446 #if HAVE_TIGETSTR
 447         if (!strcmp(check, "IBM437") ||
 448             !strcmp(check, "CP437") ||
 449             !strcmp(check, "IBM850") ||
 450             !strcmp(check, "CP850")) {
 451             char *smacs = tigetstr("smacs");
 452             char *smpch = tigetstr("smpch");
 453             /*
 454              * The ncurses library makes this check to decide whether to allow
 455              * the alternate character set for the (normally) nonprinting codes.
 456              */
 457             if (smacs != 0 && smpch != 0 && !strcmp(smacs, smpch)) {
 458                 suits = glyphs;
 459             }
 460         }
 461 #endif
 462     }
 463 }
 464 #else
 465 #define use_pc_display()        /* nothing */
 466 #endif /* HAVE_LANGINFO_CODESET */
 467
 468 int
 469 main(int argc, char *argv[])
 470 {
 471     setlocale(LC_ALL, "");
 472
 473     use_pc_display();
 474
 475     InitAndCatch(initscr(), die);
 476
 477     start_color();
 478     init_pair(RED_ON_WHITE, COLOR_RED, COLOR_WHITE);
 479     init_pair(BLUE_ON_WHITE, COLOR_BLUE, COLOR_WHITE);
 480     init_pair(BLACK_ON_WHITE, COLOR_BLACK, COLOR_WHITE);
 481
 482     cbreak();
 483
 484     if (argc == 2)
 485         srand((unsigned) atoi(argv[1]));
 486     else
 487         srand((unsigned) time((time_t *) 0));
 488
 489     init_vars();
 490
 491     do {
 492         deal_number++;
 493         shuffle(deck_size);
 494         deal_cards();
 495         display_cards(deal_number);
 496         play_game();
 497     }
 498     while
 499         ((deck_size = collect_discards()) != 0);
 500
 501     game_finished(deal_number);
 502
 503     die(SIGINT);
 504     /*NOTREACHED */
 505 }
 506
 507 /* blue.c ends here */