test/blue.c

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