comp.c revision 1.5
1 /* $NetBSD: comp.c,v 1.5 1997/10/12 00:53:45 lukem 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 #include <sys/cdefs.h> 37 #ifndef lint 38 #if 0 39 static char sccsid[] = "@(#)comp.c 8.1 (Berkeley) 5/31/93"; 40 #else 41 __RCSID("$NetBSD: comp.c,v 1.5 1997/10/12 00:53:45 lukem Exp $"); 42 #endif 43 #endif /* not lint */ 44 45 # include "mille.h" 46 47 /* 48 * @(#)comp.c 1.1 (Berkeley) 4/1/82 49 */ 50 51 # define V_VALUABLE 40 52 53 void 54 calcmove() 55 { 56 CARD card; 57 int *value; 58 PLAY *pp, *op; 59 bool foundend, cango, canstop, foundlow; 60 unsgn int i, count200, badcount, nummin, nummax, diff; 61 int curmin, curmax; 62 CARD safe, oppos; 63 int valbuf[HAND_SZ], count[NUM_CARDS]; 64 bool playit[HAND_SZ]; 65 66 wmove(Score, ERR_Y, ERR_X); /* get rid of error messages */ 67 wclrtoeol(Score); 68 pp = &Player[COMP]; 69 op = &Player[PLAYER]; 70 safe = 0; 71 cango = 0; 72 canstop = FALSE; 73 foundend = FALSE; 74 75 /* Try for a Coup Forre, and see what we have. */ 76 for (i = 0; i < NUM_CARDS; i++) 77 count[i] = 0; 78 for (i = 0; i < HAND_SZ; i++) { 79 card = pp->hand[i]; 80 switch (card) { 81 case C_STOP: case C_CRASH: 82 case C_FLAT: case C_EMPTY: 83 if ((playit[i] = canplay(pp, op, card)) != 0) 84 canstop = TRUE; 85 goto norm; 86 case C_LIMIT: 87 if ((playit[i] = canplay(pp, op, card)) 88 && Numseen[C_25] == Numcards[C_25] 89 && Numseen[C_50] == Numcards[C_50]) 90 canstop = TRUE; 91 goto norm; 92 case C_25: case C_50: case C_75: 93 case C_100: case C_200: 94 if ((playit[i] = canplay(pp, op, card)) 95 && pp->mileage + Value[card] == End) 96 foundend = TRUE; 97 goto norm; 98 default: 99 playit[i] = canplay(pp, op, card); 100 norm: 101 if (playit[i]) 102 ++cango; 103 break; 104 case C_GAS_SAFE: case C_DRIVE_SAFE: 105 case C_SPARE_SAFE: case C_RIGHT_WAY: 106 if (pp->battle == opposite(card) || 107 (pp->speed == C_LIMIT && card == C_RIGHT_WAY)) { 108 Movetype = M_PLAY; 109 Card_no = i; 110 return; 111 } 112 ++safe; 113 playit[i] = TRUE; 114 break; 115 } 116 if (card >= 0) 117 ++count[card]; 118 } 119 120 /* No Coup Forre. Draw to fill hand, then restart, as needed. */ 121 if (pp->hand[0] == C_INIT && Topcard > Deck) { 122 Movetype = M_DRAW; 123 return; 124 } 125 126 #ifdef DEBUG 127 if (Debug) 128 fprintf(outf, "CALCMOVE: cango = %d, canstop = %d, safe = %d\n", 129 cango, canstop, safe); 130 #endif 131 if (foundend) 132 foundend = !check_ext(TRUE); 133 for (i = 0; safe && i < HAND_SZ; i++) { 134 if (issafety(pp->hand[i])) { 135 if (onecard(op) || (foundend && cango && !canstop)) { 136 #ifdef DEBUG 137 if (Debug) 138 fprintf(outf, 139 "CALCMOVE: onecard(op) = %d, foundend = %d\n", 140 onecard(op), foundend); 141 #endif 142 playsafe: 143 Movetype = M_PLAY; 144 Card_no = i; 145 return; 146 } 147 oppos = opposite(pp->hand[i]); 148 if (Numseen[oppos] == Numcards[oppos] && 149 !(pp->hand[i] == C_RIGHT_WAY && 150 Numseen[C_LIMIT] != Numcards[C_LIMIT])) 151 goto playsafe; 152 else if (!cango 153 && (op->can_go || !pp->can_go || Topcard < Deck)) { 154 card = (Topcard - Deck) - roll(1, 10); 155 if ((!pp->mileage) != (!op->mileage)) 156 card -= 7; 157 #ifdef DEBUG 158 if (Debug) 159 fprintf(outf, 160 "CALCMOVE: card = %d, DECK_SZ / 4 = %d\n", 161 card, DECK_SZ / 4); 162 #endif 163 if (card < DECK_SZ / 4) 164 goto playsafe; 165 } 166 safe--; 167 playit[i] = cango; 168 } 169 } 170 if (!pp->can_go && !isrepair(pp->battle)) 171 Numneed[opposite(pp->battle)]++; 172 redoit: 173 foundlow = (cango || count[C_END_LIMIT] != 0 174 || Numseen[C_LIMIT] == Numcards[C_LIMIT] 175 || pp->safety[S_RIGHT_WAY] != S_UNKNOWN); 176 foundend = FALSE; 177 count200 = pp->nummiles[C_200]; 178 badcount = 0; 179 curmax = -1; 180 curmin = 101; 181 nummin = -1; 182 nummax = -1; 183 value = valbuf; 184 for (i = 0; i < HAND_SZ; i++) { 185 card = pp->hand[i]; 186 if (issafety(card) || playit[i] == (cango != 0)) { 187 #ifdef DEBUG 188 if (Debug) 189 fprintf(outf, "CALCMOVE: switch(\"%s\")\n", 190 C_name[card]); 191 #endif 192 switch (card) { 193 case C_25: case C_50: 194 diff = End - pp->mileage; 195 /* avoid getting too close */ 196 if (Topcard > Deck && cango && diff <= 100 197 && diff / Value[card] > count[card] 198 && (card == C_25 || diff % 50 == 0)) { 199 if (card == C_50 && diff - 50 == 25 200 && count[C_25] > 0) 201 goto okay; 202 *value = 0; 203 if (--cango <= 0) 204 goto redoit; 205 break; 206 } 207 okay: 208 *value = (Value[card] >> 3); 209 if (pp->speed == C_LIMIT) 210 ++*value; 211 else 212 --*value; 213 if (!foundlow 214 && (card == C_50 || count[C_50] == 0)) { 215 *value = (pp->mileage ? 10 : 20); 216 foundlow = TRUE; 217 } 218 goto miles; 219 case C_200: 220 if (++count200 > 2) { 221 *value = 0; 222 break; 223 } 224 case C_75: case C_100: 225 *value = (Value[card] >> 3); 226 if (pp->speed == C_LIMIT) 227 --*value; 228 else 229 ++*value; 230 miles: 231 if (pp->mileage + Value[card] > End) 232 *value = (End == 700 ? card : 0); 233 else if (pp->mileage + Value[card] == End) { 234 *value = (foundend ? card : V_VALUABLE); 235 foundend = TRUE; 236 } 237 break; 238 case C_END_LIMIT: 239 if (pp->safety[S_RIGHT_WAY] != S_UNKNOWN) 240 *value = (pp->safety[S_RIGHT_WAY] == 241 S_PLAYED ? -1 : 1); 242 else if (pp->speed == C_LIMIT && 243 End - pp->mileage <= 50) 244 *value = 1; 245 else if (pp->speed == C_LIMIT 246 || Numseen[C_LIMIT] != Numcards[C_LIMIT]) { 247 safe = S_RIGHT_WAY; 248 oppos = C_LIMIT; 249 goto repair; 250 } 251 else { 252 *value = 0; 253 --count[C_END_LIMIT]; 254 } 255 break; 256 case C_REPAIRS: case C_SPARE: case C_GAS: 257 safe = safety(card) - S_CONV; 258 oppos = opposite(card); 259 if (pp->safety[safe] != S_UNKNOWN) 260 *value = (pp->safety[safe] == 261 S_PLAYED ? -1 : 1); 262 else if (pp->battle != oppos 263 && (Numseen[oppos] == Numcards[oppos] || 264 Numseen[oppos] + count[card] > 265 Numcards[oppos])) { 266 *value = 0; 267 --count[card]; 268 } 269 else { 270 repair: 271 *value = Numcards[oppos] * 6; 272 *value += Numseen[card] - 273 Numseen[oppos]; 274 if (!cango) 275 *value /= (count[card]*count[card]); 276 count[card]--; 277 } 278 break; 279 case C_GO: 280 if (pp->safety[S_RIGHT_WAY] != S_UNKNOWN) 281 *value = (pp->safety[S_RIGHT_WAY] == 282 S_PLAYED ? -1 : 2); 283 else if (pp->can_go 284 && Numgos + count[C_GO] == Numneed[C_GO]) { 285 *value = 0; 286 --count[C_GO]; 287 } 288 else { 289 *value = Numneed[C_GO] * 3; 290 *value += (Numseen[C_GO] - Numgos); 291 *value /= (count[C_GO] * count[C_GO]); 292 count[C_GO]--; 293 } 294 break; 295 case C_LIMIT: 296 if (op->mileage + 50 >= End) { 297 *value = (End == 700 && !cango); 298 break; 299 } 300 if (canstop || (cango && !op->can_go)) 301 *value = 1; 302 else { 303 *value = (pp->safety[S_RIGHT_WAY] != 304 S_UNKNOWN ? 2 : 3); 305 safe = S_RIGHT_WAY; 306 oppos = C_END_LIMIT; 307 goto normbad; 308 } 309 break; 310 case C_CRASH: case C_EMPTY: case C_FLAT: 311 safe = safety(card) - S_CONV; 312 oppos = opposite(card); 313 *value = (pp->safety[safe]!=S_UNKNOWN ? 3 : 4); 314 normbad: 315 if (op->safety[safe] == S_PLAYED) 316 *value = -1; 317 else { 318 *value *= Numneed[oppos] + 319 Numseen[oppos] + 2; 320 if (!pp->mileage || foundend || 321 onecard(op)) 322 *value += 5; 323 if (op->mileage == 0 || onecard(op)) 324 *value += 5; 325 if (op->speed == C_LIMIT) 326 *value -= 3; 327 if (cango && 328 pp->safety[safe] != S_UNKNOWN) 329 *value += 3; 330 if (!cango) 331 *value /= ++badcount; 332 } 333 break; 334 case C_STOP: 335 if (op->safety[S_RIGHT_WAY] == S_PLAYED) 336 *value = -1; 337 else { 338 *value = (pp->safety[S_RIGHT_WAY] != 339 S_UNKNOWN ? 3 : 4); 340 *value *= Numcards[C_STOP] + 341 Numseen[C_GO]; 342 if (!pp->mileage || foundend || 343 onecard(op)) 344 *value += 5; 345 if (!cango) 346 *value /= ++badcount; 347 if (op->mileage == 0) 348 *value += 5; 349 if ((card == C_LIMIT && 350 op->speed == C_LIMIT) || 351 !op->can_go) 352 *value -= 5; 353 if (cango && pp->safety[S_RIGHT_WAY] != 354 S_UNKNOWN) 355 *value += 5; 356 } 357 break; 358 case C_GAS_SAFE: case C_DRIVE_SAFE: 359 case C_SPARE_SAFE: case C_RIGHT_WAY: 360 *value = cango ? 0 : 101; 361 break; 362 case C_INIT: 363 *value = 0; 364 break; 365 } 366 } 367 else 368 *value = cango ? 0 : 101; 369 if (card != C_INIT) { 370 if (*value >= curmax) { 371 nummax = i; 372 curmax = *value; 373 } 374 if (*value <= curmin) { 375 nummin = i; 376 curmin = *value; 377 } 378 } 379 #ifdef DEBUG 380 if (Debug) 381 mvprintw(i + 6, 2, "%3d %-14s", *value, 382 C_name[pp->hand[i]]); 383 #endif 384 value++; 385 } 386 if (!pp->can_go && !isrepair(pp->battle)) 387 Numneed[opposite(pp->battle)]++; 388 if (cango) { 389 play_it: 390 mvaddstr(MOVE_Y + 1, MOVE_X, "PLAY\n"); 391 Movetype = M_PLAY; 392 Card_no = nummax; 393 } 394 else { 395 if (issafety(pp->hand[nummin])) { /* NEVER discard a safety */ 396 nummax = nummin; 397 goto play_it; 398 } 399 mvaddstr(MOVE_Y + 1, MOVE_X, "DISCARD\n"); 400 Movetype = M_DISCARD; 401 Card_no = nummin; 402 } 403 mvprintw(MOVE_Y + 2, MOVE_X, "%16s", C_name[pp->hand[Card_no]]); 404 } 405 406 /* 407 * Return true if the given player could conceivably win with his next card. 408 */ 409 int 410 onecard(pp) 411 PLAY *pp; 412 { 413 CARD bat, spd, card; 414 415 bat = pp->battle; 416 spd = pp->speed; 417 card = -1; 418 if (pp->can_go || ((isrepair(bat) || bat == C_STOP || spd == C_LIMIT) && 419 Numseen[S_RIGHT_WAY] != 0) || 420 (bat >= 0 && Numseen[safety(bat)] != 0)) 421 switch (End - pp->mileage) { 422 case 200: 423 if (pp->nummiles[C_200] == 2) 424 return FALSE; 425 card = C_200; 426 /* FALLTHROUGH */ 427 case 100: 428 case 75: 429 if (card == -1) 430 card = (End - pp->mileage == 75 ? C_75 : C_100); 431 if (spd == C_LIMIT) 432 return Numseen[S_RIGHT_WAY] == 0; 433 case 50: 434 case 25: 435 if (card == -1) 436 card = (End - pp->mileage == 25 ? C_25 : C_50); 437 return Numseen[card] != Numcards[card]; 438 } 439 return FALSE; 440 } 441 442 int 443 canplay(pp, op, card) 444 PLAY *pp, *op; 445 CARD card; 446 { 447 switch (card) { 448 case C_200: 449 if (pp->nummiles[C_200] == 2) 450 break; 451 /* FALLTHROUGH */ 452 case C_75: case C_100: 453 if (pp->speed == C_LIMIT) 454 break; 455 /* FALLTHROUGH */ 456 case C_50: 457 if (pp->mileage + Value[card] > End) 458 break; 459 /* FALLTHROUGH */ 460 case C_25: 461 if (pp->can_go) 462 return TRUE; 463 break; 464 case C_EMPTY: case C_FLAT: case C_CRASH: 465 case C_STOP: 466 if (op->can_go && op->safety[safety(card) - S_CONV] != S_PLAYED) 467 return TRUE; 468 break; 469 case C_LIMIT: 470 if (op->speed != C_LIMIT && 471 op->safety[S_RIGHT_WAY] != S_PLAYED && 472 op->mileage + 50 < End) 473 return TRUE; 474 break; 475 case C_GAS: case C_SPARE: case C_REPAIRS: 476 if (pp->battle == opposite(card)) 477 return TRUE; 478 break; 479 case C_GO: 480 if (!pp->can_go && 481 (isrepair(pp->battle) || pp->battle == C_STOP)) 482 return TRUE; 483 break; 484 case C_END_LIMIT: 485 if (pp->speed == C_LIMIT) 486 return TRUE; 487 } 488 return FALSE; 489 } 490
Indexes created Mon Sep 29 18:09:42 GMT 2025