mille/move.c

   1 /*
   2  * Copyright (c) 1983 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[] = "@(#)move.c      5.4 (Berkeley) 6/1/90";
  36 #endif /* not lint */
  37
  38 #include        "mille.h"
  39 #ifndef unctrl
  40 #include        "unctrl.h"
  41 #endif
  42
  43 # ifdef attron
  44 #       include <term.h>
  45 #       define  _tty    cur_term->Nttyb
  46 # endif attron
  47
  48 /*
  49  * @(#)move.c   1.2 (Berkeley) 3/28/83
  50  */
  51
  52 #undef  CTRL
  53 #define CTRL(c)         (c - 'A' + 1)
  54
  55 char    *Movenames[] = {
  56                 "M_DISCARD", "M_DRAW", "M_PLAY", "M_ORDER"
  57         };
  58
  59 domove()
  60 {
  61         reg PLAY        *pp;
  62         reg int         i, j;
  63         reg bool        goodplay;
  64
  65         pp = &Player[Play];
  66         if (Play == PLAYER)
  67                 getmove();
  68         else
  69                 calcmove();
  70         Next = FALSE;
  71         goodplay = TRUE;
  72         switch (Movetype) {
  73           case M_DISCARD:
  74                 if (haspicked(pp)) {
  75                         if (pp->hand[Card_no] == C_INIT)
  76                                 if (Card_no == 6)
  77                                         Finished = TRUE;
  78                                 else
  79                                         error("no card there");
  80                         else {
  81                                 if (issafety(pp->hand[Card_no])) {
  82                                         error("discard a safety?");
  83                                         goodplay = FALSE;
  84                                         break;
  85                                 }
  86                                 Discard = pp->hand[Card_no];
  87                                 pp->hand[Card_no] = C_INIT;
  88                                 Next = TRUE;
  89                                 if (Play == PLAYER)
  90                                         account(Discard);
  91                         }
  92                 }
  93                 else
  94                         error("must pick first");
  95                 break;
  96           case M_PLAY:
  97                 goodplay = playcard(pp);
  98                 break;
  99           case M_DRAW:
 100                 Card_no = 0;
 101                 if (Topcard <= Deck)
 102                         error("no more cards");
 103                 else if (haspicked(pp))
 104                         error("already picked");
 105                 else {
 106                         pp->hand[0] = *--Topcard;
 107 #ifdef DEBUG
 108                         if (Debug)
 109                                 fprintf(outf, "DOMOVE: Draw %s\n", C_name[*Topcard]);
 110 #endif
 111 acc:
 112                         if (Play == COMP) {
 113                                 account(*Topcard);
 114                                 if (issafety(*Topcard))
 115                                         pp->safety[*Topcard-S_CONV] = S_IN_HAND;
 116                         }
 117                         if (pp->hand[1] == C_INIT && Topcard > Deck) {
 118                                 Card_no = 1;
 119                                 pp->hand[1] = *--Topcard;
 120 #ifdef DEBUG
 121                                 if (Debug)
 122                                         fprintf(outf, "DOMOVE: Draw %s\n", C_name[*Topcard]);
 123 #endif
 124                                 goto acc;
 125                         }
 126                         pp->new_battle = FALSE;
 127                         pp->new_speed = FALSE;
 128                 }
 129                 break;
 130
 131           case M_ORDER:
 132                 break;
 133         }
 134         /*
 135          * move blank card to top by one of two methods.  If the
 136          * computer's hand was sorted, the randomness for picking
 137          * between equally valued cards would be lost
 138          */
 139         if (Order && Movetype != M_DRAW && goodplay && pp == &Player[PLAYER])
 140                 sort(pp->hand);
 141         else
 142                 for (i = 1; i < HAND_SZ; i++)
 143                         if (pp->hand[i] == C_INIT) {
 144                                 for (j = 0; pp->hand[j] == C_INIT; j++)
 145                                         if (j >= HAND_SZ) {
 146                                                 j = 0;
 147                                                 break;
 148                                         }
 149                                 pp->hand[i] = pp->hand[j];
 150                                 pp->hand[j] = C_INIT;
 151                         }
 152         if (Topcard <= Deck)
 153                 check_go();
 154         if (Next)
 155                 nextplay();
 156 }
 157
 158 /*
 159  *      Check and see if either side can go.  If they cannot,
 160  * the game is over
 161  */
 162 check_go() {
 163
 164         reg CARD        card;
 165         reg PLAY        *pp, *op;
 166         reg int         i;
 167
 168         for (pp = Player; pp < &Player[2]; pp++) {
 169                 op = (pp == &Player[COMP] ? &Player[PLAYER] : &Player[COMP]);
 170                 for (i = 0; i < HAND_SZ; i++) {
 171                         card = pp->hand[i];
 172                         if (issafety(card) || canplay(pp, op, card)) {
 173 #ifdef DEBUG
 174                                 if (Debug) {
 175                                         fprintf(outf, "CHECK_GO: can play %s (%d), ", C_name[card], card);
 176                                         fprintf(outf, "issafety(card) = %d, ", issafety(card));
 177                                         fprintf(outf, "canplay(pp, op, card) = %d\n", canplay(pp, op, card));
 178                                 }
 179 #endif
 180                                 return;
 181                         }
 182 #ifdef DEBUG
 183                         else if (Debug)
 184                                 fprintf(outf, "CHECK_GO: cannot play %s\n",
 185                                     C_name[card]);
 186 #endif
 187                 }
 188         }
 189         Finished = TRUE;
 190 }
 191
 192 playcard(pp)
 193 reg PLAY        *pp;
 194 {
 195         reg int         v;
 196         reg CARD        card;
 197
 198         /*
 199          * check and see if player has picked
 200          */
 201         switch (pp->hand[Card_no]) {
 202           default:
 203                 if (!haspicked(pp))
 204 mustpick:
 205                         return error("must pick first");
 206           case C_GAS_SAFE:      case C_SPARE_SAFE:
 207           case C_DRIVE_SAFE:    case C_RIGHT_WAY:
 208                 break;
 209         }
 210
 211         card = pp->hand[Card_no];
 212 #ifdef DEBUG
 213         if (Debug)
 214                 fprintf(outf, "PLAYCARD: Card = %s\n", C_name[card]);
 215 #endif
 216         Next = FALSE;
 217         switch (card) {
 218           case C_200:
 219                 if (pp->nummiles[C_200] == 2)
 220                         return error("only two 200's per hand");
 221           case C_100:   case C_75:
 222                 if (pp->speed == C_LIMIT)
 223                         return error("limit of 50");
 224           case C_50:
 225                 if (pp->mileage + Value[card] > End)
 226                         return error("puts you over %d", End);
 227           case C_25:
 228                 if (!pp->can_go)
 229                         return error("cannot move now");
 230                 pp->nummiles[card]++;
 231                 v = Value[card];
 232                 pp->total += v;
 233                 pp->hand_tot += v;
 234                 if ((pp->mileage += v) == End)
 235                         check_ext(FALSE);
 236                 break;
 237
 238           case C_GAS:   case C_SPARE:   case C_REPAIRS:
 239                 if (pp->battle != opposite(card))
 240                         return error("can't play \"%s\"", C_name[card]);
 241                 pp->battle = card;
 242                 if (pp->safety[S_RIGHT_WAY] == S_PLAYED)
 243                         pp->can_go = TRUE;
 244                 break;
 245
 246           case C_GO:
 247                 if (pp->battle != C_INIT && pp->battle != C_STOP
 248                     && !isrepair(pp->battle))
 249                         return error("cannot play \"Go\" on a \"%s\"",
 250                             C_name[pp->battle]);
 251                 pp->battle = C_GO;
 252                 pp->can_go = TRUE;
 253                 break;
 254
 255           case C_END_LIMIT:
 256                 if (pp->speed != C_LIMIT)
 257                         return error("not limited");
 258                 pp->speed = C_END_LIMIT;
 259                 break;
 260
 261           case C_EMPTY: case C_FLAT:    case C_CRASH:
 262           case C_STOP:
 263                 pp = &Player[other(Play)];
 264                 if (!pp->can_go)
 265                         return error("opponent cannot go");
 266                 else if (pp->safety[safety(card) - S_CONV] == S_PLAYED)
 267 protected:
 268                         return error("opponent is protected");
 269                 pp->battle = card;
 270                 pp->new_battle = TRUE;
 271                 pp->can_go = FALSE;
 272                 pp = &Player[Play];
 273                 break;
 274
 275           case C_LIMIT:
 276                 pp = &Player[other(Play)];
 277                 if (pp->speed == C_LIMIT)
 278                         return error("opponent has limit");
 279                 if (pp->safety[S_RIGHT_WAY] == S_PLAYED)
 280                         goto protected;
 281                 pp->speed = C_LIMIT;
 282                 pp->new_speed = TRUE;
 283                 pp = &Player[Play];
 284                 break;
 285
 286           case C_GAS_SAFE:      case C_SPARE_SAFE:
 287           case C_DRIVE_SAFE:    case C_RIGHT_WAY:
 288                 if (pp->battle == opposite(card)
 289                     || (card == C_RIGHT_WAY && pp->speed == C_LIMIT)) {
 290                         if (!(card == C_RIGHT_WAY && !isrepair(pp->battle))) {
 291                                 pp->battle = C_GO;
 292                                 pp->can_go = TRUE;
 293                         }
 294                         if (card == C_RIGHT_WAY && pp->speed == C_LIMIT)
 295                                 pp->speed = C_INIT;
 296                         if (pp->new_battle
 297                             || (pp->new_speed && card == C_RIGHT_WAY)) {
 298                                 pp->coups[card - S_CONV] = TRUE;
 299                                 pp->total += SC_COUP;
 300                                 pp->hand_tot += SC_COUP;
 301                                 pp->coupscore += SC_COUP;
 302                         }
 303                 }
 304                 /*
 305                  * if not coup, must pick first
 306                  */
 307                 else if (pp->hand[0] == C_INIT && Topcard > Deck)
 308                         goto mustpick;
 309                 pp->safety[card - S_CONV] = S_PLAYED;
 310                 pp->total += SC_SAFETY;
 311                 pp->hand_tot += SC_SAFETY;
 312                 if ((pp->safescore += SC_SAFETY) == NUM_SAFE * SC_SAFETY) {
 313                         pp->total += SC_ALL_SAFE;
 314                         pp->hand_tot += SC_ALL_SAFE;
 315                 }
 316                 if (card == C_RIGHT_WAY) {
 317                         if (pp->speed == C_LIMIT)
 318                                 pp->speed = C_INIT;
 319                         if (pp->battle == C_STOP || pp->battle == C_INIT) {
 320                                 pp->can_go = TRUE;
 321                                 pp->battle = C_INIT;
 322                         }
 323                         if (!pp->can_go && isrepair(pp->battle))
 324                                 pp->can_go = TRUE;
 325                 }
 326                 Next = -1;
 327                 break;
 328
 329           case C_INIT:
 330                 error("no card there");
 331                 Next = -1;
 332                 break;
 333         }
 334         if (pp == &Player[PLAYER])
 335                 account(card);
 336         pp->hand[Card_no] = C_INIT;
 337         Next = (Next == -1 ? FALSE : TRUE);
 338         return TRUE;
 339 }
 340
 341 getmove()
 342 {
 343         reg char        c, *sp;
 344 #ifdef EXTRAP
 345         static bool     last_ex = FALSE;        /* set if last command was E */
 346
 347         if (last_ex) {
 348                 undoex();
 349                 prboard();
 350                 last_ex = FALSE;
 351         }
 352 #endif
 353         for (;;) {
 354                 prompt(MOVEPROMPT);
 355                 leaveok(Board, FALSE);
 356                 refresh();
 357                 while ((c = readch()) == killchar() || c == erasechar())
 358                         continue;
 359                 if (islower(c))
 360                         c = toupper(c);
 361                 if (isprint(c) && !isspace(c)) {
 362                         addch(c);
 363                         refresh();
 364                 }
 365                 switch (c) {
 366                   case 'P':             /* Pick */
 367                         Movetype = M_DRAW;
 368                         goto ret;
 369                   case 'U':             /* Use Card */
 370                   case 'D':             /* Discard Card */
 371                         if ((Card_no = getcard()) < 0)
 372                                 break;
 373                         Movetype = (c == 'U' ? M_PLAY : M_DISCARD);
 374                         goto ret;
 375                   case 'O':             /* Order */
 376                         Order = !Order;
 377                         if (Window == W_SMALL) {
 378                                 if (!Order)
 379                                         mvwaddstr(Score, 12, 21,
 380                                                   "o: order hand");
 381                                 else
 382                                         mvwaddstr(Score, 12, 21,
 383                                                   "o: stop ordering");
 384                                 wclrtoeol(Score);
 385                         }
 386                         Movetype = M_ORDER;
 387                         goto ret;
 388                   case 'Q':             /* Quit */
 389                         rub();          /* Same as a rubout */
 390                         break;
 391                   case 'W':             /* Window toggle */
 392                         Window = nextwin(Window);
 393                         newscore();
 394                         prscore(TRUE);
 395                         wrefresh(Score);
 396                         break;
 397                   case 'R':             /* Redraw screen */
 398                   case CTRL('L'):
 399                         wrefresh(curscr);
 400                         break;
 401                   case 'S':             /* Save game */
 402                         On_exit = FALSE;
 403                         save();
 404                         break;
 405                   case 'E':             /* Extrapolate */
 406 #ifdef EXTRAP
 407                         if (last_ex)
 408                                 break;
 409                         Finished = TRUE;
 410                         if (Window != W_FULL)
 411                                 newscore();
 412                         prscore(FALSE);
 413                         wrefresh(Score);
 414                         last_ex = TRUE;
 415                         Finished = FALSE;
 416 #else
 417                         error("%c: command not implemented", c);
 418 #endif
 419                         break;
 420                   case '\r':            /* Ignore RETURNs and   */
 421                   case '\n':            /* Line Feeds           */
 422                   case ' ':             /* Spaces               */
 423                   case '\0':            /* and nulls            */
 424                         break;
 425 #ifdef DEBUG
 426                   case 'Z':             /* Debug code */
 427                         if (!Debug && outf == NULL) {
 428                                 char    buf[MAXPATHLEN];
 429
 430                                 prompt(FILEPROMPT);
 431                                 leaveok(Board, FALSE);
 432                                 refresh();
 433                                 sp = buf;
 434                                 while ((*sp = readch()) != '\n') {
 435                                         if (*sp == killchar())
 436                                                 goto over;
 437                                         else if (*sp == erasechar()) {
 438                                                 if (--sp < buf)
 439                                                         sp = buf;
 440                                                 else {
 441                                                         addch('\b');
 442                                                         if (*sp < ' ')
 443                                                             addch('\b');
 444                                                         clrtoeol();
 445                                                 }
 446                                         }
 447                                         else
 448                                                 addstr(unctrl(*sp++));
 449                                         refresh();
 450                                 }
 451                                 *sp = '\0';
 452                                 leaveok(Board, TRUE);
 453                                 if ((outf = fopen(buf, "w")) == NULL)
 454                                         perror(buf);
 455                                 setbuf(outf, (char *)NULL);
 456                         }
 457                         Debug = !Debug;
 458                         break;
 459 #endif
 460                   default:
 461                         error("unknown command: %s", unctrl(c));
 462                         break;
 463                 }
 464         }
 465 ret:
 466         leaveok(Board, TRUE);
 467 }
 468 /*
 469  * return whether or not the player has picked
 470  */
 471 haspicked(pp)
 472 reg PLAY        *pp; {
 473
 474         reg int card;
 475
 476         if (Topcard <= Deck)
 477                 return TRUE;
 478         switch (pp->hand[Card_no]) {
 479           case C_GAS_SAFE:      case C_SPARE_SAFE:
 480           case C_DRIVE_SAFE:    case C_RIGHT_WAY:
 481                 card = 1;
 482                 break;
 483           default:
 484                 card = 0;
 485                 break;
 486         }
 487         return (pp->hand[card] != C_INIT);
 488 }
 489
 490 account(card)
 491 reg CARD        card; {
 492
 493         reg CARD        oppos;
 494
 495         if (card == C_INIT)
 496                 return;
 497         ++Numseen[card];
 498         if (Play == COMP)
 499                 switch (card) {
 500                   case C_GAS_SAFE:
 501                   case C_SPARE_SAFE:
 502                   case C_DRIVE_SAFE:
 503                         oppos = opposite(card);
 504                         Numgos += Numcards[oppos] - Numseen[oppos];
 505                         break;
 506                   case C_CRASH:
 507                   case C_FLAT:
 508                   case C_EMPTY:
 509                   case C_STOP:
 510                         Numgos++;
 511                         break;
 512                 }
 513 }
 514
 515 prompt(promptno)
 516 int     promptno;
 517 {
 518         static char     *names[] = {
 519                                 ">>:Move:",
 520                                 "Really?",
 521                                 "Another hand?",
 522                                 "Another game?",
 523                                 "Save game?",
 524                                 "Same file?",
 525                                 "file:",
 526                                 "Extension?",
 527                                 "Overwrite file?",
 528                         };
 529         static int      last_prompt = -1;
 530
 531         if (promptno == last_prompt)
 532                 move(MOVE_Y, MOVE_X + strlen(names[promptno]) + 1);
 533         else {
 534                 move(MOVE_Y, MOVE_X);
 535                 if (promptno == MOVEPROMPT)
 536                         standout();
 537                 addstr(names[promptno]);
 538                 if (promptno == MOVEPROMPT)
 539                         standend();
 540                 addch(' ');
 541                 last_prompt = promptno;
 542         }
 543         clrtoeol();
 544 }
 545
 546 sort(hand)
 547 reg CARD        *hand;
 548 {
 549         reg CARD        *cp, *tp;
 550         reg CARD        temp;
 551
 552         cp = hand;
 553         hand += HAND_SZ;
 554         for ( ; cp < &hand[-1]; cp++)
 555                 for (tp = cp + 1; tp < hand; tp++)
 556                         if (*cp > *tp) {
 557                                 temp = *cp;
 558                                 *cp = *tp;
 559                                 *tp = temp;
 560                         }
 561 }
 562