?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
libc/sysvipc: Mark two functions as printf-like and fix resulting errors.
[dragonfly.git] / games / mille / comp.c
bloba5979e7b5242abe347907714bf3ac2d3d4527008
1 /*-
2 * Copyright (c) 1982, 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. Neither the name of the University nor the names of its contributors
14 * may be used to endorse or promote products derived from this software
15 * without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27 * SUCH DAMAGE.
28 *
29 * @(#)comp.c 8.1 (Berkeley) 5/31/93
30 * $FreeBSD: src/games/mille/comp.c,v 1.5 1999/12/12 06:17:24 billf Exp $
31 */
32
33 #include "mille.h"
34
35 /*
36 * @(#)comp.c 1.1 (Berkeley) 4/1/82
37 */
38
39 #define V_VALUABLE 40
40
41 void
42 calcmove(void)
43 {
44 CARD card;
45 int *value;
46 PLAY *pp, *op;
47 bool foundend, cango, canstop, foundlow;
48 unsigned int i, count200, badcount, nummin, nummax, diff;
49 int curmin, curmax;
50 CARD safe, oppos;
51 int valbuf[HAND_SZ], count[NUM_CARDS];
52 bool playit[HAND_SZ];
53
54 wmove(Score, ERR_Y, ERR_X); /* get rid of error messages */
55 wclrtoeol(Score);
56 pp = &Player[COMP];
57 op = &Player[PLAYER];
58 safe = 0;
59 cango = FALSE;
60 canstop = FALSE;
61 foundend = FALSE;
62
63 /* Try for a Coup Forre, and see what we have. */
64 for (i = 0; i < NUM_CARDS; i++)
65 count[i] = 0;
66 for (i = 0; i < HAND_SZ; i++) {
67 card = pp->hand[i];
68 switch (card) {
69 case C_STOP: case C_CRASH:
70 case C_FLAT: case C_EMPTY:
71 if ((playit[i] = canplay(pp, op, card)))
72 canstop = TRUE;
73 goto norm;
74 case C_LIMIT:
75 if ((playit[i] = canplay(pp, op, card))
76 && Numseen[C_25] == Numcards[C_25]
77 && Numseen[C_50] == Numcards[C_50])
78 canstop = TRUE;
79 goto norm;
80 case C_25: case C_50: case C_75:
81 case C_100: case C_200:
82 if ((playit[i] = canplay(pp, op, card))
83 && pp->mileage + Value[card] == End)
84 foundend = TRUE;
85 goto norm;
86 default:
87 playit[i] = canplay(pp, op, card);
88 norm:
89 if (playit[i])
90 cango = TRUE;
91 break;
92 case C_GAS_SAFE: case C_DRIVE_SAFE:
93 case C_SPARE_SAFE: case C_RIGHT_WAY:
94 if (pp->battle == opposite(card) ||
95 (pp->speed == C_LIMIT && card == C_RIGHT_WAY)) {
96 Movetype = M_PLAY;
97 Card_no = i;
98 return;
99 }
100 ++safe;
101 playit[i] = TRUE;
102 break;
103 }
104 if (card >= 0)
105 ++count[card];
106 }
107
108 /* No Coup Forre. Draw to fill hand, then restart, as needed. */
109 if (pp->hand[0] == C_INIT && Topcard > Deck) {
110 Movetype = M_DRAW;
111 return;
112 }
113
114 #ifdef DEBUG
115 if (Debug)
116 fprintf(outf, "CALCMOVE: cango = %d, canstop = %d, safe = %d\n",
117 cango, canstop, safe);
118 #endif
119 if (foundend)
120 foundend = !check_ext(TRUE);
121 for (i = 0; safe && i < HAND_SZ; i++) {
122 if (issafety(pp->hand[i])) {
123 if (onecard(op) || (foundend && cango && !canstop)) {
124 #ifdef DEBUG
125 if (Debug)
126 fprintf(outf,
127 "CALCMOVE: onecard(op) = %d, foundend = %d\n",
128 onecard(op), foundend);
129 #endif
130 playsafe:
131 Movetype = M_PLAY;
132 Card_no = i;
133 return;
134 }
135 oppos = opposite(pp->hand[i]);
136 if (Numseen[oppos] == Numcards[oppos] &&
137 !(pp->hand[i] == C_RIGHT_WAY &&
138 Numseen[C_LIMIT] != Numcards[C_LIMIT]))
139 goto playsafe;
140 else if (!cango
141 && (op->can_go || !pp->can_go || Topcard < Deck)) {
142 card = (Topcard - Deck) - roll(1, 10);
143 if ((!pp->mileage) != (!op->mileage))
144 card -= 7;
145 #ifdef DEBUG
146 if (Debug)
147 fprintf(outf,
148 "CALCMOVE: card = %d, DECK_SZ / 4 = %d\n",
149 card, DECK_SZ / 4);
150 #endif
151 if (card < DECK_SZ / 4)
152 goto playsafe;
153 }
154 safe--;
155 playit[i] = cango;
156 }
157 }
158 if (!pp->can_go && !isrepair(pp->battle))
159 Numneed[opposite(pp->battle)]++;
160 redoit:
161 foundlow = (cango || count[C_END_LIMIT] != 0
162 || Numseen[C_LIMIT] == Numcards[C_LIMIT]
163 || pp->safety[S_RIGHT_WAY] != S_UNKNOWN);
164 foundend = FALSE;
165 count200 = pp->nummiles[C_200];
166 badcount = 0;
167 curmax = -1;
168 curmin = 101;
169 nummin = -1;
170 nummax = -1;
171 value = valbuf;
172 for (i = 0; i < HAND_SZ; i++) {
173 card = pp->hand[i];
174 if (issafety(card) || playit[i] == cango) {
175 #ifdef DEBUG
176 if (Debug)
177 fprintf(outf, "CALCMOVE: switch(\"%s\")\n",
178 C_name[card]);
179 #endif
180 switch (card) {
181 case C_25: case C_50:
182 diff = End - pp->mileage;
183 /* avoid getting too close */
184 if (Topcard > Deck && cango && diff <= 100
185 && (int)diff / Value[card] > count[card]
186 && (card == C_25 || diff % 50 == 0)) {
187 if (card == C_50 && diff - 50 == 25
188 && count[C_25] > 0)
189 goto okay;
190 *value = 0;
191 cango = FALSE;
192 goto redoit;
193 }
194 okay:
195 *value = (Value[card] >> 3);
196 if (pp->speed == C_LIMIT)
197 ++*value;
198 else
199 --*value;
200 if (!foundlow
201 && (card == C_50 || count[C_50] == 0)) {
202 *value = (pp->mileage ? 10 : 20);
203 foundlow = TRUE;
204 }
205 goto miles;
206 case C_200:
207 if (++count200 > 2) {
208 *value = 0;
209 break;
210 }
211 /* FALLTHROUGH */
212 case C_100:
213 case C_75:
214 *value = (Value[card] >> 3);
215 if (pp->speed == C_LIMIT)
216 --*value;
217 else
218 ++*value;
219 miles:
220 if (pp->mileage + Value[card] > End)
221 *value = (End == 700 ? card : 0);
222 else if (pp->mileage + Value[card] == End) {
223 *value = (foundend ? card : V_VALUABLE);
224 foundend = TRUE;
225 }
226 break;
227 case C_END_LIMIT:
228 if (pp->safety[S_RIGHT_WAY] != S_UNKNOWN)
229 *value = (pp->safety[S_RIGHT_WAY] ==
230 S_PLAYED ? -1 : 1);
231 else if (pp->speed == C_LIMIT &&
232 End - pp->mileage <= 50)
233 *value = 1;
234 else if (pp->speed == C_LIMIT
235 || Numseen[C_LIMIT] != Numcards[C_LIMIT]) {
236 safe = S_RIGHT_WAY;
237 oppos = C_LIMIT;
238 goto repair;
239 }
240 else {
241 *value = 0;
242 --count[C_END_LIMIT];
243 }
244 break;
245 case C_REPAIRS: case C_SPARE: case C_GAS:
246 safe = safety(card) - S_CONV;
247 oppos = opposite(card);
248 if (pp->safety[safe] != S_UNKNOWN)
249 *value = (pp->safety[safe] ==
250 S_PLAYED ? -1 : 1);
251 else if (pp->battle != oppos
252 && (Numseen[oppos] == Numcards[oppos] ||
253 Numseen[oppos] + count[card] >
254 Numcards[oppos])) {
255 *value = 0;
256 --count[card];
257 }
258 else {
259 repair:
260 *value = Numcards[oppos] * 6;
261 *value += Numseen[card] -
262 Numseen[oppos];
263 if (!cango)
264 *value /= (count[card]*count[card]);
265 count[card]--;
266 }
267 break;
268 case C_GO:
269 if (pp->safety[S_RIGHT_WAY] != S_UNKNOWN)
270 *value = (pp->safety[S_RIGHT_WAY] ==
271 S_PLAYED ? -1 : 2);
272 else if (pp->can_go
273 && Numgos + count[C_GO] == Numneed[C_GO]) {
274 *value = 0;
275 --count[C_GO];
276 }
277 else {
278 *value = Numneed[C_GO] * 3;
279 *value += (Numseen[C_GO] - Numgos);
280 *value /= (count[C_GO] * count[C_GO]);
281 count[C_GO]--;
282 }
283 break;
284 case C_LIMIT:
285 if (op->mileage + 50 >= End) {
286 *value = (End == 700 && !cango);
287 break;
288 }
289 if (canstop || (cango && !op->can_go))
290 *value = 1;
291 else {
292 *value = (pp->safety[S_RIGHT_WAY] !=
293 S_UNKNOWN ? 2 : 3);
294 safe = S_RIGHT_WAY;
295 oppos = C_END_LIMIT;
296 goto normbad;
297 }
298 break;
299 case C_CRASH: case C_EMPTY: case C_FLAT:
300 safe = safety(card) - S_CONV;
301 oppos = opposite(card);
302 *value = (pp->safety[safe]!=S_UNKNOWN ? 3 : 4);
303 normbad:
304 if (op->safety[safe] == S_PLAYED)
305 *value = -1;
306 else {
307 *value *= Numneed[oppos] +
308 Numseen[oppos] + 2;
309 if (!pp->mileage || foundend ||
310 onecard(op))
311 *value += 5;
312 if (op->mileage == 0 || onecard(op))
313 *value += 5;
314 if (op->speed == C_LIMIT)
315 *value -= 3;
316 if (cango &&
317 pp->safety[safe] != S_UNKNOWN)
318 *value += 3;
319 if (!cango)
320 *value /= ++badcount;
321 }
322 break;
323 case C_STOP:
324 if (op->safety[S_RIGHT_WAY] == S_PLAYED)
325 *value = -1;
326 else {
327 *value = (pp->safety[S_RIGHT_WAY] !=
328 S_UNKNOWN ? 3 : 4);
329 *value *= Numcards[C_STOP] +
330 Numseen[C_GO];
331 if (!pp->mileage || foundend ||
332 onecard(op))
333 *value += 5;
334 if (!cango)
335 *value /= ++badcount;
336 if (op->mileage == 0)
337 *value += 5;
338 if ((card == C_LIMIT &&
339 op->speed == C_LIMIT) ||
340 !op->can_go)
341 *value -= 5;
342 if (cango && pp->safety[S_RIGHT_WAY] !=
343 S_UNKNOWN)
344 *value += 5;
345 }
346 break;
347 case C_GAS_SAFE: case C_DRIVE_SAFE:
348 case C_SPARE_SAFE: case C_RIGHT_WAY:
349 *value = cango ? 0 : 101;
350 break;
351 case C_INIT:
352 *value = 0;
353 break;
354 }
355 }
356 else
357 *value = cango ? 0 : 101;
358 if (card != C_INIT) {
359 if (*value >= curmax) {
360 nummax = i;
361 curmax = *value;
362 }
363 if (*value <= curmin) {
364 nummin = i;
365 curmin = *value;
366 }
367 }
368 #ifdef DEBUG
369 if (Debug)
370 mvprintw(i + 6, 2, "%3d %-14s", *value,
371 C_name[pp->hand[i]]);
372 #endif
373 value++;
374 }
375 if (!pp->can_go && !isrepair(pp->battle))
376 Numneed[opposite(pp->battle)]++;
377 if (cango) {
378 play_it:
379 mvaddstr(MOVE_Y + 1, MOVE_X, "PLAY\n");
380 Movetype = M_PLAY;
381 Card_no = nummax;
382 }
383 else {
384 if (issafety(pp->hand[nummin])) { /* NEVER discard a safety */
385 nummax = nummin;
386 goto play_it;
387 }
388 mvaddstr(MOVE_Y + 1, MOVE_X, "DISCARD\n");
389 Movetype = M_DISCARD;
390 Card_no = nummin;
391 }
392 mvprintw(MOVE_Y + 2, MOVE_X, "%16s", C_name[pp->hand[Card_no]]);
393 }
394
395 /*
396 * Return true if the given player could conceivably win with his next card.
397 */
398 bool
399 onecard(const PLAY *pp)
400 {
401 CARD bat, spd, card;
402
403 bat = pp->battle;
404 spd = pp->speed;
405 card = -1;
406 if (pp->can_go || ((isrepair(bat) || bat == C_STOP || spd == C_LIMIT) &&
407 Numseen[S_RIGHT_WAY] != 0) ||
408 (bat >= 0 && Numseen[safety(bat)] != 0))
409 switch (End - pp->mileage) {
410 case 200:
411 if (pp->nummiles[C_200] == 2)
412 return FALSE;
413 card = C_200;
414 /* FALLTHROUGH */
415 case 100:
416 case 75:
417 if (card == -1)
418 card = (End - pp->mileage == 75 ? C_75 : C_100);
419 if (spd == C_LIMIT)
420 return Numseen[S_RIGHT_WAY] == 0;
421 /* FALLTHROUGH */
422 case 50:
423 case 25:
424 if (card == -1)
425 card = (End - pp->mileage == 25 ? C_25 : C_50);
426 return Numseen[card] != Numcards[card];
427 }
428 return FALSE;
429 }
430
431 bool
432 canplay(const PLAY *pp, const PLAY *op, CARD card)
433 {
434 switch (card) {
435 case C_200:
436 if (pp->nummiles[C_200] == 2)
437 break;
438 /* FALLTHROUGH */
439 case C_75: case C_100:
440 if (pp->speed == C_LIMIT)
441 break;
442 /* FALLTHROUGH */
443 case C_50:
444 if (pp->mileage + Value[card] > End)
445 break;
446 /* FALLTHROUGH */
447 case C_25:
448 if (pp->can_go)
449 return TRUE;
450 break;
451 case C_EMPTY: case C_FLAT: case C_CRASH:
452 case C_STOP:
453 if (op->can_go && op->safety[safety(card) - S_CONV] != S_PLAYED)
454 return TRUE;
455 break;
456 case C_LIMIT:
457 if (op->speed != C_LIMIT &&
458 op->safety[S_RIGHT_WAY] != S_PLAYED &&
459 op->mileage + 50 < End)
460 return TRUE;
461 break;
462 case C_GAS: case C_SPARE: case C_REPAIRS:
463 if (pp->battle == opposite(card))
464 return TRUE;
465 break;
466 case C_GO:
467 if (!pp->can_go &&
468 (isrepair(pp->battle) || pp->battle == C_STOP))
469 return TRUE;
470 break;
471 case C_END_LIMIT:
472 if (pp->speed == C_LIMIT)
473 return TRUE;
474 }
475 return FALSE;
476 }
DragonFly BSD