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