ncurses 6.1 - patch 20180127
[ncurses.git] / test / blue.c
1 /****************************************************************************
2  * Copyright (c) 1998-2016,2017 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  * $Id: blue.c,v 1.51 2017/09/30 17:43:18 tom Exp $
40  */
41
42 #include <test.priv.h>
43
44 #include <time.h>
45
46 #if HAVE_LANGINFO_CODESET
47 #include <langinfo.h>
48 #endif
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 static int letters[4] =
101 {
102     'h',                        /* hearts */
103     's',                        /* spades */
104     'd',                        /* diamonds */
105     'c',                        /* clubs */
106 };
107
108 #if HAVE_LANGINFO_CODESET
109
110 #if HAVE_TIGETSTR
111 static int glyphs[] =
112 {
113     '\003',                     /* hearts */
114     '\006',                     /* spades */
115     '\004',                     /* diamonds */
116     '\005',                     /* clubs */
117 };
118 #endif
119
120 #if USE_WIDEC_SUPPORT
121 static int uglyphs[] =
122 {
123     0x2665,                     /* hearts */
124     0x2660,                     /* spades */
125     0x2666,                     /* diamonds */
126     0x2663                      /* clubs */
127 };
128 #endif
129 #endif /* HAVE_LANGINFO_CODESET */
130
131 static int *suits = letters;    /* this may change to glyphs below */
132
133 static void
134 die(int onsig)
135 {
136     (void) signal(onsig, SIG_IGN);
137     endwin();
138     ExitProgram(EXIT_SUCCESS);
139 }
140
141 static void
142 init_vars(void)
143 {
144     int i;
145
146     deck_size = PACK_SIZE;
147     for (i = 0; i < PACK_SIZE; i++)
148         deck[i] = i;
149     for (i = 0; i < 4; i++)
150         freeptr[i] = i * GRID_WIDTH;
151 }
152
153 static void
154 shuffle(int size)
155 {
156     int i, j, numswaps, swapnum, temp;
157
158     numswaps = size * 10;       /* an arbitrary figure */
159
160     for (swapnum = 0; swapnum < numswaps; swapnum++) {
161         i = rand() % size;
162         j = rand() % size;
163         temp = deck[i];
164         deck[i] = deck[j];
165         deck[j] = temp;
166     }
167 }
168
169 static void
170 deal_cards(void)
171 {
172     int ptr, card = 0, value, csuit, crank, suit, aces[4];
173
174     memset(aces, 0, sizeof(aces));
175     for (suit = HEARTS; suit <= CLUBS; suit++) {
176         ptr = freeptr[suit];
177         grid[ptr++] = NOCARD;   /* 1st card space is blank */
178         while ((ptr % GRID_WIDTH) != 0) {
179             value = deck[card++];
180             crank = value % SUIT_LENGTH;
181             csuit = value / SUIT_LENGTH;
182             if (crank == ACE)
183                 aces[csuit] = ptr;
184             grid[ptr++] = value;
185         }
186     }
187
188     if (deal_number == 1)       /* shift the aces down to the 1st column */
189         for (suit = HEARTS; suit <= CLUBS; suit++) {
190             grid[suit * GRID_WIDTH] = suit * SUIT_LENGTH;
191             grid[aces[suit]] = NOCARD;
192             freeptr[suit] = aces[suit];
193         }
194 }
195
196 static void
197 printcard(int value)
198 {
199     AddCh(' ');
200     if (value == NOCARD) {
201         (void) addstr("   ");
202     } else {
203         int which = (value / SUIT_LENGTH);
204         int isuit = (value % SUIT_LENGTH);
205         chtype color = (chtype) COLOR_PAIR(((which % 2) == 0)
206                                            ? RED_ON_WHITE
207                                            : BLACK_ON_WHITE);
208
209         AddCh(ranks[isuit][0] | (chtype) COLOR_PAIR(BLUE_ON_WHITE));
210         AddCh(ranks[isuit][1] | (chtype) COLOR_PAIR(BLUE_ON_WHITE));
211
212 #ifdef NCURSES_VERSION
213         (attron) ((int) color); /* quieter compiler warnings */
214 #else
215         attron(color);          /* PDCurses, etc., either no macro or wrong */
216 #endif
217 #if USE_WIDEC_SUPPORT
218         {
219             wchar_t values[2];
220             values[0] = (wchar_t) suits[which];
221             values[1] = 0;
222             addwstr(values);
223         }
224 #else
225         AddCh(suits[which]);
226 #endif
227 #ifdef NCURSES_VERSION
228         (attroff) ((int) color);
229 #else
230         attroff(color);
231 #endif
232     }
233     AddCh(' ');
234 }
235
236 static void
237 display_cards(int deal)
238 {
239     int row, card;
240
241     clear();
242     (void) printw(
243                      "Blue Moon 2.1 - by Tim Lister & Eric Raymond - Deal %d.\n",
244                      deal);
245     for (row = HEARTS; row <= CLUBS; row++) {
246         move(BASEROW + row + row + 2, 1);
247         for (card = 0; card < GRID_WIDTH; card++)
248             printcard(grid[row * GRID_WIDTH + card]);
249     }
250
251     move(PROMPTROW + 2, 0);
252     refresh();
253 #define P(x)    (void)printw("%s\n", x)
254     P("   This 52-card solitaire starts with  the entire deck shuffled and dealt");
255     P("out in four rows.  The aces are then moved to the left end of the layout,");
256     P("making 4 initial free spaces.  You may move to a space only the card that");
257     P("matches the left neighbor in suit, and is one greater in rank.  Kings are");
258     P("high, so no cards may be placed to their right (they create dead spaces).");
259     P("  When no moves can be made,  cards still out of sequence are  reshuffled");
260     P("and dealt face up after the ends of the partial sequences, leaving a card");
261     P("space after each sequence, so that each row looks like a partial sequence");
262     P("followed by a space, followed by enough cards to make a row of 14.       ");
263     P("  A moment's reflection will show that this game cannot take more than 13");
264     P("deals. A good score is 1-3 deals, 4-7 is average, 8 or more is poor.     ");
265 #undef P
266     refresh();
267 }
268
269 static int
270 find(int card)
271 {
272     int i;
273
274     if ((card < 0) || (card >= PACK_SIZE))
275         return (NOCARD);
276     for (i = 0; i < GRID_LENGTH; i++)
277         if (grid[i] == card)
278             return i;
279     return (NOCARD);
280 }
281
282 static void
283 movecard(int src, int dst)
284 {
285     grid[dst] = grid[src];
286     grid[src] = NOCARD;
287
288     move(BASEROW + (dst / GRID_WIDTH) * 2 + 2, (dst % GRID_WIDTH) * 5 + 1);
289     printcard(grid[dst]);
290
291     move(BASEROW + (src / GRID_WIDTH) * 2 + 2, (src % GRID_WIDTH) * 5 + 1);
292     printcard(grid[src]);
293
294     refresh();
295 }
296
297 static void
298 play_game(void)
299 {
300     int dead = 0, i, j;
301     char c;
302     int selection[4], card;
303
304     while (dead < 4) {
305         dead = 0;
306         for (i = 0; i < 4; i++) {
307             card = grid[freeptr[i] - 1];
308
309             if (((card % SUIT_LENGTH) == KING)
310                 ||
311                 (card == NOCARD))
312                 selection[i] = NOCARD;
313             else
314                 selection[i] = find(card + 1);
315
316             if (selection[i] == NOCARD)
317                 dead++;
318         };
319
320         if (dead < 4) {
321             char live[NSUITS + 1], *lp = live;
322
323             for (i = 0; i < 4; i++) {
324                 if (selection[i] != NOCARD) {
325                     move(BASEROW + (selection[i] / GRID_WIDTH) * 2 + 3,
326                          (selection[i] % GRID_WIDTH) * 5);
327                     (void) printw("   %c ", (*lp++ = (char) ('a' + i)));
328                 }
329             };
330             *lp = '\0';
331
332             if (strlen(live) == 1) {
333                 move(PROMPTROW, 0);
334                 (void) printw(
335                                  "Making forced moves...                                 ");
336                 refresh();
337                 (void) sleep(1);
338                 c = live[0];
339             } else {
340                 char buf[BUFSIZ];
341
342                 _nc_SPRINTF(buf, _nc_SLIMIT(sizeof(buf))
343                             "Type [%s] to move, r to redraw, q or INTR to quit: ",
344                             live);
345
346                 do {
347                     move(PROMPTROW, 0);
348                     (void) addstr(buf);
349                     move(PROMPTROW, (int) strlen(buf));
350                     clrtoeol();
351                     AddCh(' ');
352                 } while
353                     (((c = (char) getch()) < 'a' || c > 'd')
354                      && (c != 'r')
355                      && (c != 'q'));
356             }
357
358             for (j = 0; j < 4; j++)
359                 if (selection[j] != NOCARD) {
360                     move(BASEROW + (selection[j] / GRID_WIDTH) * 2 + 3,
361                          (selection[j] % GRID_WIDTH) * 5);
362                     (void) printw("     ");
363                 }
364
365             if (c == 'r')
366                 display_cards(deal_number);
367             else if (c == 'q')
368                 die(SIGINT);
369             else {
370                 i = c - 'a';
371                 if (selection[i] == NOCARD)
372                     beep();
373                 else {
374                     movecard(selection[i], freeptr[i]);
375                     freeptr[i] = selection[i];
376                 }
377             }
378         }
379     }
380
381     move(PROMPTROW, 0);
382     (void) standout();
383     (void) printw("Finished deal %d - type any character to continue...", deal_number);
384     (void) standend();
385     (void) getch();
386 }
387
388 static int
389 collect_discards(void)
390 {
391     int row, col, cardno = 0, finish, gridno;
392
393     for (row = HEARTS; row <= CLUBS; row++) {
394         finish = 0;
395         for (col = 1; col < GRID_WIDTH; col++) {
396             gridno = row * GRID_WIDTH + col;
397
398             if ((grid[gridno] != (grid[gridno - 1] + 1)) && (finish == 0)) {
399                 finish = 1;
400                 freeptr[row] = gridno;
401             };
402
403             if ((finish != 0) && (grid[gridno] != NOCARD))
404                 deck[cardno++] = grid[gridno];
405         }
406     }
407     return cardno;
408 }
409
410 static void
411 game_finished(int deal)
412 {
413     clear();
414     (void) printw("You finished the game in %d deals. This is ", deal);
415     (void) standout();
416     if (deal < 2)
417         (void) addstr("excellent");
418     else if (deal < 4)
419         (void) addstr("good");
420     else if (deal < 8)
421         (void) addstr("average");
422     else
423         (void) addstr("poor");
424     (void) standend();
425     (void) addstr(".         ");
426     refresh();
427 }
428
429 #if HAVE_LANGINFO_CODESET
430 /*
431  * This program first appeared in ncurses in January 1995.  At that point, the
432  * Linux console was able to display CP437 graphic characters, e.g., in the
433  * range 0-31.  As of 2016, most Linux consoles are running with the UTF-8
434  * (partial) support.  Incidentally, that makes all of the cards diamonds.
435  */
436 static void
437 use_pc_display(void)
438 {
439     char *check = nl_langinfo(CODESET);
440     if (!strcmp(check, "UTF-8")) {
441 #if USE_WIDEC_SUPPORT
442         suits = uglyphs;
443 #endif
444     } else {
445 #if HAVE_TIGETSTR
446         if (!strcmp(check, "IBM437") ||
447             !strcmp(check, "CP437") ||
448             !strcmp(check, "IBM850") ||
449             !strcmp(check, "CP850")) {
450             char *smacs = tigetstr("smacs");
451             char *smpch = tigetstr("smpch");
452             /*
453              * The ncurses library makes this check to decide whether to allow
454              * the alternate character set for the (normally) nonprinting codes.
455              */
456             if (smacs != 0 && smpch != 0 && !strcmp(smacs, smpch)) {
457                 suits = glyphs;
458             }
459         }
460 #endif
461     }
462 }
463 #else
464 #define use_pc_display()        /* nothing */
465 #endif /* HAVE_LANGINFO_CODESET */
466
467 int
468 main(int argc, char *argv[])
469 {
470     setlocale(LC_ALL, "");
471
472     use_pc_display();
473
474     InitAndCatch(initscr(), die);
475
476     start_color();
477     init_pair(RED_ON_WHITE, COLOR_RED, COLOR_WHITE);
478     init_pair(BLUE_ON_WHITE, COLOR_BLUE, COLOR_WHITE);
479     init_pair(BLACK_ON_WHITE, COLOR_BLACK, COLOR_WHITE);
480
481     cbreak();
482
483     if (argc == 2)
484         srand((unsigned) atoi(argv[1]));
485     else
486         srand((unsigned) time((time_t *) 0));
487
488     init_vars();
489
490     do {
491         deal_number++;
492         shuffle(deck_size);
493         deal_cards();
494         display_cards(deal_number);
495         play_game();
496     }
497     while
498         ((deck_size = collect_discards()) != 0);
499
500     game_finished(deal_number);
501
502     die(SIGINT);
503     /*NOTREACHED */
504 }
505
506 /* blue.c ends here */