Bring if_bridge up to date with FreeBSD.
[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.3 2005/08/03 13:31:00 eirikn Exp $
36  */
37
38 #include <stdio.h>
39 #include <string.h>
40
41 #include "cribbage.h"
42 #include "cribcur.h"
43
44 static int      anysumto(CARD[], int, int, int);
45 static int      numofval(CARD[], int, int);
46 static void     prpeg(int, int, bool);
47
48 #define NTV     10              /* number scores to test */
49
50 /* score to test reachability of, and order to test them in */
51 const int tv[NTV] = {8, 7, 9, 6, 11, 12, 13, 14, 10, 5};
52
53 /*
54  * computer chooses what to play in pegging...
55  * only called if no playable card will score points
56  */
57 int
58 cchose(CARD h[], int n, int s)
59 {
60         int i, j, l;
61
62         if (n <= 1)
63                 return (0);
64         if (s < 4) {            /* try for good value */
65                 if ((j = anysumto(h, n, s, 4)) >= 0)
66                         return (j);
67                 if ((j = anysumto(h, n, s, 3)) >= 0 && s == 0)
68                         return (j);
69         }
70         if (s > 0 && s < 20) {
71                                 /* try for retaliation to 31 */
72                 for (i = 1; i <= 10; i++) {
73                         if ((j = anysumto(h, n, s, 21 - i)) >= 0) {
74                                 if ((l = numofval(h, n, i)) > 0) {
75                                         if (l > 1 || VAL(h[j].rank) != i)
76                                                 return (j);
77                                 }
78                         }
79                 }
80         }
81         if (s < 15) {
82                                 /* for retaliation after 15 */
83                 for (i = 0; i < NTV; i++) {
84                         if ((j = anysumto(h, n, s, tv[i])) >= 0) {
85                                 if ((l = numofval(h, n, 15 - tv[i])) > 0) {
86                                         if (l > 1 ||
87                                             VAL(h[j].rank) != 15 - tv[i])
88                                                 return (j);
89                                 }
90                         }
91                 }
92         }
93         j = -1;
94                                 /* remember: h is sorted */
95         for (i = n - 1; i >= 0; --i) {
96                 l = s + VAL(h[i].rank);
97                 if (l > 31)
98                         continue;
99                 if (l != 5 && l != 10 && l != 21) {
100                         j = i;
101                         break;
102                 }
103         }
104         if (j >= 0)
105                 return (j);
106         for (i = n - 1; i >= 0; --i) {
107                 l = s + VAL(h[i].rank);
108                 if (l > 31)
109                         continue;
110                 if (j < 0)
111                         j = i;
112                 if (l != 5 && l != 21) {
113                         j = i;
114                         break;
115                 }
116         }
117         return (j);
118 }
119
120 /*
121  * plyrhand:
122  *      Evaluate and score a player hand or crib
123  */
124 bool
125 plyrhand(CARD hand[], const char *s)
126 {
127         static char prompt[BUFSIZ];
128         int i, j;
129         bool win;
130
131         prhand(hand, CINHAND, Playwin, false);
132         sprintf(prompt, "Your %s scores ", s);
133         i = scorehand(hand, turnover, CINHAND, strcmp(s, "crib") == 0, explain);
134         if ((j = number(0, 29, prompt)) == 19)
135                 j = 0;
136         if (i != j) {
137                 if (i < j) {
138                         win = chkscr(&pscore, i);
139                         msg("It's really only %d points; I get %d", i, 2);
140                         if (!win)
141                                 win = chkscr(&cscore, 2);
142                 } else {
143                         win = chkscr(&pscore, j);
144                         msg("You should have taken %d, not %d!", i, j);
145                 }
146                 if (explain)
147                         msg("Explanation: %s", explstr);
148                 do_wait();
149         } else
150                 win = chkscr(&pscore, i);
151         return (win);
152 }
153
154 /*
155  * comphand:
156  *      Handle scoring and displaying the computer's hand
157  */
158 bool
159 comphand(CARD h[], const char *s)
160 {
161         int j;
162
163         j = scorehand(h, turnover, CINHAND, strcmp(s, "crib") == 0, false);
164         prhand(h, CINHAND, Compwin, false);
165         msg("My %s scores %d", s, (j == 0 ? 19 : j));
166         return (chkscr(&cscore, j));
167 }
168
169 /*
170  * chkscr:
171  *      Add inc to scr and test for > glimit, printing on the scoring
172  *      board while we're at it.
173  */
174 int Lastscore[2] = {-1, -1};
175
176 bool
177 chkscr(int *scr, int inc)
178 {
179         bool myturn;
180
181         myturn = (scr == &cscore);
182         if (inc != 0) {
183                 prpeg(Lastscore[myturn], '.', myturn);
184                 Lastscore[myturn] = *scr;
185                 *scr += inc;
186                 prpeg(*scr, PEG, myturn);
187                 refresh();
188         }
189         return (*scr >= glimit);
190 }
191
192 /*
193  * prpeg:
194  *      Put out the peg character on the score board and put the
195  *      score up on the board.
196  */
197 static void
198 prpeg(int score, int peg, bool myturn)
199 {
200         int y, x;
201
202         if (!myturn)
203                 y = SCORE_Y + 2;
204         else
205                 y = SCORE_Y + 5;
206
207         if (score <= 0 || score >= glimit) {
208                 if (peg == '.')
209                         peg = ' ';
210                 if (score == 0)
211                         x = SCORE_X + 2;
212                 else {
213                         x = SCORE_X + 2;
214                         y++;
215                 }
216         } else {
217                 x = (score - 1) % 30;
218                 if (score > 90 || (score > 30 && score <= 60)) {
219                         y++;
220                         x = 29 - x;
221                 }
222                 x += x / 5;
223                 x += SCORE_X + 3;
224         }
225         mvaddch(y, x, peg);
226         mvprintw(SCORE_Y + (myturn ? 7 : 1), SCORE_X + 10, "%3d", score);
227 }
228
229 /*
230  * cdiscard -- the computer figures out what is the best discard for
231  * the crib and puts the best two cards at the end
232  */
233 void
234 cdiscard(bool mycrib)
235 {
236         CARD    d[CARDS], h[FULLHAND], cb[2];
237         int i, j, k;
238         int     nc, ns;
239         long    sums[15];
240         static int undo1[15] = {0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 3, 3, 4};
241         static int undo2[15] = {1, 2, 3, 4, 5, 2, 3, 4, 5, 3, 4, 5, 4, 5, 5};
242
243         makedeck(d);
244         nc = CARDS;
245         for (i = 0; i < knownum; i++) { /* get all other cards */
246                 cremove(known[i], d, nc--);
247         }
248         for (i = 0; i < 15; i++)
249                 sums[i] = 0L;
250         ns = 0;
251         for (i = 0; i < (FULLHAND - 1); i++) {
252                 cb[0] = chand[i];
253                 for (j = i + 1; j < FULLHAND; j++) {
254                         cb[1] = chand[j];
255                         for (k = 0; k < FULLHAND; k++)
256                                 h[k] = chand[k];
257                         cremove(chand[i], h, FULLHAND);
258                         cremove(chand[j], h, FULLHAND - 1);
259                         for (k = 0; k < nc; k++) {
260                                 sums[ns] +=
261                                     scorehand(h, d[k], CINHAND, true, false);
262                                 if (mycrib)
263                                         sums[ns] += adjust(cb);
264                                 else
265                                         sums[ns] -= adjust(cb);
266                         }
267                         ++ns;
268                 }
269         }
270         j = 0;
271         for (i = 1; i < 15; i++)
272                 if (sums[i] > sums[j])
273                         j = i;
274         for (k = 0; k < FULLHAND; k++)
275                 h[k] = chand[k];
276         cremove(h[undo1[j]], chand, FULLHAND);
277         cremove(h[undo2[j]], chand, FULLHAND - 1);
278         chand[4] = h[undo1[j]];
279         chand[5] = h[undo2[j]];
280 }
281
282 /*
283  * returns true if some card in hand can be played without exceeding 31
284  */
285 bool
286 anymove(CARD hand[], int n, int sum)
287 {
288         int i, j;
289
290         if (n < 1)
291                 return (false);
292         j = hand[0].rank;
293         for (i = 1; i < n; i++) {
294                 if (hand[i].rank < j)
295                         j = hand[i].rank;
296         }
297         return (sum + VAL(j) <= 31);
298 }
299
300 /*
301  * anysumto returns the index (0 <= i < n) of the card in hand that brings
302  * the s up to t, or -1 if there is none
303  */
304 static int
305 anysumto(CARD hand[], int n, int s, int t)
306 {
307         int i;
308
309         for (i = 0; i < n; i++) {
310                 if (s + VAL(hand[i].rank) == t)
311                         return (i);
312         }
313         return (-1);
314 }
315
316 /*
317  * return the number of cards in h having the given rank value
318  */
319 static int
320 numofval(CARD h[], int n, int v)
321 {
322         int i, j;
323
324         j = 0;
325         for (i = 0; i < n; i++) {
326                 if (VAL(h[i].rank) == v)
327                         ++j;
328         }
329         return (j);
330 }
331
332 /*
333  * makeknown remembers all n cards in h for future recall
334  */
335 void
336 makeknown(CARD h[], int n)
337 {
338         int i;
339
340         for (i = 0; i < n; i++)
341                 known[knownum++] = h[i];
342 }