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