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