Add the DragonFly cvs id and perform general cleanups on cvs/rcs/sccs ids. Most
[dragonfly.git] / games / cribbage / support.c
CommitLineData
984263bc
MD
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.
1de703da
MD
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 $
984263bc
MD
36 */
37
984263bc
MD
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 */
48int 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 */
54int
55cchose(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 */
123int
124plyrhand(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 */
159int
160comphand(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 */
177int Lastscore[2] = {-1, -1};
178
179int
180chkscr(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 */
201void
202prpeg(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 */
240void
241cdiscard(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 */
293int
294anymove(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 */
314int
315anysumto(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 */
331int
332numofval(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 */
349void
350makeknown(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}