![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to canfield.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / games|
Return to canfield.c CVS log | Up to [Research Unix] / researchv10no / games |
1.1 root 1: /* Copyright (c) 1982 Regents of the University of California */
2:
3: static char sccsid[] = "@(#)canfield.c 4.1 10/24/82";
4:
5: /*
6: * The canfield program
7: *
8: * Authors:
9: * Originally written: Steve Levine
10: * Converted to use curses and debugged: Steve Feldman
11: * Card counting: Kirk McKusick and Mikey Olson
12: */
13:
14: #include <curses.h>
15: #include <ctype.h>
16: #include <signal.h>
17:
18: #define decksize 52
19: #define originrow 0
20: #define origincol 0
21: #define basecol 1
22: #define boxcol 42
23: #define tboxrow 2
24: #define bboxrow 16
25: #define movecol 43
26: #define moverow 15
27: #define msgcol 43
28: #define msgrow 14
29: #define titlecol 30
30: #define titlerow 0
31: #define sidecol 1
32: #define ottlrow 6
33: #define foundcol 11
34: #define foundrow 3
35: #define stockcol 2
36: #define stockrow 8
37: #define fttlcol 10
38: #define fttlrow 1
39: #define taloncol 2
40: #define talonrow 13
41: #define tabrow 8
42: #define ctoprow 21
43: #define cbotrow 23
44: #define cinitcol 14
45: #define cheightcol 1
46: #define cwidthcol 4
47: #define handstatrow 21
48: #define handstatcol 7
49: #define talonstatrow 22
50: #define talonstatcol 7
51: #define stockstatrow 23
52: #define stockstatcol 7
53: #define Ace 1
54: #define Jack 11
55: #define Queen 12
56: #define King 13
57: #define atabcol 11
58: #define btabcol 18
59: #define ctabcol 25
60: #define dtabcol 32
61:
62: #define spades 's'
63: #define clubs 'c'
64: #define hearts 'h'
65: #define diamonds 'd'
66: #define black 'b'
67: #define red 'r'
68:
69: #define stk 1
70: #define tal 2
71: #define tab 3
72: #define INCRHAND(row, col) {\
73: row -= cheightcol;\
74: if (row < ctoprow) {\
75: row = cbotrow;\
76: col += cwidthcol;\
77: }\
78: }
79: #define DECRHAND(row, col) {\
80: row += cheightcol;\
81: if (row > cbotrow) {\
82: row = ctoprow;\
83: col -= cwidthcol;\
84: }\
85: }
86:
87:
88: struct cardtype {
89: char suit;
90: char color;
91: bool visible;
92: int rank;
93: struct cardtype *next;
94: };
95:
96: #define NIL ((struct cardtype *) -1)
97:
98: struct cardtype *deck[decksize];
99: struct cardtype cards[decksize];
100: struct cardtype *bottom[4], *found[4], *tableau[4];
101: struct cardtype *talon, *hand, *stock, *basecard;
102: int length[4];
103: int cardsoff, base, cinhand, taloncnt, stockcnt, timesthru;
104: char suitmap[4] = {spades, clubs, hearts, diamonds};
105: char colormap[4] = {black, black, red, red};
106: char pilemap[4] = {atabcol, btabcol, ctabcol, dtabcol};
107: char srcpile, destpile;
108: int mtforigin, tempbase;
109: int coldcol, cnewcol, coldrow, cnewrow;
110: bool errmsg, done;
111: bool mtfdone, Cflag = FALSE;
112:
113:
114:
115: /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
116: * The following procedures print the board onto the screen using the
117: * addressible cursor. The end of these procedures will also be
118: * separated from the rest of the program.
119: */
120: /* procedure to set the move command box */
121: movebox()
122: {
123: move(tboxrow, boxcol);
124: printw("*--------------------------*");
125: move(tboxrow + 1, boxcol);
126: printw("| MOVES |");
127: move(tboxrow + 2, boxcol);
128: printw("|s# = stock to tableau |");
129: move(tboxrow + 3, boxcol);
130: printw("|sf = stock to foundation |");
131: move(tboxrow + 4, boxcol);
132: printw("|t# = talon to tableau |");
133: move(tboxrow + 5, boxcol);
134: printw("|tf = talon to foundation |");
135: move(tboxrow + 6, boxcol);
136: printw("|## = tableau to tableau |");
137: move(tboxrow + 7, boxcol);
138: printw("|#f = tableau to foundation|");
139: move(tboxrow + 8, boxcol);
140: printw("|ht = hand to talon |");
141: move(tboxrow + 9, boxcol);
142: printw("|c = toggle card counting |");
143: move(tboxrow + 10, boxcol);
144: printw("|q = quit to end the game |");
145: move(tboxrow + 11, boxcol);
146: printw("|==========================|");
147: move(moverow, boxcol);
148: printw("| |");
149: move(msgrow, boxcol);
150: printw("| |");
151: move(bboxrow, boxcol);
152: printw("|Replace the # with the |");
153: move(bboxrow + 1, boxcol);
154: printw("|number of the tableau you |");
155: move(bboxrow + 2, boxcol);
156: printw("|want, 1, 2, 3, or 4. |");
157: move(bboxrow + 3, boxcol);
158: printw("*--------------------------*");
159: refresh();
160: }
161:
162: /* procedure to put the board on the screen using addressable cursor */
163: makeboard()
164: {
165: clear();
166: refresh();
167: move(titlerow, titlecol);
168: printw("=-> CANFIELD <-=");
169: move(fttlrow, fttlcol);
170: printw("foundation");
171: move(foundrow - 1, fttlcol);
172: printw("=---= =---= =---= =---=");
173: move(foundrow, fttlcol);
174: printw("| | | | | | | |");
175: move(foundrow + 1, fttlcol);
176: printw("=---= =---= =---= =---=");
177: move(ottlrow, sidecol);
178: printw("stock tableau");
179: move(stockrow - 1, sidecol);
180: printw("=---=");
181: move(stockrow, sidecol);
182: printw("| |");
183: move(stockrow + 1, sidecol);
184: printw("=---=");
185: move(talonrow - 2, sidecol);
186: printw("talon");
187: move(talonrow - 1, sidecol);
188: printw("=---=");
189: move(talonrow, sidecol);
190: printw("| |");
191: move(talonrow + 1, sidecol);
192: printw("=---=");
193: move(tabrow - 1, atabcol);
194: printw("-1- -2- -3- -4-");
195: movebox();
196: }
197: /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
198:
199: /* clean up the board for another game */
200: cleanupboard()
201: {
202: int cnt, row, col;
203: struct cardtype *ptr;
204:
205: if (Cflag) {
206: clearstat();
207: for(ptr = stock, row = stockrow;
208: ptr != NIL;
209: ptr = ptr->next, row++) {
210: move(row, sidecol);
211: printw(" ");
212: }
213: move(row, sidecol);
214: printw(" ");
215: move(stockrow + 1, sidecol);
216: printw("=---=");
217: move(talonrow - 2, sidecol);
218: printw("talon");
219: move(talonrow - 1, sidecol);
220: printw("=---=");
221: move(talonrow + 1, sidecol);
222: printw("=---=");
223: }
224: move(stockrow, sidecol);
225: printw("| |");
226: move(talonrow, sidecol);
227: printw("| |");
228: move(foundrow, fttlcol);
229: printw("| | | | | | | |");
230: for (cnt = 0; cnt < 4; cnt++) {
231: switch(cnt) {
232: case 0:
233: col = atabcol;
234: break;
235: case 1:
236: col = btabcol;
237: break;
238: case 2:
239: col = ctabcol;
240: break;
241: case 3:
242: col = dtabcol;
243: break;
244: }
245: for(ptr = tableau[cnt], row = tabrow;
246: ptr != NIL;
247: ptr = ptr->next, row++)
248: removecard(col, row);
249: }
250: }
251:
252: /* procedure to create a deck of cards */
253: initdeck(deck)
254: struct cardtype *deck[];
255: {
256: int i;
257: int scnt;
258: char s;
259: int r;
260:
261: i = 0;
262: for (scnt=0; scnt<4; scnt++) {
263: s = suitmap[scnt];
264: for (r=Ace; r<=King; r++) {
265: deck[i] = &cards[i];
266: cards[i].rank = r;
267: cards[i].suit = s;
268: cards[i].color = colormap[scnt];
269: cards[i].next = NIL;
270: i++;
271: }
272: }
273: }
274:
275: /* procedure to shuffle the deck */
276: shuffle(deck)
277: struct cardtype *deck[];
278: {
279: int i,j;
280: struct cardtype *temp;
281:
282: for (i=0; i<decksize; i++)
283: deck[i]->visible = FALSE;
284: for (i = decksize-1; i>=0; i--) {
285: j = rand() % decksize;
286: if (i != j) {
287: temp = deck[i];
288: deck[i] = deck[j];
289: deck[j] = temp;
290: }
291: }
292: }
293:
294: /* procedure to remove the card from the board */
295: removecard(a, b)
296: {
297: move(b, a);
298: printw(" ");
299: }
300:
301: /* procedure to print the cards on the board */
302: printrank(a, b, cp)
303: struct cardtype *cp;
304: {
305: move(b, a);
306: switch (cp->rank) {
307: case 2: case 3: case 4: case 5: case 6: case 7:
308: case 8: case 9: case 10:
309: printw("%2d", cp->rank);
310: break;
311: case Ace:
312: printw(" A");
313: break;
314: case Jack:
315: printw(" J");
316: break;
317: case Queen:
318: printw(" Q");
319: break;
320: case King:
321: printw(" K");
322: }
323: }
324:
325: printcard(a, b, cp)
326: int a,b;
327: struct cardtype *cp;
328: {
329: if (cp == NIL)
330: removecard(a, b);
331: else if (cp->visible == FALSE) {
332: move(b, a);
333: printw(" ? ");
334: } else {
335: printrank(a, b, cp);
336: addch(cp->suit);
337: }
338: }
339:
340: /*
341: * procedure to move the top card from one location to the top
342: * of another location. The pointers always point to the top
343: * of the piles.
344: */
345: transit(source, dest)
346: struct cardtype **source, **dest;
347: {
348: struct cardtype *temp;
349:
350: temp = *source;
351: *source = (*source)->next;
352: temp->next = *dest;
353: *dest = temp;
354: }
355:
356: /*
357: * Procedure to set the cards on the foundation base when available.
358: * Note that it is only called on a foundation pile at the beginning of
359: * the game, so the pile will have exactly one card in it.
360: */
361:
362: fndbase(cp, column, row)
363: struct cardtype **cp;
364: {
365: bool nomore;
366:
367: if (*cp != NIL)
368: do {
369: if ((*cp)->rank == basecard->rank) {
370: base++;
371: printcard(pilemap[base], foundrow, *cp);
372: if (*cp == tableau[0])
373: length[0] = length[0] - 1;
374: if (*cp == tableau[1])
375: length[1] = length[1] - 1;
376: if (*cp == tableau[2])
377: length[2] = length[2] - 1;
378: if (*cp == tableau[3])
379: length[3] = length[3] - 1;
380: transit(cp, &found[base]);
381: if (cp == &talon)
382: usedtalon();
383: if (cp == &stock)
384: usedstock();
385: if (*cp != NIL) {
386: printcard(column, row, *cp);
387: nomore = FALSE;
388: } else {
389: removecard(column, row);
390: nomore = TRUE;
391: }
392: cardsoff++;
393: } else
394: nomore = TRUE;
395: } while (nomore == FALSE);
396: }
397:
398: /* procedure to initialize the things necessary for the game */
399: initgame()
400: {
401: register i;
402:
403: for (i=0; i<18; i++)
404: deck[i]->visible = TRUE;
405: stockcnt = 13;
406: stock = deck[12];
407: for (i=12; i>=1; i--)
408: deck[i]->next = deck[i - 1];
409: deck[0]->next = NIL;
410: found[0] = deck[13];
411: deck[13]->next = NIL;
412: for (i=1; i<4; i++)
413: found[i] = NIL;
414: basecard = found[0];
415: for (i=14; i<18; i++) {
416: tableau[i - 14] = deck[i];
417: deck[i]->next = NIL;
418: }
419: for (i=0; i<4; i++) {
420: bottom[i] = tableau[i];
421: length[i] = tabrow;
422: }
423: hand = deck[18];
424: for (i=18; i<decksize-1; i++)
425: deck[i]->next = deck[i + 1];
426: deck[decksize-1]->next = NIL;
427: talon = NIL;
428: base = 0;
429: cinhand = 34;
430: taloncnt = 0;
431: timesthru = 0;
432: cardsoff = 1;
433: coldrow = ctoprow;
434: coldcol = cinitcol;
435: cnewrow = ctoprow;
436: cnewcol = cinitcol + cwidthcol;
437: }
438:
439: /* procedure to print the beginning cards and to start each game */
440: startgame()
441: {
442: register int j;
443:
444: shuffle(deck);
445: initgame();
446: printcard(foundcol, foundrow, found[0]);
447: printcard(stockcol, stockrow, stock);
448: printcard(atabcol, tabrow, tableau[0]);
449: printcard(btabcol, tabrow, tableau[1]);
450: printcard(ctabcol, tabrow, tableau[2]);
451: printcard(dtabcol, tabrow, tableau[3]);
452: printcard(taloncol, talonrow, talon);
453: move(foundrow - 2, basecol);
454: printw("Base");
455: move(foundrow - 1, basecol);
456: printw("Rank");
457: printrank(basecol, foundrow, found[0]);
458: for (j=0; j<=3; j++)
459: fndbase(&tableau[j], pilemap[j], tabrow);
460: fndbase(&stock, stockcol, stockrow);
461: showstat(); /* show card counting info to cheaters */
462: }
463:
464:
465: /* procedure to clear the message printed from an error */
466: clearmsg()
467: {
468: int i;
469:
470: if (errmsg == TRUE) {
471: errmsg = FALSE;
472: move(msgrow, msgcol);
473: for (i=0; i<25; i++)
474: addch(' ');
475: refresh();
476: }
477: }
478:
479: /* procedure to print an error message if the move is not listed */
480: dumberror()
481: {
482: errmsg = TRUE;
483: move(msgrow, msgcol);
484: printw("Not a proper move ");
485: }
486:
487: /* procedure to print an error message if the move is not possible */
488: destinerror()
489: {
490: errmsg = TRUE;
491: move(msgrow, msgcol);
492: printw("Error: Can't move there");
493: }
494:
495: /* function to see if the source has cards in it */
496: bool
497: notempty(cp)
498: struct cardtype *cp;
499: {
500: if (cp == NIL) {
501: errmsg = TRUE;
502: move(msgrow, msgcol);
503: printw("Error: no cards to move");
504: return (FALSE);
505: } else
506: return (TRUE);
507: }
508:
509:
510: /* function to see if the rank of one card is less than another */
511:
512: bool
513: ranklower(cp1, cp2)
514: struct cardtype *cp1, *cp2;
515: {
516: if (cp2->rank == Ace)
517: if (cp1->rank == King)
518: return (TRUE);
519: else
520: return (FALSE);
521: else if (cp1->rank + 1 == cp2->rank)
522: return (TRUE);
523: else
524: return (FALSE);
525: }
526:
527: /* function to check the cardcolor for moving to a tableau */
528: bool
529: diffcolor(cp1, cp2)
530: struct cardtype *cp1, *cp2;
531: {
532: if (cp1->color == cp2->color)
533: return (FALSE);
534: else
535: return (TRUE);
536: }
537:
538: /* function to see if the card can move to the tableau */
539: bool
540: tabok(cp, des)
541: struct cardtype *cp;
542: {
543: if ((cp == stock) && (tableau[des] == NIL))
544: return (TRUE);
545: else if (tableau[des] == NIL)
546: if (stock == NIL)
547: return (TRUE);
548: else
549: return (FALSE);
550: else if (ranklower(cp, tableau[des]) && diffcolor(cp, tableau[des]))
551: return (TRUE);
552: else
553: return (FALSE);
554: }
555:
556:
557: /* procedure to turn the cards onto the talon from the deck */
558: movetotalon()
559: {
560: int i, fin;
561:
562: if (cinhand >= 3)
563: fin = 3;
564: else if (cinhand > 0)
565: fin = cinhand;
566: else if (talon != NIL) {
567: timesthru++;
568: errmsg = TRUE;
569: move(msgrow, msgcol);
570: if (timesthru != 4) {
571: printw("Talon is now the new hand");
572: while (talon != NIL) {
573: transit(&talon, &hand);
574: cinhand++;
575: }
576: if (cinhand >= 3)
577: fin = 3;
578: else
579: fin = cinhand;
580: taloncnt = 0;
581: coldrow = ctoprow;
582: coldcol = cinitcol;
583: cnewrow = ctoprow;
584: cnewcol = cinitcol + cwidthcol;
585: clearstat();
586: showstat();
587: } else {
588: fin = 0;
589: done = TRUE;
590: printw("I believe you have lost");
591: refresh();
592: sleep(5);
593: }
594: } else {
595: errmsg = TRUE;
596: move(msgrow, msgcol);
597: printw("Talon and hand are empty");
598: fin = 0;
599: }
600: for (i=0; i<fin; i++) {
601: transit(&hand, &talon);
602: INCRHAND(cnewrow, cnewcol);
603: INCRHAND(coldrow, coldcol);
604: removecard(cnewcol, cnewrow);
605: if (i == fin - 1)
606: talon->visible = TRUE;
607: if (Cflag)
608: printcard(coldcol, coldrow, talon);
609: }
610: if (fin != 0) {
611: printcard(taloncol, talonrow, talon);
612: cinhand -= fin;
613: taloncnt += fin;
614: if (Cflag) {
615: move(handstatrow, handstatcol);
616: printw("%3d", cinhand);
617: move(talonstatrow, talonstatcol);
618: printw("%3d", taloncnt);
619: }
620: fndbase(&talon, taloncol, talonrow);
621: }
622: }
623:
624:
625: /* procedure to print card counting info on screen */
626: showstat()
627: {
628: int row, col;
629: register struct cardtype *ptr;
630:
631: if (Cflag) {
632: move(talonstatrow, talonstatcol - 7);
633: printw("Talon: %3d", taloncnt);
634: move(handstatrow, handstatcol - 7);
635: printw("Hand: %3d", cinhand);
636: move(stockstatrow, stockstatcol - 7);
637: printw("Stock: %3d", stockcnt);
638: for ( row = coldrow, col = coldcol, ptr = talon;
639: ptr != NIL;
640: ptr = ptr->next ) {
641: printcard(col, row, ptr);
642: DECRHAND(row, col);
643: }
644: for ( row = cnewrow, col = cnewcol, ptr = hand;
645: ptr != NIL;
646: ptr = ptr->next ) {
647: INCRHAND(row, col);
648: printcard(col, row, ptr);
649: }
650: }
651: }
652:
653:
654: /* procedure to clear card counting info from screen */
655: clearstat()
656: {
657: int row;
658:
659: move(talonstatrow, talonstatcol - 7);
660: printw(" ");
661: move(handstatrow, handstatcol - 7);
662: printw(" ");
663: move(stockstatrow, stockstatcol - 7);
664: printw(" ");
665: for ( row = ctoprow ; row <= cbotrow ; row++ ) {
666: move(row, cinitcol);
667: printw("%56s", " ");
668: }
669: }
670:
671:
672: /* procedure to update card counting base */
673: usedtalon()
674: {
675: removecard(coldcol, coldrow);
676: DECRHAND(coldrow, coldcol);
677: if (talon != NIL && (talon->visible == FALSE)) {
678: talon->visible = TRUE;
679: if (Cflag)
680: printcard(coldcol, coldrow, talon);
681: }
682: taloncnt--;
683: if (Cflag) {
684: move(talonstatrow, talonstatcol);
685: printw("%3d", taloncnt);
686: }
687: }
688:
689:
690: /* procedure to update stock card counting base */
691: usedstock()
692: {
693: stockcnt--;
694: if (Cflag) {
695: move(stockstatrow, stockstatcol);
696: printw("%3d", stockcnt);
697: }
698: }
699:
700:
701: /* let 'em know how they lost! */
702: showcards()
703: {
704: register struct cardtype *ptr;
705: int row;
706:
707: if (!Cflag)
708: return;
709: for (ptr = talon; ptr != NIL; ptr = ptr->next)
710: ptr->visible = TRUE;
711: for (ptr = hand; ptr != NIL; ptr = ptr->next)
712: ptr->visible = TRUE;
713: showstat();
714: move(stockrow + 1, sidecol);
715: printw(" ");
716: move(talonrow - 2, sidecol);
717: printw(" ");
718: move(talonrow - 1, sidecol);
719: printw(" ");
720: move(talonrow, sidecol);
721: printw(" ");
722: move(talonrow + 1, sidecol);
723: printw(" ");
724: for (ptr = stock, row = stockrow; ptr != NIL; ptr = ptr->next, row++) {
725: move(row, stockcol - 1);
726: printw("| |");
727: printcard(stockcol, row, ptr);
728: }
729: if (stock == NIL) {
730: move(row, stockcol - 1);
731: printw("| |");
732: row++;
733: }
734: move(handstatrow, handstatcol - 7);
735: printw(" ");
736: move(row, stockcol - 1);
737: printw("=---=");
738: getcmd(moverow, movecol, "Hit return to exit");
739: }
740:
741:
742: /* procedure to move a card from the stock or talon to the tableau */
743: simpletableau(cp, des)
744: struct cardtype **cp;
745: {
746: int origin;
747:
748: if (notempty(*cp)) {
749: if (tabok(*cp, des)) {
750: if (*cp == stock)
751: origin = stk;
752: else
753: origin = tal;
754: if (tableau[des] == NIL)
755: bottom[des] = *cp;
756: transit(cp, &tableau[des]);
757: length[des]++;
758: printcard(pilemap[des], length[des], tableau[des]);
759: timesthru = 0;
760: if (origin == stk) {
761: usedstock();
762: printcard(stockcol, stockrow, stock);
763: } else {
764: usedtalon();
765: printcard(taloncol, talonrow, talon);
766: }
767: } else
768: destinerror();
769: }
770: }
771:
772:
773: tabprint(sour, des)
774: {
775: int dlength, slength, i;
776: struct cardtype *tempcard;
777:
778: for (i=tabrow; i<=length[sour]; i++)
779: removecard(pilemap[sour], i);
780: dlength = length[des] + 1;
781: slength = length[sour];
782: if (slength == tabrow)
783: printcard(pilemap[des], dlength, tableau[sour]);
784: else
785: while (slength != tabrow - 1) {
786: tempcard = tableau[sour];
787: for (i=1; i<=slength-tabrow; i++)
788: tempcard = tempcard->next;
789: printcard(pilemap[des], dlength, tempcard);
790: slength--;
791: dlength++;
792: }
793: }
794:
795: /* procedure to move from the tableau to the tableau */
796: tabtotab(sour, des)
797: {
798: struct cardtype *temp;
799:
800: if (notempty(tableau[sour])) {
801: if (tabok(bottom[sour], des)) {
802: tabprint(sour, des);
803: temp = bottom[sour];
804: bottom[sour] = NIL;
805: temp->next = tableau[des];
806: tableau[des] = tableau[sour];
807: tableau[sour] = NIL;
808: length[des] = length[des] + (length[sour] - (tabrow - 1));
809: length[sour] = tabrow - 1;
810: timesthru = 0;
811: } else
812: destinerror();
813: }
814: }
815:
816:
817: /* functions to see if the card can go onto the foundation */
818: bool
819: rankhigher(cp, let)
820: struct cardtype *cp;
821: {
822: if (found[let]->rank == King)
823: if (cp->rank == Ace)
824: return(TRUE);
825: else
826: return(FALSE);
827: else if (cp->rank - 1 == found[let]->rank)
828: return(TRUE);
829: else
830: return(FALSE);
831: }
832:
833: samesuit(cp, let)
834: struct cardtype *cp;
835: {
836: if (cp->suit == found[let]->suit)
837: return (TRUE);
838: else
839: return (FALSE);
840: }
841:
842: /* procedure to move a card to the correct foundation pile */
843:
844: movetofound(cp, source)
845: struct cardtype **cp;
846: {
847: tempbase = 0;
848: mtfdone = FALSE;
849: if (notempty(*cp)) {
850: do {
851: if (found[tempbase] != NIL)
852: if (rankhigher(*cp, tempbase)
853: && samesuit(*cp, tempbase)) {
854: if (*cp == stock)
855: mtforigin = stk;
856: else if (*cp == talon)
857: mtforigin = tal;
858: else
859: mtforigin = tab;
860: transit(cp, &found[tempbase]);
861: printcard(pilemap[tempbase],
862: foundrow, found[tempbase]);
863: timesthru = 0;
864: if (mtforigin == stk) {
865: usedstock();
866: printcard(stockcol, stockrow, stock);
867: } else if (mtforigin == tal) {
868: usedtalon();
869: printcard(taloncol, talonrow, talon);
870: } else {
871: removecard(pilemap[source], length[source]);
872: length[source]--;
873: }
874: cardsoff++;
875: mtfdone = TRUE;
876: } else
877: tempbase++;
878: else
879: tempbase++;
880: } while ((tempbase != 4) && !mtfdone);
881: if (!mtfdone)
882: destinerror();
883: }
884: }
885:
886:
887: /* procedure to get a command */
888:
889: getcmd(row, col, cp)
890: int row, col;
891: char *cp;
892: {
893: char cmd[2], ch;
894: int i;
895:
896: i = 0;
897: move(row, col);
898: printw("%-24s", cp);
899: col += 1 + strlen(cp);
900: move(row, col);
901: refresh();
902: do {
903: ch = getch() & 0177;
904: if (ch >= 'A' && ch <= 'Z')
905: ch += ('a' - 'A');
906: if (ch == '\f') {
907: wrefresh(curscr);
908: refresh();
909: } else if (i >= 2 && ch != _tty.sg_erase && ch != _tty.sg_kill) {
910: if (ch != '\n' && ch != '\r' && ch != ' ')
911: write(1, "\007", 1);
912: } else if (ch == _tty.sg_erase && i > 0) {
913: printw("\b \b");
914: refresh();
915: i--;
916: } else if (ch == _tty.sg_kill && i > 0) {
917: while (i > 0) {
918: printw("\b \b");
919: i--;
920: }
921: refresh();
922: } else if (ch == '\032') { /* Control-Z */
923: suspend();
924: move(row, col + i);
925: refresh();
926: } else if (isprint(ch)) {
927: cmd[i++] = ch;
928: addch(ch);
929: refresh();
930: }
931: } while (ch != '\n' && ch != '\r' && ch != ' ');
932: srcpile = cmd[0];
933: destpile = cmd[1];
934: }
935:
936: /* Suspend the game (shell escape if no process control on system) */
937:
938: suspend()
939: {
940: #ifndef SIGTSTP
941: char *sh;
942: #endif
943:
944: move(21, 0);
945: refresh();
946: endwin();
947: fflush(stdout);
948: #ifdef SIGTSTP
949: kill(getpid(), SIGTSTP);
950: #else
951: sh = getenv("SHELL");
952: if (sh == NULL)
953: sh = "/bin/sh";
954: system(sh);
955: #endif
956: raw();
957: noecho();
958: }
959:
960: /* procedure to evaluate and make the specific moves */
961:
962: movecard()
963: {
964: int source, dest;
965:
966: done = FALSE;
967: errmsg = FALSE;
968: do {
969: if (cardsoff == 52) {
970: refresh();
971: srcpile = 'q';
972: } else
973: getcmd(moverow, movecol, "Move:");
974: clearmsg();
975: if (srcpile >= '1' && srcpile <= '4')
976: source = (int) (srcpile - '1');
977: if (destpile >= '1' && destpile <= '4')
978: dest = (int) (destpile - '1');
979: switch (srcpile) {
980: case 't':
981: if (destpile == 'f' || destpile == 'F')
982: movetofound(&talon, source);
983: else if (destpile >= '1' && destpile <= '4')
984: simpletableau(&talon, dest);
985: else
986: dumberror();
987: break;
988: case 's':
989: if (destpile == 'f' || destpile == 'F')
990: movetofound(&stock, source);
991: else if (destpile >= '1' && destpile <= '4')
992: simpletableau(&stock, dest);
993: else dumberror();
994: break;
995: case 'h':
996: if (destpile == 't' || destpile == 'T')
997: movetotalon();
998: else dumberror();
999: break;
1000: case 'q':
1001: showcards();
1002: done = TRUE;
1003: break;
1004: case 'c':
1005: Cflag = !Cflag;
1006: if (Cflag)
1007: showstat();
1008: else
1009: clearstat();
1010: break;
1011: case '1': case '2': case '3': case '4':
1012: if (destpile == 'f' || destpile == 'F')
1013: movetofound(&tableau[source], source);
1014: else if (destpile >= '1' && destpile <= '4')
1015: tabtotab(source, dest);
1016: else dumberror();
1017: break;
1018: default:
1019: dumberror();
1020: }
1021: fndbase(&stock, stockcol, stockrow);
1022: fndbase(&talon, taloncol, talonrow);
1023: } while (!done);
1024: }
1025:
1026: /* procedure to printout instructions */
1027: instruct()
1028: {
1029: move(originrow, origincol);
1030: printw("This is the game of solitaire called Canfield. Do\n");
1031: printw("you want instructions for the game?");
1032: do {
1033: getcmd(originrow + 3, origincol, "y or n?");
1034: } while (srcpile != 'y' && srcpile != 'n');
1035: if (srcpile == 'y') {
1036: clear();
1037: refresh();
1038: printw("Here are brief instuctions to the game of Canfield:\n");
1039: printw("\n");
1040: printw(" If you have never played solitaire before, it is recom-\n");
1041: printw("mended that you consult a solitaire instruction book. In\n");
1042: printw("Canfield, tableau cards may be built on each other downward\n");
1043: printw("in alternate colors. An entire pile must be moved as a unit\n");
1044: printw("in building. Top cards of the piles are available to be able\n");
1045: printw("to be played on foundations, but never into empty spaces.\n");
1046: printw("\n");
1047: printw(" Spaces must be filled from the stock. The top card of\n");
1048: printw("the stock also is available to be played on foundations or\n");
1049: printw("built on tableau piles. After the stock is exhausted, ta-\n");
1050: printw("bleau spaces may be filled from the talon and the player may\n");
1051: printw("keep them open until he wishes to use them.\n");
1052: printw("\n");
1053: printw(" Cards are dealt from the hand to the talon by threes\n");
1054: printw("and this repeats until there are no more cards in the hand\n");
1055: printw("or the player quits. To have cards dealt onto the talon the\n");
1056: printw("player types 'ht' for his move. Foundation base cards are\n");
1057: printw("also automatically moved to the foundation when they become\n");
1058: printw("available.\n\n");
1059: printw("push any key when you are finished: ");
1060: refresh();
1061: getch();
1062: }
1063: }
1064:
1065: /* procedure to initialize the game */
1066: initall()
1067:
1068: {
1069: srand(getpid());
1070: initdeck(deck);
1071: }
1072:
1073: /* procedure to end the game */
1074: bool
1075: finish()
1076: {
1077: int row, col;
1078:
1079: if (cardsoff == 52) {
1080: clear();
1081: refresh();
1082: move(originrow, origincol);
1083: printw("CONGRATULATIONS!\n");
1084: printw("You won the game. That is a feat to be proud of.\n");
1085: move(originrow + 4, origincol);
1086: printw("Wish to play again? ");
1087: row = originrow + 5;
1088: col = origincol;
1089: } else {
1090: move(msgrow, msgcol);
1091: printw("You got %d card", cardsoff);
1092: if (cardsoff > 1)
1093: printw("s");
1094: printw(" off ");
1095: getcmd(moverow, movecol, "Hit return to continue");
1096: move(msgrow, msgcol);
1097: printw("Wish to play again? ");
1098: row = moverow;
1099: col = movecol;
1100: }
1101: do {
1102: getcmd(row, col, "y or n?");
1103: } while (srcpile != 'y' && srcpile != 'n');
1104: errmsg = TRUE;
1105: clearmsg();
1106: if (srcpile == 'y')
1107: return (FALSE);
1108: else
1109: return (TRUE);
1110: }
1111:
1112: main(argc, argv)
1113: int argc;
1114: char *argv[];
1115: {
1116: #ifdef MAXLOAD
1117: double vec[3];
1118:
1119: loadav(vec);
1120: if (vec[2] >= MAXLOAD) {
1121: puts("The system load is too high. Try again later.");
1122: exit(0);
1123: }
1124: #endif
1125: initscr();
1126: raw();
1127: noecho();
1128: initall();
1129: instruct();
1130: makeboard();
1131: for (;;) {
1132: startgame();
1133: movecard();
1134: if (finish())
1135: break;
1136: if (cardsoff == 52)
1137: makeboard();
1138: else
1139: cleanupboard();
1140: }
1141: clear();
1142: move(22,0);
1143: refresh();
1144: endwin();
1145: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.