games/mille/comp.c

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