main.c

   1 /*
   2  * There used to be a note that said this:
   3  *
   4  * The author - Don Woods - apologises for the style of the code; it
   5  * is a result of running the original Fortran IV source through a
   6  * home-brew Fortran-to-C converter.
   7  *
   8  * Now that the code has been restructured into something much closer
   9  * to idiomatic C, the following is more appropriate:
  10  *
  11  * ESR apologizes for the remaing gotos (now confined to one function
  12  * in this file - there used to be over 350 of them, *everywhere*),
  13  * and for the offensive globals.  Applying the Structured Program
  14  * Theorem can be hard.
  15  */
  16 #define DEFINE_GLOBALS_FROM_INCLUDES
  17 #include <stdlib.h>
  18 #include <stdio.h>
  19 #include <stdbool.h>
  20 #include <getopt.h>
  21 #include <signal.h>
  22 #include <time.h>
  23 #include "advent.h"
  24 #include "database.h"
  25 #include "linenoise/linenoise.h"
  26 #include "newdb.h"
  27
  28 struct game_t game;
  29
  30 long LNLENG, LNPOSN, PARMS[MAXPARMS + 1];
  31 char rawbuf[LINESIZE], INLINE[LINESIZE + 1];
  32
  33 long AMBER, AXE, BACK, BATTERY, BEAR, BIRD, BLOOD,
  34      BOTTLE, CAGE, CAVE, CAVITY, CHAIN, CHASM, CHEST,
  35      CLAM, COINS, DOOR, DPRSSN, DRAGON, DWARF, EGGS,
  36      EMERALD, ENTER, ENTRNC, FIND, FISSURE, FOOD,
  37      GRATE, HINT, INVENT, JADE, KEYS,
  38      KNIFE, LAMP, LOCK, LOOK, MAGAZINE,
  39      MESSAG, MIRROR, NUGGET, NUL, OGRE, OIL, OYSTER,
  40      PEARL, PILLOW, PLANT, PLANT2, PYRAMID, RESER, ROD, ROD2,
  41      RUBY, RUG, SAPPH, SAY, SIGN, SNAKE,
  42      STEPS, STREAM, THROW, TRIDENT, TROLL, TROLL2,
  43      URN, VASE, VEND, VOLCANO, WATER;
  44 long WD1, WD1X, WD2, WD2X;
  45
  46 FILE  *logfp = NULL, *rfp = NULL;
  47 bool oldstyle = false;
  48 bool editline = true;
  49 bool prompt = true;
  50
  51 static void sig_handler(int signo)
  52 {
  53     if (signo == SIGINT) {
  54         if (logfp != NULL)
  55             fflush(logfp);
  56     }
  57     exit(0);
  58 }
  59
  60 /*
  61  * MAIN PROGRAM
  62  *
  63  *  Adventure (rev 2: 20 treasures)
  64  *
  65  *  History: Original idea & 5-treasure version (adventures) by Willie Crowther
  66  *           15-treasure version (adventure) by Don Woods, April-June 1977
  67  *           20-treasure version (rev 2) by Don Woods, August 1978
  68  *              Errata fixed: 78/12/25
  69  *           Revived 2017 as Open Adventure.
  70  */
  71
  72 static bool do_command(FILE *);
  73
  74 int main(int argc, char *argv[])
  75 {
  76     int ch;
  77
  78     /*  Options. */
  79
  80     while ((ch = getopt(argc, argv, "l:or:s")) != EOF) {
  81         switch (ch) {
  82         case 'l':
  83             logfp = fopen(optarg, "w");
  84             if (logfp == NULL)
  85                 fprintf(stderr,
  86                         "advent: can't open logfile %s for write\n",
  87                         optarg);
  88             signal(SIGINT, sig_handler);
  89             break;
  90         case 'o':
  91             oldstyle = true;
  92             editline = prompt = false;
  93             break;
  94         case 'r':
  95             rfp = fopen(optarg, "r");
  96             if (rfp == NULL)
  97                 fprintf(stderr,
  98                         "advent: can't open save file %s for read\n",
  99                         optarg);
 100             signal(SIGINT, sig_handler);
 101             break;
 102         case 's':
 103             editline = false;
 104             break;
 105         default:
 106             fprintf(stderr,
 107                     "Usage: %s [-l logfilename] [-o] [-r restorefilename] [-s] \n", argv[0]);
 108             fprintf(stderr,
 109                     "  where -l creates a log file of your game named as specified'\n");
 110             fprintf(stderr,
 111                     "        -o 'oldstyle' (no prompt, no command editing, displays 'Initialising...')\n");
 112             fprintf(stderr,
 113                     "        -r indicates restoring from specified saved game file\n");
 114             fprintf(stderr,
 115                     "        -s indicates playing with command editing suppressed\n");
 116             exit(-1);
 117             break;
 118         }
 119     }
 120
 121     linenoiseHistorySetMaxLen(350);
 122
 123     /* Logical variables:
 124      *
 125      *  game.closed says whether we're all the way closed
 126      *  game.closng says whether it's closing time yet
 127      *  game.clshnt says whether he's read the clue in the endgame
 128      *  game.lmwarn says whether he's been warned about lamp going dim
 129      *  game.novice says whether he asked for instructions at start-up
 130      *  game.panic says whether he's found out he's trapped in the cave
 131      *  game.wzdark says whether the loc he's leaving was dark */
 132
 133     /* Initialize our LCG PRNG with parameters tested against
 134      * Knuth vol. 2. by the original authors */
 135     game.lcg_a = 1093;
 136     game.lcg_c = 221587;
 137     game.lcg_m = 1048576;
 138     srand(time(NULL));
 139     long seedval = (long)rand();
 140     set_seed(seedval);
 141
 142     /*  Initialize game variables */
 143     initialise();
 144
 145     /*  Start-up, dwarf stuff */
 146     game.zzword = RNDVOC(3, 0);
 147     game.newloc = LOC_START;
 148     game.loc = LOC_START;
 149     game.limit = 330;
 150     if (!rfp) {
 151         game.novice = YES(WELCOME_YOU, CAVE_NEARBY, NO_MESSAGE);
 152         if (game.novice)game.limit = 1000;
 153     } else {
 154         restore(rfp);
 155     }
 156
 157     if (logfp)
 158         fprintf(logfp, "seed %ld\n", seedval);
 159
 160     /* interpret commands until EOF or interrupt */
 161     for (;;) {
 162         if (!do_command(stdin))
 163             break;
 164     }
 165     /* show score and exit */
 166     terminate(quitgame);
 167 }
 168
 169 static bool fallback_handler(char *buf)
 170 /* fallback handler for commands not handled by FORTRANish parser */
 171 {
 172     long sv;
 173     if (sscanf(buf, "seed %ld", &sv) == 1) {
 174         set_seed(sv);
 175         printf("Seed set to %ld\n", sv);
 176         // autogenerated, so don't charge user time for it.
 177         --game.turns;
 178         // here we reconfigure any global game state that uses random numbers
 179         game.zzword = RNDVOC(3, 0);
 180         return true;
 181     }
 182     return false;
 183 }
 184
 185 /*  Check if this loc is eligible for any hints.  If been here
 186  *  long enough, branch to help section (on later page).  Hints
 187  *  all come back here eventually to finish the loop.  Ignore
 188  *  "HINTS" < 4 (special stuff, see database notes).
 189  */
 190 static void checkhints(void)
 191 {
 192     if (COND[game.loc] >= game.conds) {
 193         for (int hint = 1; hint <= HNTMAX; hint++) {
 194             if (game.hinted[hint])
 195                 continue;
 196             if (!CNDBIT(game.loc, hint + HBASE))
 197                 game.hintlc[hint] = -1;
 198             ++game.hintlc[hint];
 199             /*  Come here if he's been long enough at required loc(s) for some
 200              *  unused hint. */
 201             if (game.hintlc[hint] >= HINTS[hint][1]) {
 202                 int i;
 203
 204                 switch (hint - 1) {
 205                 case 0:
 206                     /* cave */
 207                     if (game.prop[GRATE] == 0 && !HERE(KEYS))
 208                         break;
 209                     game.hintlc[hint] = 0;
 210                     return;
 211                 case 1: /* bird */
 212                     if (game.place[BIRD] == game.loc && TOTING(ROD) && game.oldobj == BIRD)
 213                         break;
 214                     return;
 215                 case 2: /* snake */
 216                     if (HERE(SNAKE) && !HERE(BIRD))
 217                         break;
 218                     game.hintlc[hint] = 0;
 219                     return;
 220                 case 3: /* maze */
 221                     if (game.atloc[game.loc] == 0 &&
 222                         game.atloc[game.oldloc] == 0 &&
 223                         game.atloc[game.oldlc2] == 0 &&
 224                         game.holdng > 1)
 225                         break;
 226                     game.hintlc[hint] = 0;
 227                     return;
 228                 case 4: /* dark */
 229                     if (game.prop[EMERALD] != -1 && game.prop[PYRAMID] == -1)
 230                         break;
 231                     game.hintlc[hint] = 0;
 232                     return;
 233                 case 5: /* witt */
 234                     break;
 235                 case 6: /* urn */
 236                     if (game.dflag == 0)
 237                         break;
 238                     game.hintlc[hint] = 0;
 239                     return;
 240                 case 7: /* woods */
 241                     if (game.atloc[game.loc] == 0 &&
 242                         game.atloc[game.oldloc] == 0 &&
 243                         game.atloc[game.oldlc2] == 0)
 244                         break;
 245                     return;
 246                 case 8: /* ogre */
 247                     i = ATDWRF(game.loc);
 248                     if (i < 0) {
 249                         game.hintlc[hint] = 0;
 250                         return;
 251                     }
 252                     if (HERE(OGRE) && i == 0)
 253                         break;
 254                     return;
 255                 case 9: /* jade */
 256                     if (game.tally == 1 && game.prop[JADE] < 0)
 257                         break;
 258                     game.hintlc[hint] = 0;
 259                     return;
 260                 default:
 261                     BUG(HINT_NUMBER_EXCEEDS_GOTO_LIST);
 262                     break;
 263                 }
 264
 265                 /* Fall through to hint display */
 266                 game.hintlc[hint] = 0;
 267                 if (!YES(HINTS[hint][3], NO_MESSAGE, OK_MAN))
 268                     return;
 269                 SETPRM(1, HINTS[hint][2], HINTS[hint][2]);
 270                 RSPEAK(HINT_COST);
 271                 game.hinted[hint] = YES(WANT_HINT, HINTS[hint][4], OK_MAN);
 272                 if (game.hinted[hint] && game.limit > WARNTIME)
 273                     game.limit += WARNTIME * HINTS[hint][2];
 274             }
 275         }
 276     }
 277 }
 278
 279 static bool spotted_by_pirate(int i)
 280 {
 281     if (i != PIRATE)
 282         return false;
 283
 284     /*  The pirate's spotted him.  He leaves him alone once we've
 285      *  found chest.  K counts if a treasure is here.  If not, and
 286      *  tally=1 for an unseen chest, let the pirate be spotted.  Note
 287      *  that game.place[CHEST] = NOWHERE might mean that he's thrown
 288      *  it to the troll, but in that case he's seen the chest
 289      *  (game.prop=0). */
 290     if (game.loc == game.chloc || game.prop[CHEST] >= 0)
 291         return true;
 292     int snarfed = 0;
 293     bool movechest = false, robplayer = false;
 294     for (int treasure = MINTRS; treasure <= MAXTRS; treasure++) {
 295         /*  Pirate won't take pyramid from plover room or dark
 296          *  room (too easy!). */
 297         if (treasure == PYRAMID && (game.loc == PLAC[PYRAMID] || game.loc == PLAC[EMERALD])) {
 298             continue;
 299         }
 300         if (TOTING(treasure) || HERE(treasure))
 301             ++snarfed;
 302         if (TOTING(treasure)) {
 303             movechest = true;
 304             robplayer = true;
 305         }
 306     }
 307     /* Force chest placement before player finds last treasure */
 308     if (game.tally == 1 && snarfed == 0 && game.place[CHEST] == NOWHERE && HERE(LAMP) && game.prop[LAMP] == 1) {
 309         RSPEAK(PIRATE_SPOTTED);
 310         movechest = true;
 311     }
 312     /* Do things in this order (chest move before robbery) so chest is listed
 313      * last at the maze location. */
 314     if (movechest) {
 315         MOVE(CHEST, game.chloc);
 316         MOVE(MESSAG, game.chloc2);
 317         game.dloc[PIRATE] = game.chloc;
 318         game.odloc[PIRATE] = game.chloc;
 319         game.dseen[PIRATE] = false;
 320     } else {
 321         /* You might get a hint of the pirate's presence even if the
 322          * chest doesn't move... */
 323         if (game.odloc[PIRATE] != game.dloc[PIRATE] && PCT(20))
 324             RSPEAK(PIRATE_RUSTLES);
 325     }
 326     if (robplayer) {
 327         RSPEAK(PIRATE_POUNCES);
 328         for (int treasure = MINTRS; treasure <= MAXTRS; treasure++) {
 329             if (!(treasure == PYRAMID && (game.loc == PLAC[PYRAMID] || game.loc == PLAC[EMERALD]))) {
 330                 if (AT(treasure) && game.fixed[treasure] == 0)
 331                     CARRY(treasure, game.loc);
 332                 if (TOTING(treasure))
 333                     DROP(treasure, game.chloc);
 334             }
 335         }
 336     }
 337
 338     return true;
 339 }
 340
 341 static bool dwarfmove(void)
 342 /* Dwarves move.  Return true if player survives, false if he dies. */
 343 {
 344     int kk, stick, attack;
 345     long tk[21];
 346
 347     /*  Dwarf stuff.  See earlier comments for description of
 348      *  variables.  Remember sixth dwarf is pirate and is thus
 349      *  very different except for motion rules. */
 350
 351     /*  First off, don't let the dwarves follow him into a pit or
 352      *  a wall.  Activate the whole mess the first time he gets as
 353      *  far as the hall of mists (loc 15).  If game.newloc is
 354      *  forbidden to pirate (in particular, if it's beyond the
 355      *  troll bridge), bypass dwarf stuff.  That way pirate can't
 356      *  steal return toll, and dwarves can't meet the bear.  Also
 357      *  means dwarves won't follow him into dead end in maze, but
 358      *  c'est la vie.  They'll wait for him outside the dead
 359      *  end. */
 360     if (game.loc == 0 || FORCED(game.loc) || CNDBIT(game.newloc, NOARRR))
 361         return true;
 362
 363     /* Dwarf activity level ratchets up */
 364     if (game.dflag == 0) {
 365         if (INDEEP(game.loc))
 366             game.dflag = 1;
 367         return true;
 368     }
 369
 370     /*  When we encounter the first dwarf, we kill 0, 1, or 2 of
 371      *  the 5 dwarves.  If any of the survivors is at loc,
 372      *  replace him with the alternate. */
 373     if (game.dflag == 1) {
 374         if (!INDEEP(game.loc) || (PCT(95) && (!CNDBIT(game.loc, NOBACK) || PCT(85))))
 375             return true;
 376         game.dflag = 2;
 377         for (int i = 1; i <= 2; i++) {
 378             int j = 1 + randrange(NDWARVES - 1);
 379             if (PCT(50))
 380                 game.dloc[j] = 0;
 381         }
 382         for (int i = 1; i <= NDWARVES - 1; i++) {
 383             if (game.dloc[i] == game.loc)
 384                 game.dloc[i] = DALTLC;
 385             game.odloc[i] = game.dloc[i];
 386         }
 387         RSPEAK(DWARF_RAN);
 388         DROP(AXE, game.loc);
 389         return true;
 390     }
 391
 392     /*  Things are in full swing.  Move each dwarf at random,
 393      *  except if he's seen us he sticks with us.  Dwarves stay
 394      *  deep inside.  If wandering at random, they don't back up
 395      *  unless there's no alternative.  If they don't have to
 396      *  move, they attack.  And, of course, dead dwarves don't do
 397      *  much of anything. */
 398     game.dtotal = 0;
 399     attack = 0;
 400     stick = 0;
 401     for (int i = 1; i <= NDWARVES; i++) {
 402         if (game.dloc[i] == 0)
 403             continue;
 404         /*  Fill tk array with all the places this dwarf might go. */
 405         int j = 1;
 406         kk = KEY[game.dloc[i]];
 407         if (kk != 0)
 408             do {
 409                 game.newloc = MOD(labs(TRAVEL[kk]) / 1000, 1000);
 410                 /* Have we avoided a dwarf encounter? */
 411                 bool avoided = (SPECIAL(game.newloc) ||
 412                                 !INDEEP(game.newloc) ||
 413                                 game.newloc == game.odloc[i] ||
 414                                 (j > 1 && game.newloc == tk[j - 1]) ||
 415                                 j >= 20 ||
 416                                 game.newloc == game.dloc[i] ||
 417                                 FORCED(game.newloc) ||
 418                                 (i == PIRATE && CNDBIT(game.newloc, NOARRR)) ||
 419                                 labs(TRAVEL[kk]) / 1000000 == 100);
 420                 if (!avoided) {
 421                     tk[j++] = game.newloc;
 422                 }
 423                 ++kk;
 424             } while
 425             (TRAVEL[kk - 1] >= 0);
 426         tk[j] = game.odloc[i];
 427         if (j >= 2)
 428             --j;
 429         j = 1 + randrange(j);
 430         game.odloc[i] = game.dloc[i];
 431         game.dloc[i] = tk[j];
 432         game.dseen[i] = (game.dseen[i] && INDEEP(game.loc)) || (game.dloc[i] == game.loc || game.odloc[i] == game.loc);
 433         if (!game.dseen[i]) continue;
 434         game.dloc[i] = game.loc;
 435         if (spotted_by_pirate(i))
 436             continue;
 437         /* This threatening little dwarf is in the room with him! */
 438         ++game.dtotal;
 439         if (game.odloc[i] == game.dloc[i]) {
 440             ++attack;
 441             if (game.knfloc >= 0)
 442                 game.knfloc = game.loc;
 443             if (randrange(1000) < 95 * (game.dflag - 2))
 444                 ++stick;
 445         }
 446     }
 447
 448     /*  Now we know what's happening.  Let's tell the poor sucker about it.
 449      *  Note that various of the "knife" messages must have specific relative
 450      *  positions in the RSPEAK database. */
 451     if (game.dtotal == 0)
 452         return true;
 453     SETPRM(1, game.dtotal, 0);
 454     RSPEAK(DWARF_PACK + 1 / game.dtotal);       /* FIXME: Arithmetic on message number */
 455     if (attack == 0)
 456         return true;
 457     if (game.dflag == 2)game.dflag = 3;
 458     SETPRM(1, attack, 0);
 459     int k = 6;
 460     if (attack > 1)k = THROWN_KNIVES;
 461     RSPEAK(k);
 462     SETPRM(1, stick, 0);
 463     RSPEAK(k + 1 + 2 / (1 + stick));    /* FIXME: Arithmetic on message number */
 464     if (stick == 0)
 465         return true;
 466     game.oldlc2 = game.loc;
 467     return false;
 468 }
 469
 470 /*  "You're dead, Jim."
 471  *
 472  *  If the current loc is zero, it means the clown got himself killed.
 473  *  We'll allow this maxdie times.  MAXDIE is automatically set based
 474  *  on the number of snide messages available.  Each death results in
 475  *  a message (81, 83, etc.)  which offers reincarnation; if accepted,
 476  *  this results in message 82, 84, etc.  The last time, if he wants
 477  *  another chance, he gets a snide remark as we exit.  When
 478  *  reincarnated, all objects being carried get dropped at game.oldlc2
 479  *  (presumably the last place prior to being killed) without change
 480  *  of props.  the loop runs backwards to assure that the bird is
 481  *  dropped before the cage.  (this kluge could be changed once we're
 482  *  sure all references to bird and cage are done by keywords.)  The
 483  *  lamp is a special case (it wouldn't do to leave it in the cave).
 484  *  It is turned off and left outside the building (only if he was
 485  *  carrying it, of course).  He himself is left inside the building
 486  *  (and heaven help him if he tries to xyzzy back into the cave
 487  *  without the lamp!).  game.oldloc is zapped so he can't just
 488  *  "retreat". */
 489
 490 static void croak(void)
 491 /*  Okay, he's dead.  Let's get on with it. */
 492 {
 493     ++game.numdie;
 494     if (game.closng) {
 495         /*  He died during closing time.  No resurrection.  Tally up a
 496          *  death and exit. */
 497         RSPEAK(DEATH_CLOSING);
 498         terminate(endgame);
 499     }
 500     /* FIXME: Arithmetic on message numbers */
 501     else if (game.numdie == MAXDIE || !YES(WATCH_IT + game.numdie * 2, WHICH_WAY + game.numdie * 2, OK_MAN))
 502         terminate(endgame);
 503     else {
 504         game.place[WATER] = game.place[OIL] = NOWHERE;
 505         if (TOTING(LAMP))
 506             game.prop[LAMP] = 0;
 507         for (int j = 1; j <= NOBJECTS; j++) {
 508             int i = NOBJECTS + 1 - j;
 509             if (TOTING(i)) {
 510                 /* Always leave lamp where it's accessible aboveground */
 511                 DROP(i, (i == LAMP) ? LOC_START : game.oldlc2);
 512             }
 513         }
 514         game.loc = LOC_BUILDING;
 515         game.oldloc = game.loc;
 516     }
 517 }
 518
 519 /*  Given the current location in "game.loc", and a motion verb number in
 520  *  "motion", put the new location in "game.newloc".  The current loc is saved
 521  *  in "game.oldloc" in case he wants to retreat.  The current
 522  *  game.oldloc is saved in game.oldlc2, in case he dies.  (if he
 523  *  does, game.newloc will be limbo, and game.oldloc will be what killed
 524  *  him, so we need game.oldlc2, which is the last place he was
 525  *  safe.) */
 526
 527 static bool playermove(token_t verb, int motion)
 528 {
 529     int scratchloc, k2, kk = KEY[game.loc];
 530     game.newloc = game.loc;
 531     if (kk == 0)
 532         BUG(LOCATION_HAS_NO_TRAVEL_ENTRIES);
 533     if (motion == NUL)
 534         return true;
 535     else if (motion == BACK) {
 536         /*  Handle "go back".  Look for verb which goes from game.loc to
 537          *  game.oldloc, or to game.oldlc2 If game.oldloc has forced-motion.
 538          *  k2 saves entry -> forced loc -> previous loc. */
 539         motion = game.oldloc;
 540         if (FORCED(motion))
 541             motion = game.oldlc2;
 542         game.oldlc2 = game.oldloc;
 543         game.oldloc = game.loc;
 544         k2 = 0;
 545         if (motion == game.loc)k2 = FORGOT_PATH;
 546         if (CNDBIT(game.loc, NOBACK))k2 = TWIST_TURN;
 547         if (k2 == 0) {
 548             for (;;) {
 549                 scratchloc = MOD((labs(TRAVEL[kk]) / 1000), 1000);
 550                 if (scratchloc != motion) {
 551                     if (!SPECIAL(scratchloc)) {
 552                         if (FORCED(scratchloc) && MOD((labs(TRAVEL[KEY[scratchloc]]) / 1000), 1000) == motion)
 553                             k2 = kk;
 554                     }
 555                     if (TRAVEL[kk] >= 0) {
 556                         ++kk;
 557                         continue;
 558                     }
 559                     kk = k2;
 560                     if (kk == 0) {
 561                         RSPEAK(NOT_CONNECTED);
 562                         return true;
 563                     }
 564                 }
 565
 566                 motion = MOD(labs(TRAVEL[kk]), 1000);
 567                 kk = KEY[game.loc];
 568                 break; /* fall through to ordinary travel */
 569             }
 570         } else {
 571             RSPEAK(k2);
 572             return true;
 573         }
 574     } else if (motion == LOOK) {
 575         /*  Look.  Can't give more detail.  Pretend it wasn't dark
 576          *  (though it may now be dark) so he won't fall into a
 577          *  pit while staring into the gloom. */
 578         if (game.detail < 3)
 579             RSPEAK(NO_MORE_DETAIL);
 580         ++game.detail;
 581         game.wzdark = false;
 582         game.abbrev[game.loc] = 0;
 583         return true;
 584     } else if (motion == CAVE) {
 585         /*  Cave.  Different messages depending on whether above ground. */
 586         RSPEAK((OUTSID(game.loc) && game.loc != LOC_GRATE) ? FOLLOW_STREAM : NEED_DETAIL);
 587         return true;
 588     } else {
 589         /* none of the specials */
 590         game.oldlc2 = game.oldloc;
 591         game.oldloc = game.loc;
 592     }
 593
 594     /* ordinary travel */
 595     for (;;) {
 596         scratchloc = labs(TRAVEL[kk]);
 597         if (MOD(scratchloc, 1000) == 1 || MOD(scratchloc, 1000) == motion)
 598             break;
 599         if (TRAVEL[kk] < 0) {
 600             /* FIXME: Magic numbers! */
 601             /*  Non-applicable motion.  Various messages depending on
 602              *  word given. */
 603             int spk = CANT_APPLY;
 604             if (motion >= 43 && motion <= 50)spk = BAD_DIRECTION;
 605             if (motion == 29 || motion == 30)spk = BAD_DIRECTION;
 606             if (motion == 7 || motion == 36 || motion == 37)spk = UNSURE_FACING;
 607             if (motion == 11 || motion == 19)spk = NO_INOUT_HERE;
 608             if (verb == FIND || verb == INVENT)spk = NEreplace;
 609             if (motion == 62 || motion == 65)spk = NOTHING_HAPPENS;
 610             if (motion == 17)spk = WHICH_WAY;
 611             RSPEAK(spk);
 612             return true;
 613         }
 614         ++kk;
 615     }
 616     scratchloc = scratchloc / 1000;
 617
 618     do {
 619         /*
 620          * (ESR) This special-travel loop may have to be repeated if it includes
 621          * the plover passage.  Same deal for any future cases wgerw we beed to
 622          * block travel and then redo it once the blocking condition has been
 623          * removed.
 624          */
 625         for (;;) {
 626             game.newloc = scratchloc / 1000;
 627             motion = MOD(game.newloc, 100);
 628             if (!SPECIAL(game.newloc)) {
 629                 if (game.newloc <= 100) {
 630                     if (game.newloc == 0 || PCT(game.newloc))
 631                         break;
 632                     /* else fall through */
 633                 }
 634                 if (TOTING(motion) || (game.newloc > 200 && AT(motion)))
 635                     break;
 636                 /* else fall through */
 637             } else if (game.prop[motion] != game.newloc / 100 - 3)
 638                 break;
 639 L12:
 640             do {
 641                 if (TRAVEL[kk] < 0)
 642                     BUG(CONDITIONAL_TRAVEL_ENTRY_WITH_NO_ALTERATION);
 643                 ++kk;
 644                 game.newloc = labs(TRAVEL[kk]) / 1000;
 645             } while
 646             (game.newloc == scratchloc);
 647             scratchloc = game.newloc;
 648         }
 649
 650         game.newloc = MOD(scratchloc, 1000);
 651         if (!SPECIAL(game.newloc))
 652             return true;
 653         if (game.newloc <= 500) {
 654             game.newloc = game.newloc - SPECIALBASE;
 655             switch (game.newloc) {
 656             case 1:
 657                 /*  Travel 301.  Plover-alcove passage.  Can carry only
 658                  *  emerald.  Note: travel table must include "useless"
 659                  *  entries going through passage, which can never be used for
 660                  *  actual motion, but can be spotted by "go back". */
 661                 /* FIXME: Arithmetic on location numbers */
 662                 game.newloc = 99 + 100 - game.loc;
 663                 if (game.holdng > 1 || (game.holdng == 1 && !TOTING(EMERALD))) {
 664                     game.newloc = game.loc;
 665                     RSPEAK(MUST_DROP);
 666                 }
 667                 return true;
 668             case 2:
 669                 /*  Travel 302.  Plover transport.  Drop the emerald (only use
 670                  *  special travel if toting it), so he's forced to use the
 671                  *  plover-passage to get it out.  Having dropped it, go back and
 672                  *  pretend he wasn't carrying it after all. */
 673                 DROP(EMERALD, game.loc);
 674                 goto L12;
 675             case 3:
 676                 /*  Travel 303.  Troll bridge.  Must be done only as special
 677                  *  motion so that dwarves won't wander across and encounter
 678                  *  the bear.  (They won't follow the player there because
 679                  *  that region is forbidden to the pirate.)  If
 680                  *  game.prop(TROLL)=1, he's crossed since paying, so step out
 681                  *  and block him.  (standard travel entries check for
 682                  *  game.prop(TROLL)=0.)  Special stuff for bear. */
 683                 if (game.prop[TROLL] == 1) {
 684                     PSPEAK(TROLL, 1);
 685                     game.prop[TROLL] = 0;
 686                     MOVE(TROLL2, 0);
 687                     MOVE(TROLL2 + NOBJECTS, 0);
 688                     MOVE(TROLL, PLAC[TROLL]);
 689                     MOVE(TROLL + NOBJECTS, FIXD[TROLL]);
 690                     JUGGLE(CHASM);
 691                     game.newloc = game.loc;
 692                     return true;
 693                 } else {
 694                     game.newloc = PLAC[TROLL] + FIXD[TROLL] - game.loc;
 695                     if (game.prop[TROLL] == 0)game.prop[TROLL] = 1;
 696                     if (!TOTING(BEAR)) return true;
 697                     RSPEAK(BRIDGE_COLLAPSE);
 698                     game.prop[CHASM] = 1;
 699                     game.prop[TROLL] = 2;
 700                     DROP(BEAR, game.newloc);
 701                     game.fixed[BEAR] = -1;
 702                     game.prop[BEAR] = 3;
 703                     game.oldlc2 = game.newloc;
 704                     croak();
 705                 }
 706             }
 707             BUG(SPECIAL_TRAVEL_500_GT_L_GT_300_EXCEEDS_GOTO_LIST);
 708         }
 709     } while
 710     (false);
 711     /* FIXME: Arithmetic on location number, becoming a message number */
 712     RSPEAK(game.newloc - 500);
 713     game.newloc = game.loc;
 714     return true;
 715 }
 716
 717 static bool closecheck(void)
 718 /*  Handle the closing of the cave.  The cave closes "clock1" turns
 719  *  after the last treasure has been located (including the pirate's
 720  *  chest, which may of course never show up).  Note that the
 721  *  treasures need not have been taken yet, just located.  Hence
 722  *  clock1 must be large enough to get out of the cave (it only ticks
 723  *  while inside the cave).  When it hits zero, we branch to 10000 to
 724  *  start closing the cave, and then sit back and wait for him to try
 725  *  to get out.  If he doesn't within clock2 turns, we close the cave;
 726  *  if he does try, we assume he panics, and give him a few additional
 727  *  turns to get frantic before we close.  When clock2 hits zero, we
 728  *  branch to 11000 to transport him into the final puzzle.  Note that
 729  *  the puzzle depends upon all sorts of random things.  For instance,
 730  *  there must be no water or oil, since there are beanstalks which we
 731  *  don't want to be able to water, since the code can't handle it.
 732  *  Also, we can have no keys, since there is a grate (having moved
 733  *  the fixed object!) there separating him from all the treasures.
 734  *  Most of these problems arise from the use of negative prop numbers
 735  *  to suppress the object descriptions until he's actually moved the
 736  *  objects. */
 737 {
 738     if (game.tally == 0 && INDEEP(game.loc) && game.loc != 33)
 739         --game.clock1;
 740
 741     /*  When the first warning comes, we lock the grate, destroy
 742      *  the bridge, kill all the dwarves (and the pirate), remove
 743      *  the troll and bear (unless dead), and set "closng" to
 744      *  true.  Leave the dragon; too much trouble to move it.
 745      *  from now until clock2 runs out, he cannot unlock the
 746      *  grate, move to any location outside the cave, or create
 747      *  the bridge.  Nor can he be resurrected if he dies.  Note
 748      *  that the snake is already gone, since he got to the
 749      *  treasure accessible only via the hall of the mountain
 750      *  king. Also, he's been in giant room (to get eggs), so we
 751      *  can refer to it.  Also also, he's gotten the pearl, so we
 752      *  know the bivalve is an oyster.  *And*, the dwarves must
 753      *  have been activated, since we've found chest. */
 754     if (game.clock1 == 0) {
 755         game.prop[GRATE] = 0;
 756         game.prop[FISSURE] = 0;
 757         for (int i = 1; i <= NDWARVES; i++) {
 758             game.dseen[i] = false;
 759             game.dloc[i] = 0;
 760         }
 761         MOVE(TROLL, 0);
 762         MOVE(TROLL + NOBJECTS, 0);
 763         MOVE(TROLL2, PLAC[TROLL]);
 764         MOVE(TROLL2 + NOBJECTS, FIXD[TROLL]);
 765         JUGGLE(CHASM);
 766         if (game.prop[BEAR] != 3)DESTROY(BEAR);
 767         game.prop[CHAIN] = 0;
 768         game.fixed[CHAIN] = 0;
 769         game.prop[AXE] = 0;
 770         game.fixed[AXE] = 0;
 771         RSPEAK(CAVE_CLOSING);
 772         game.clock1 = -1;
 773         game.closng = true;
 774         return true;
 775     } else if (game.clock1 < 0)
 776         --game.clock2;
 777     if (game.clock2 == 0) {
 778         /*  Once he's panicked, and clock2 has run out, we come here
 779          *  to set up the storage room.  The room has two locs,
 780          *  hardwired as 115 (ne) and 116 (sw).  At the ne end, we
 781          *  place empty bottles, a nursery of plants, a bed of
 782          *  oysters, a pile of lamps, rods with stars, sleeping
 783          *  dwarves, and him.  At the sw end we place grate over
 784          *  treasures, snake pit, covey of caged birds, more rods, and
 785          *  pillows.  A mirror stretches across one wall.  Many of the
 786          *  objects come from known locations and/or states (e.g. the
 787          *  snake is known to have been destroyed and needn't be
 788          *  carried away from its old "place"), making the various
 789          *  objects be handled differently.  We also drop all other
 790          *  objects he might be carrying (lest he have some which
 791          *  could cause trouble, such as the keys).  We describe the
 792          *  flash of light and trundle back. */
 793         game.prop[BOTTLE] = PUT(BOTTLE, LOC_NE, 1);
 794         game.prop[PLANT] = PUT(PLANT, LOC_NE, 0);
 795         game.prop[OYSTER] = PUT(OYSTER, LOC_NE, 0);
 796         OBJTXT[OYSTER] = 3;
 797         game.prop[LAMP] = PUT(LAMP, LOC_NE, 0);
 798         game.prop[ROD] = PUT(ROD, LOC_NE, 0);
 799         game.prop[DWARF] = PUT(DWARF, LOC_NE, 0);
 800         game.loc = LOC_NE;
 801         game.oldloc = LOC_NE;
 802         game.newloc = LOC_NE;
 803         /*  Leave the grate with normal (non-negative) property.
 804          *  Reuse sign. */
 805         PUT(GRATE, LOC_SW, 0);
 806         PUT(SIGN, LOC_SW, 0);
 807         ++OBJTXT[SIGN];
 808         game.prop[SNAKE] = PUT(SNAKE, LOC_SW, 1);
 809         game.prop[BIRD] = PUT(BIRD, LOC_SW, 1);
 810         game.prop[CAGE] = PUT(CAGE, LOC_SW, 0);
 811         game.prop[ROD2] = PUT(ROD2, LOC_SW, 0);
 812         game.prop[PILLOW] = PUT(PILLOW, LOC_SW, 0);
 813
 814         game.prop[MIRROR] = PUT(MIRROR, LOC_NE, 0);
 815         game.fixed[MIRROR] = LOC_SW;
 816
 817         for (int i = 1; i <= NOBJECTS; i++) {
 818             if (TOTING(i))
 819                 DESTROY(i);
 820         }
 821
 822         RSPEAK(CAVE_CLOSED);
 823         game.closed = true;
 824         return true;
 825     }
 826
 827     return false;
 828 }
 829
 830 static void lampcheck(void)
 831 /* Check game limit and lamp timers */
 832 {
 833     if (game.prop[LAMP] == 1)
 834         --game.limit;
 835
 836     /*  Another way we can force an end to things is by having the
 837      *  lamp give out.  When it gets close, we come here to warn
 838      *  him.  First following ar, if the lamp and fresh batteries are
 839      *  here, in which case we replace the batteries and continue.
 840      *  Second is for other cases of lamp dying.  12400 is when it
 841      *  goes out.  Even then, he can explore outside for a while
 842      *  if desired. */
 843     if (game.limit <= WARNTIME && HERE(BATTERY) && game.prop[BATTERY] == 0 && HERE(LAMP)) {
 844         RSPEAK(REPLACE_BATTERYIES);
 845         game.prop[BATTERY] = 1;
 846         if (TOTING(BATTERY))
 847             DROP(BATTERY, game.loc);
 848         game.limit = game.limit + 2500;
 849         game.lmwarn = false;
 850     } else if (game.limit == 0) {
 851         game.limit = -1;
 852         game.prop[LAMP] = 0;
 853         if (HERE(LAMP))
 854             RSPEAK(LAMP_OUT);
 855     } else if (game.limit <= WARNTIME) {
 856         if (!game.lmwarn && HERE(LAMP)) {
 857             game.lmwarn = true;
 858             int spk = GET_BATTERYIES;
 859             if (game.place[BATTERY] == NOWHERE)spk = LAMP_DIM;
 860             if (game.prop[BATTERY] == 1)spk = MISSING_BATTERYIES;
 861             RSPEAK(spk);
 862         }
 863     }
 864 }
 865
 866 static void listobjects(void)
 867 /*  Print out descriptions of objects at this location.  If
 868  *  not closing and property value is negative, tally off
 869  *  another treasure.  Rug is special case; once seen, its
 870  *  game.prop is 1 (dragon on it) till dragon is killed.
 871  *  Similarly for chain; game.prop is initially 1 (locked to
 872  *  bear).  These hacks are because game.prop=0 is needed to
 873  *  get full score. */
 874 {
 875     if (!DARK(game.loc)) {
 876         ++game.abbrev[game.loc];
 877         for (int i = game.atloc[game.loc]; i != 0; i = game.link[i]) {
 878             long obj = i;
 879             if (obj > NOBJECTS)obj = obj - NOBJECTS;
 880             if (obj == STEPS && TOTING(NUGGET))
 881                 continue;
 882             if (game.prop[obj] < 0) {
 883                 if (game.closed)
 884                     continue;
 885                 game.prop[obj] = 0;
 886                 if (obj == RUG || obj == CHAIN)
 887                     game.prop[obj] = 1;
 888                 --game.tally;
 889                 /*  Note: There used to be a test here to see whether the
 890                  *  player had blown it so badly that he could never ever see
 891                  *  the remaining treasures, and if so the lamp was zapped to
 892                  *  35 turns.  But the tests were too simple-minded; things
 893                  *  like killing the bird before the snake was gone (can never
 894                  *  see jewelry), and doing it "right" was hopeless.  E.G.,
 895                  *  could cross troll bridge several times, using up all
 896                  *  available treasures, breaking vase, using coins to buy
 897                  *  batteries, etc., and eventually never be able to get
 898                  *  across again.  If bottle were left on far side, could then
 899                  *  never get eggs or trident, and the effects propagate.  So
 900                  *  the whole thing was flushed.  anyone who makes such a
 901                  *  gross blunder isn't likely to find everything else anyway
 902                  *  (so goes the rationalisation). */
 903             }
 904             int kk = game.prop[obj];
 905             if (obj == STEPS && game.loc == game.fixed[STEPS])
 906                 kk = 1;
 907             PSPEAK(obj, kk);
 908         }
 909     }
 910 }
 911
 912 static bool do_command(FILE *cmdin)
 913 /* Get and execute a command */
 914 {
 915     long verb = 0, V1, V2;
 916     long kmod, defn;
 917     static long igo = 0;
 918     static long obj = 0;
 919     enum speechpart part;
 920
 921     /*  Can't leave cave once it's closing (except by main office). */
 922     if (OUTSID(game.newloc) && game.newloc != 0 && game.closng) {
 923         RSPEAK(EXIT_CLOSED);
 924         game.newloc = game.loc;
 925         if (!game.panic)game.clock2 = PANICTIME;
 926         game.panic = true;
 927     }
 928
 929     /*  See if a dwarf has seen him and has come from where he
 930      *  wants to go.  If so, the dwarf's blocking his way.  If
 931      *  coming from place forbidden to pirate (dwarves rooted in
 932      *  place) let him get out (and attacked). */
 933     if (game.newloc != game.loc && !FORCED(game.loc) && !CNDBIT(game.loc, NOARRR)) {
 934         for (size_t i = 1; i <= NDWARVES - 1; i++) {
 935             if (game.odloc[i] == game.newloc && game.dseen[i]) {
 936                 game.newloc = game.loc;
 937                 RSPEAK(DWARF_BLOCK);
 938                 break;
 939             }
 940         }
 941     }
 942     game.loc = game.newloc;
 943
 944     if (!dwarfmove())
 945         croak();
 946
 947     /*  Describe the current location and (maybe) get next command. */
 948
 949     for (;;) {
 950         if (game.loc == 0)
 951             croak();
 952         const char* msg = locations[game.loc].description.small;
 953         if (MOD(game.abbrev[game.loc], game.abbnum) == 0 || msg == 0)
 954             msg = locations[game.loc].description.big;
 955         if (!FORCED(game.loc) && DARK(game.loc)) {
 956             /*  The easiest way to get killed is to fall into a pit in
 957              *  pitch darkness. */
 958             if (game.wzdark && PCT(35)) {
 959                 RSPEAK(PIT_FALL);
 960                 game.oldlc2 = game.loc;
 961                 croak();
 962                 continue;       /* back to top of main interpreter loop */
 963             }
 964             msg = arbitrary_messages[PITCH_DARK];
 965         }
 966         if (TOTING(BEAR))RSPEAK(TAME_BEAR);
 967         speak(msg);
 968         if (FORCED(game.loc)) {
 969             if (playermove(verb, 1))
 970                 return true;
 971             else
 972                 continue;       /* back to top of main interpreter loop */
 973         }
 974         if (game.loc == 33 && PCT(25) && !game.closng)RSPEAK(SAYS_PLUGH);
 975
 976         listobjects();
 977
 978 L2012:
 979         verb = 0;
 980         game.oldobj = obj;
 981         obj = 0;
 982
 983 L2600:
 984         checkhints();
 985
 986         /*  If closing time, check for any objects being toted with
 987          *  game.prop < 0 and set the prop to -1-game.prop.  This way
 988          *  objects won't be described until they've been picked up
 989          *  and put down separate from their respective piles.  Don't
 990          *  tick game.clock1 unless well into cave (and not at Y2). */
 991         if (game.closed) {
 992             if (game.prop[OYSTER] < 0 && TOTING(OYSTER))
 993                 PSPEAK(OYSTER, 1);
 994             for (size_t i = 1; i <= NOBJECTS; i++) {
 995                 if (TOTING(i) && game.prop[i] < 0)
 996                     game.prop[i] = -1 - game.prop[i];
 997             }
 998         }
 999         game.wzdark = DARK(game.loc);
1000         if (game.knfloc > 0 && game.knfloc != game.loc)
1001             game.knfloc = 0;
1002
1003         /* This is where we get a new command from the user */
1004         if (!GETIN(cmdin, &WD1, &WD1X, &WD2, &WD2X))
1005             return false;
1006
1007         /*  Every input, check "game.foobar" flag.  If zero, nothing's
1008          *  going on.  If pos, make neg.  If neg, he skipped a word,
1009          *  so make it zero. */
1010 L2607:
1011         game.foobar = (game.foobar > 0 ? -game.foobar : 0);
1012         ++game.turns;
1013         if (game.turns == game.thresh) {
1014             speak(turn_threshold_messages[game.trndex]);
1015             game.trnluz = game.trnluz + TRNVAL[game.trndex] / 100000;
1016             ++game.trndex;
1017             game.thresh = -1;
1018             if (game.trndex <= TRNVLS)
1019                 game.thresh = MOD(TRNVAL[game.trndex], 100000) + 1;
1020         }
1021         if (verb == SAY && WD2 > 0)
1022             verb = 0;
1023         if (verb == SAY) {
1024             part = transitive;
1025             goto Laction;
1026         }
1027         if (closecheck()) {
1028             if (game.closed)
1029                 return true;
1030         } else
1031             lampcheck();
1032
1033         V1 = VOCAB(WD1, -1);
1034         V2 = VOCAB(WD2, -1);
1035         if (V1 == ENTER && (V2 == STREAM || V2 == 1000 + WATER)) {
1036             if (LIQLOC(game.loc) == WATER) {
1037                 RSPEAK(FEET_WET);
1038             } else {
1039                 RSPEAK(WHERE_QUERY);
1040             }
1041             goto L2012;
1042         }
1043         if (V1 == ENTER && WD2 > 0) {
1044             WD1 = WD2;
1045             WD1X = WD2X;
1046             WD2 = 0;
1047         } else {
1048             if (!((V1 != 1000 + WATER && V1 != 1000 + OIL) ||
1049                   (V2 != 1000 + PLANT && V2 != 1000 + DOOR))) {
1050                 if (AT(V2 - 1000))
1051                     WD2 = MAKEWD(16152118);
1052             }
1053             if (V1 == 1000 + CAGE && V2 == 1000 + BIRD && HERE(CAGE) && HERE(BIRD))
1054                 WD1 = MAKEWD(301200308);
1055         }
1056 L2620:
1057         if (WD1 == MAKEWD(23051920)) {
1058             ++game.iwest;
1059             if (game.iwest == 10)
1060                 RSPEAK(W_IS_WEST);
1061         }
1062         if (WD1 == MAKEWD( 715) && WD2 != 0) {
1063             if (++igo == 10)
1064                 RSPEAK(GO_UNNEEDED);
1065         }
1066 Lookup:
1067         defn = VOCAB(WD1, -1);
1068         if (defn == -1) {
1069             /* Gee, I don't understand. */
1070             if (fallback_handler(rawbuf))
1071                 continue;
1072             SETPRM(1, WD1, WD1X);
1073             RSPEAK(DONT_KNOW);
1074             goto L2600;
1075         }
1076         kmod = MOD(defn, 1000);
1077         switch (defn / 1000) {
1078         case 0:
1079             if (playermove(verb, kmod))
1080                 return true;
1081             else
1082                 continue;       /* back to top of main interpreter loop */
1083         case 1:
1084             part = unknown;
1085             obj = kmod;
1086             break;
1087         case 2:
1088             part = intransitive;
1089             verb = kmod;
1090             break;
1091         case 3:
1092             RSPEAK(kmod);
1093             goto L2012;
1094         default:
1095             BUG(VOCABULARY_TYPE_N_OVER_1000_NOT_BETWEEN_0_AND_3);
1096         }
1097
1098 Laction:
1099         switch (action(cmdin, part, verb, obj)) {
1100         case GO_TERMINATE:
1101             return true;
1102         case GO_MOVE:
1103             playermove(verb, NUL);
1104             return true;
1105         case GO_TOP:
1106             continue;   /* back to top of main interpreter loop */
1107         case GO_CLEAROBJ:
1108             goto L2012;
1109         case GO_CHECKHINT:
1110             goto L2600;
1111         case GO_CHECKFOO:
1112             goto L2607;
1113         case GO_LOOKUP:
1114             goto Lookup;
1115         case GO_WORD2:
1116             /* Get second word for analysis. */
1117             WD1 = WD2;
1118             WD1X = WD2X;
1119             WD2 = 0;
1120             goto L2620;
1121         case GO_UNKNOWN:
1122             /*  Random intransitive verbs come here.  Clear obj just in case
1123              *  (see attack()). */
1124             SETPRM(1, WD1, WD1X);
1125             RSPEAK(DO_WHAT);
1126             obj = 0;
1127             goto L2600;
1128         case GO_DWARFWAKE:
1129             /*  Oh dear, he's disturbed the dwarves. */
1130             RSPEAK(DWARVES_AWAKEN);
1131             terminate(endgame);
1132         default:
1133             BUG(ACTION_RETURNED_PHASE_CODE_BEYOND_END_OF_SWITCH);
1134         }
1135     }
1136 }
1137
1138 /* end */