Clean up:
[dragonfly.git] / games / cribbage / support.c
1 /*-
2  * Copyright (c) 1980, 1993
3  *      The Regents of the University of California.  All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  * 3. All advertising materials mentioning features or use of this software
14  *    must display the following acknowledgement:
15  *      This product includes software developed by the University of
16  *      California, Berkeley and its contributors.
17  * 4. Neither the name of the University nor the names of its contributors
18  *    may be used to endorse or promote products derived from this software
19  *    without specific prior written permission.
20  *
21  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31  * SUCH DAMAGE.
32  *
33  * @(#)support.c        8.1 (Berkeley) 5/31/93
34  * $FreeBSD: src/games/cribbage/support.c,v 1.5 1999/12/12 03:04:15 billf Exp $
35  * $DragonFly: src/games/cribbage/support.c,v 1.2 2003/06/17 04:25:23 dillon Exp $
36  */
37
38 #include <curses.h>
39 #include <string.h>
40
41 #include "deck.h"
42 #include "cribbage.h"
43 #include "cribcur.h"
44
45 #define NTV     10              /* number scores to test */
46
47 /* score to test reachability of, and order to test them in */
48 int tv[NTV] = {8, 7, 9, 6, 11, 12, 13, 14, 10, 5};
49
50 /*
51  * computer chooses what to play in pegging...
52  * only called if no playable card will score points
53  */
54 int
55 cchose(h, n, s)
56         CARD h[];
57         int n, s;
58 {
59         int i, j, l;
60
61         if (n <= 1)
62                 return (0);
63         if (s < 4) {            /* try for good value */
64                 if ((j = anysumto(h, n, s, 4)) >= 0)
65                         return (j);
66                 if ((j = anysumto(h, n, s, 3)) >= 0 && s == 0)
67                         return (j);
68         }
69         if (s > 0 && s < 20) {
70                                 /* try for retaliation to 31 */
71                 for (i = 1; i <= 10; i++) {
72                         if ((j = anysumto(h, n, s, 21 - i)) >= 0) {
73                                 if ((l = numofval(h, n, i)) > 0) {
74                                         if (l > 1 || VAL(h[j].rank) != i)
75                                                 return (j);
76                                 }
77                         }
78                 }
79         }
80         if (s < 15) {
81                                 /* for retaliation after 15 */
82                 for (i = 0; i < NTV; i++) {
83                         if ((j = anysumto(h, n, s, tv[i])) >= 0) {
84                                 if ((l = numofval(h, n, 15 - tv[i])) > 0) {
85                                         if (l > 1 ||
86                                             VAL(h[j].rank) != 15 - tv[i])
87                                                 return (j);
88                                 }
89                         }
90                 }
91         }
92         j = -1;
93                                 /* remember: h is sorted */
94         for (i = n - 1; i >= 0; --i) {
95                 l = s + VAL(h[i].rank);
96                 if (l > 31)
97                         continue;
98                 if (l != 5 && l != 10 && l != 21) {
99                         j = i;
100                         break;
101                 }
102         }
103         if (j >= 0)
104                 return (j);
105         for (i = n - 1; i >= 0; --i) {
106                 l = s + VAL(h[i].rank);
107                 if (l > 31)
108                         continue;
109                 if (j < 0)
110                         j = i;
111                 if (l != 5 && l != 21) {
112                         j = i;
113                         break;
114                 }
115         }
116         return (j);
117 }
118
119 /*
120  * plyrhand:
121  *      Evaluate and score a player hand or crib
122  */
123 int
124 plyrhand(hand, s)
125         CARD    hand[];
126         char   *s;
127 {
128         static char prompt[BUFSIZ];
129         int i, j;
130         BOOLEAN win;
131
132         prhand(hand, CINHAND, Playwin, FALSE);
133         (void) sprintf(prompt, "Your %s scores ", s);
134         i = scorehand(hand, turnover, CINHAND, strcmp(s, "crib") == 0, explain);
135         if ((j = number(0, 29, prompt)) == 19)
136                 j = 0;
137         if (i != j) {
138                 if (i < j) {
139                         win = chkscr(&pscore, i);
140                         msg("It's really only %d points; I get %d", i, 2);
141                         if (!win)
142                                 win = chkscr(&cscore, 2);
143                 } else {
144                         win = chkscr(&pscore, j);
145                         msg("You should have taken %d, not %d!", i, j);
146                 }
147                 if (explain)
148                         msg("Explanation: %s", expl);
149                 do_wait();
150         } else
151                 win = chkscr(&pscore, i);
152         return (win);
153 }
154
155 /*
156  * comphand:
157  *      Handle scoring and displaying the computers hand
158  */
159 int
160 comphand(h, s)
161         CARD h[];
162         char *s;
163 {
164         int j;
165
166         j = scorehand(h, turnover, CINHAND, strcmp(s, "crib") == 0, FALSE);
167         prhand(h, CINHAND, Compwin, FALSE);
168         msg("My %s scores %d", s, (j == 0 ? 19 : j));
169         return (chkscr(&cscore, j));
170 }
171
172 /*
173  * chkscr:
174  *      Add inc to scr and test for > glimit, printing on the scoring
175  *      board while we're at it.
176  */
177 int Lastscore[2] = {-1, -1};
178
179 int
180 chkscr(scr, inc)
181         int    *scr, inc;
182 {
183         BOOLEAN myturn;
184
185         myturn = (scr == &cscore);
186         if (inc != 0) {
187                 prpeg(Lastscore[myturn ? 1 : 0], '.', myturn);
188                 Lastscore[myturn ? 1 : 0] = *scr;
189                 *scr += inc;
190                 prpeg(*scr, PEG, myturn);
191                 refresh();
192         }
193         return (*scr >= glimit);
194 }
195
196 /*
197  * prpeg:
198  *      Put out the peg character on the score board and put the
199  *      score up on the board.
200  */
201 void
202 prpeg(score, peg, myturn)
203         int score;
204         int peg;
205         BOOLEAN myturn;
206 {
207         int y, x;
208
209         if (!myturn)
210                 y = SCORE_Y + 2;
211         else
212                 y = SCORE_Y + 5;
213
214         if (score <= 0 || score >= glimit) {
215                 if (peg == '.')
216                         peg = ' ';
217                 if (score == 0)
218                         x = SCORE_X + 2;
219                 else {
220                         x = SCORE_X + 2;
221                         y++;
222                 }
223         } else {
224                 x = (score - 1) % 30;
225                 if (score > 90 || (score > 30 && score <= 60)) {
226                         y++;
227                         x = 29 - x;
228                 }
229                 x += x / 5;
230                 x += SCORE_X + 3;
231         }
232         mvaddch(y, x, peg);
233         mvprintw(SCORE_Y + (myturn ? 7 : 1), SCORE_X + 10, "%3d", score);
234 }
235
236 /*
237  * cdiscard -- the computer figures out what is the best discard for
238  * the crib and puts the best two cards at the end
239  */
240 void
241 cdiscard(mycrib)
242         BOOLEAN mycrib;
243 {
244         CARD    d[CARDS], h[FULLHAND], cb[2];
245         int i, j, k;
246         int     nc, ns;
247         long    sums[15];
248         static int undo1[15] = {0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 3, 3, 4};
249         static int undo2[15] = {1, 2, 3, 4, 5, 2, 3, 4, 5, 3, 4, 5, 4, 5, 5};
250
251         makedeck(d);
252         nc = CARDS;
253         for (i = 0; i < knownum; i++) { /* get all other cards */
254                 cremove(known[i], d, nc--);
255         }
256         for (i = 0; i < 15; i++)
257                 sums[i] = 0L;
258         ns = 0;
259         for (i = 0; i < (FULLHAND - 1); i++) {
260                 cb[0] = chand[i];
261                 for (j = i + 1; j < FULLHAND; j++) {
262                         cb[1] = chand[j];
263                         for (k = 0; k < FULLHAND; k++)
264                                 h[k] = chand[k];
265                         cremove(chand[i], h, FULLHAND);
266                         cremove(chand[j], h, FULLHAND - 1);
267                         for (k = 0; k < nc; k++) {
268                                 sums[ns] +=
269                                     scorehand(h, d[k], CINHAND, TRUE, FALSE);
270                                 if (mycrib)
271                                         sums[ns] += adjust(cb, d[k]);
272                                 else
273                                         sums[ns] -= adjust(cb, d[k]);
274                         }
275                         ++ns;
276                 }
277         }
278         j = 0;
279         for (i = 1; i < 15; i++)
280                 if (sums[i] > sums[j])
281                         j = i;
282         for (k = 0; k < FULLHAND; k++)
283                 h[k] = chand[k];
284         cremove(h[undo1[j]], chand, FULLHAND);
285         cremove(h[undo2[j]], chand, FULLHAND - 1);
286         chand[4] = h[undo1[j]];
287         chand[5] = h[undo2[j]];
288 }
289
290 /*
291  * returns true if some card in hand can be played without exceeding 31
292  */
293 int
294 anymove(hand, n, sum)
295         CARD hand[];
296         int n, sum;
297 {
298         int i, j;
299
300         if (n < 1)
301                 return (FALSE);
302         j = hand[0].rank;
303         for (i = 1; i < n; i++) {
304                 if (hand[i].rank < j)
305                         j = hand[i].rank;
306         }
307         return (sum + VAL(j) <= 31);
308 }
309
310 /*
311  * anysumto returns the index (0 <= i < n) of the card in hand that brings
312  * the s up to t, or -1 if there is none
313  */
314 int
315 anysumto(hand, n, s, t)
316         CARD hand[];
317         int n, s, t;
318 {
319         int i;
320
321         for (i = 0; i < n; i++) {
322                 if (s + VAL(hand[i].rank) == t)
323                         return (i);
324         }
325         return (-1);
326 }
327
328 /*
329  * return the number of cards in h having the given rank value
330  */
331 int
332 numofval(h, n, v)
333         CARD h[];
334         int n, v;
335 {
336         int i, j;
337
338         j = 0;
339         for (i = 0; i < n; i++) {
340                 if (VAL(h[i].rank) == v)
341                         ++j;
342         }
343         return (j);
344 }
345
346 /*
347  * makeknown remembers all n cards in h for future recall
348  */
349 void
350 makeknown(h, n)
351         CARD h[];
352         int n;
353 {
354         int i;
355
356         for (i = 0; i < n; i++)
357                 known[knownum++] = h[i];
358 }