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 token_t 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 #ifndef ADVENT_NOSAVE
  81     const char* opts = "l:or:s";
  82     const char* usage = "Usage: %s [-l logfilename] [-o] [-r restorefilename] [-s] \n";
  83 #else
  84     const char* opts = "l:os";
  85     const char* usage = "Usage: %s [-l logfilename] [-o] [-s] \n";
  86 #endif
  87     while ((ch = getopt(argc, argv, opts)) != EOF) {
  88         switch (ch) {
  89         case 'l':
  90             logfp = fopen(optarg, "w");
  91             if (logfp == NULL)
  92                 fprintf(stderr,
  93                         "advent: can't open logfile %s for write\n",
  94                         optarg);
  95             signal(SIGINT, sig_handler);
  96             break;
  97         case 'o':
  98             oldstyle = true;
  99             editline = prompt = false;
 100             break;
 101 #ifndef ADVENT_NOSAVE
 102         case 'r':
 103             rfp = fopen(optarg, "r");
 104             if (rfp == NULL)
 105                 fprintf(stderr,
 106                         "advent: can't open save file %s for read\n",
 107                         optarg);
 108             signal(SIGINT, sig_handler);
 109             break;
 110 #endif
 111         case 's':
 112             editline = false;
 113             break;
 114         default:
 115             fprintf(stderr,
 116                     usage, argv[0]);
 117             fprintf(stderr,
 118                     "        -l create a log file of your game named as specified'\n");
 119             fprintf(stderr,
 120                     "        -o 'oldstyle' (no prompt, no command editing, displays 'Initialising...')\n");
 121 #ifndef ADVENT_NOSAVE
 122             fprintf(stderr,
 123                     "        -r restore from specified saved game file\n");
 124 #endif
 125             fprintf(stderr,
 126                     "        -s suppress command editing\n");
 127             exit(-1);
 128             break;
 129         }
 130     }
 131
 132     linenoiseHistorySetMaxLen(350);
 133
 134     /* Initialize our LCG PRNG with parameters tested against
 135      * Knuth vol. 2. by the original authors */
 136     game.lcg_a = 1093;
 137     game.lcg_c = 221587;
 138     game.lcg_m = 1048576;
 139     srand(time(NULL));
 140     long seedval = (long)rand();
 141     set_seed(seedval);
 142
 143     /*  Initialize game variables */
 144     initialise();
 145
 146     /*  Start-up, dwarf stuff */
 147     game.zzword = RNDVOC(3, 0);
 148     game.newloc = LOC_START;
 149     game.loc = LOC_START;
 150     game.limit = GAMELIMIT;
 151     if (!rfp) {
 152         game.novice = YES(arbitrary_messages[WELCOME_YOU], arbitrary_messages[CAVE_NEARBY], arbitrary_messages[NO_MESSAGE]);
 153         if (game.novice)
 154             game.limit = NOVICELIMIT;
 155     } else {
 156         restore(rfp);
 157     }
 158
 159     if (logfp)
 160         fprintf(logfp, "seed %ld\n", seedval);
 161
 162     /* interpret commands until EOF or interrupt */
 163     for (;;) {
 164         if (!do_command(stdin))
 165             break;
 166     }
 167     /* show score and exit */
 168     terminate(quitgame);
 169 }
 170
 171 static bool fallback_handler(char *buf)
 172 /* fallback handler for commands not handled by FORTRANish parser */
 173 {
 174     long sv;
 175     if (sscanf(buf, "seed %ld", &sv) == 1) {
 176         set_seed(sv);
 177         printf("Seed set to %ld\n", sv);
 178         // autogenerated, so don't charge user time for it.
 179         --game.turns;
 180         // here we reconfigure any global game state that uses random numbers
 181         game.zzword = RNDVOC(3, 0);
 182         return true;
 183     }
 184     return false;
 185 }
 186
 187 /*  Check if this loc is eligible for any hints.  If been here long
 188  *  enough, display.  Ignore "HINTS" < 4 (special stuff, see database
 189  *  notes). */
 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(arbitrary_messages[HINTS[hint][3]], arbitrary_messages[NO_MESSAGE], arbitrary_messages[OK_MAN]))
 268                     return;
 269                 SETPRM(1, HINTS[hint][2], HINTS[hint][2]);
 270                 RSPEAK(HINT_COST);
 271                 game.hinted[hint] = YES(arbitrary_messages[WANT_HINT], arbitrary_messages[HINTS[hint][4]], arbitrary_messages[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] = LOC_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] == LOC_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(game.dtotal == 1 ? DWARF_SINGLE : DWARF_PACK);
 455     if (attack == 0)
 456         return true;
 457     if (game.dflag == 2)game.dflag = 3;
 458     if (attack > 1){
 459         SETPRM(1, attack, 0);
 460         RSPEAK(THROWN_KNIVES);
 461         SETPRM(1, stick, 0);
 462         RSPEAK(stick > 1 ? MULTIPLE_HITS : (stick == 1 ? ONE_HIT : NONE_HIT));
 463     } else {
 464         RSPEAK(KNIFE_THROWN);
 465         RSPEAK(MISSES_YOU);
 466     }
 467     if (stick == 0)
 468         return true;
 469     game.oldlc2 = game.loc;
 470     return false;
 471 }
 472
 473 /*  "You're dead, Jim."
 474  *
 475  *  If the current loc is zero, it means the clown got himself killed.
 476  *  We'll allow this maxdie times.  maximum_deaths is automatically set based
 477  *  on the number of snide messages available.  Each death results in
 478  *  a message (81, 83, etc.)  which offers reincarnation; if accepted,
 479  *  this results in message 82, 84, etc.  The last time, if he wants
 480  *  another chance, he gets a snide remark as we exit.  When
 481  *  reincarnated, all objects being carried get dropped at game.oldlc2
 482  *  (presumably the last place prior to being killed) without change
 483  *  of props.  the loop runs backwards to assure that the bird is
 484  *  dropped before the cage.  (this kluge could be changed once we're
 485  *  sure all references to bird and cage are done by keywords.)  The
 486  *  lamp is a special case (it wouldn't do to leave it in the cave).
 487  *  It is turned off and left outside the building (only if he was
 488  *  carrying it, of course).  He himself is left inside the building
 489  *  (and heaven help him if he tries to xyzzy back into the cave
 490  *  without the lamp!).  game.oldloc is zapped so he can't just
 491  *  "retreat". */
 492
 493 static void croak(void)
 494 /*  Okay, he's dead.  Let's get on with it. */
 495 {
 496     const char* query = obituaries[game.numdie].query;
 497     const char* yes_response = obituaries[game.numdie].yes_response;
 498     ++game.numdie;
 499     if (game.closng) {
 500         /*  He died during closing time.  No resurrection.  Tally up a
 501          *  death and exit. */
 502         RSPEAK(DEATH_CLOSING);
 503         terminate(endgame);
 504     } else if (game.numdie == maximum_deaths || !YES(query, yes_response, arbitrary_messages[OK_MAN]))
 505         terminate(endgame);
 506     else {
 507         game.place[WATER] = game.place[OIL] = LOC_NOWHERE;
 508         if (TOTING(LAMP))
 509             game.prop[LAMP] = 0;
 510         for (int j = 1; j <= NOBJECTS; j++) {
 511             int i = NOBJECTS + 1 - j;
 512             if (TOTING(i)) {
 513                 /* Always leave lamp where it's accessible aboveground */
 514                 DROP(i, (i == LAMP) ? LOC_START : game.oldlc2);
 515             }
 516         }
 517         game.loc = LOC_BUILDING;
 518         game.oldloc = game.loc;
 519     }
 520 }
 521
 522 /*  Given the current location in "game.loc", and a motion verb number in
 523  *  "motion", put the new location in "game.newloc".  The current loc is saved
 524  *  in "game.oldloc" in case he wants to retreat.  The current
 525  *  game.oldloc is saved in game.oldlc2, in case he dies.  (if he
 526  *  does, game.newloc will be limbo, and game.oldloc will be what killed
 527  *  him, so we need game.oldlc2, which is the last place he was
 528  *  safe.) */
 529
 530 static bool playermove(token_t verb, int motion)
 531 {
 532     int scratchloc, k2, kk = KEY[game.loc];
 533     game.newloc = game.loc;
 534     if (kk == 0)
 535         BUG(LOCATION_HAS_NO_TRAVEL_ENTRIES);
 536     if (motion == NUL)
 537         return true;
 538     else if (motion == BACK) {
 539         /*  Handle "go back".  Look for verb which goes from game.loc to
 540          *  game.oldloc, or to game.oldlc2 If game.oldloc has forced-motion.
 541          *  k2 saves entry -> forced loc -> previous loc. */
 542         motion = game.oldloc;
 543         if (FORCED(motion))
 544             motion = game.oldlc2;
 545         game.oldlc2 = game.oldloc;
 546         game.oldloc = game.loc;
 547         k2 = 0;
 548         if (motion == game.loc)k2 = FORGOT_PATH;
 549         if (CNDBIT(game.loc, NOBACK))k2 = TWIST_TURN;
 550         if (k2 == 0) {
 551             for (;;) {
 552                 scratchloc = MOD((labs(TRAVEL[kk]) / 1000), 1000);
 553                 if (scratchloc != motion) {
 554                     if (!SPECIAL(scratchloc)) {
 555                         if (FORCED(scratchloc) && MOD((labs(TRAVEL[KEY[scratchloc]]) / 1000), 1000) == motion)
 556                             k2 = kk;
 557                     }
 558                     if (TRAVEL[kk] >= 0) {
 559                         ++kk;
 560                         continue;
 561                     }
 562                     kk = k2;
 563                     if (kk == 0) {
 564                         RSPEAK(NOT_CONNECTED);
 565                         return true;
 566                     }
 567                 }
 568
 569                 motion = MOD(labs(TRAVEL[kk]), 1000);
 570                 kk = KEY[game.loc];
 571                 break; /* fall through to ordinary travel */
 572             }
 573         } else {
 574             RSPEAK(k2);
 575             return true;
 576         }
 577     } else if (motion == LOOK) {
 578         /*  Look.  Can't give more detail.  Pretend it wasn't dark
 579          *  (though it may now be dark) so he won't fall into a
 580          *  pit while staring into the gloom. */
 581         if (game.detail < 3)
 582             RSPEAK(NO_MORE_DETAIL);
 583         ++game.detail;
 584         game.wzdark = false;
 585         game.abbrev[game.loc] = 0;
 586         return true;
 587     } else if (motion == CAVE) {
 588         /*  Cave.  Different messages depending on whether above ground. */
 589         RSPEAK((OUTSID(game.loc) && game.loc != LOC_GRATE) ? FOLLOW_STREAM : NEED_DETAIL);
 590         return true;
 591     } else {
 592         /* none of the specials */
 593         game.oldlc2 = game.oldloc;
 594         game.oldloc = game.loc;
 595     }
 596
 597     /* ordinary travel */
 598     for (;;) {
 599         scratchloc = labs(TRAVEL[kk]);
 600         if (MOD(scratchloc, 1000) == 1 || MOD(scratchloc, 1000) == motion)
 601             break;
 602         if (TRAVEL[kk] < 0) {
 603             /* FIXME: Magic numbers! */
 604             /*  Non-applicable motion.  Various messages depending on
 605              *  word given. */
 606             int spk = CANT_APPLY;
 607             if (motion >= 43 && motion <= 50)spk = BAD_DIRECTION;
 608             if (motion == 29 || motion == 30)spk = BAD_DIRECTION;
 609             if (motion == 7 || motion == 36 || motion == 37)spk = UNSURE_FACING;
 610             if (motion == 11 || motion == 19)spk = NO_INOUT_HERE;
 611             if (verb == FIND || verb == INVENT)spk = NEARBY;
 612             if (motion == 62 || motion == 65)spk = NOTHING_HAPPENS;
 613             if (motion == 17)spk = WHICH_WAY;
 614             RSPEAK(spk);
 615             return true;
 616         }
 617         ++kk;
 618     }
 619     scratchloc = scratchloc / 1000;
 620
 621     do {
 622         /*
 623          * (ESR) This special-travel loop may have to be repeated if it includes
 624          * the plover passage.  Same deal for any future cases where we need to
 625          * block travel and then redo it once the blocking condition has been
 626          * removed.
 627          */
 628         for (;;) { /* L12 loop */
 629             for (;;) {
 630                 game.newloc = scratchloc / 1000;
 631                 motion = MOD(game.newloc, 100);
 632                 if (!SPECIAL(game.newloc)) {
 633                     if (game.newloc <= 100) {
 634                         if (game.newloc == 0 || PCT(game.newloc))
 635                             break;
 636                         /* else fall through */
 637                     }
 638                     if (TOTING(motion) || (game.newloc > 200 && AT(motion)))
 639                         break;
 640                     /* else fall through */
 641                 } else if (game.prop[motion] != game.newloc / 100 - 3)
 642                     break;
 643                 do {
 644                     if (TRAVEL[kk] < 0)
 645                         BUG(CONDITIONAL_TRAVEL_ENTRY_WITH_NO_ALTERATION);
 646                     ++kk;
 647                     game.newloc = labs(TRAVEL[kk]) / 1000;
 648                 } while
 649                 (game.newloc == scratchloc);
 650                 scratchloc = game.newloc;
 651             }
 652
 653             game.newloc = MOD(scratchloc, 1000);
 654             if (!SPECIAL(game.newloc))
 655                 return true;
 656             if (game.newloc <= 500) {
 657                 game.newloc -= SPECIALBASE;
 658                 switch (game.newloc) {
 659                 case 1:
 660                     /*  Travel 301.  Plover-alcove passage.  Can carry only
 661                      *  emerald.  Note: travel table must include "useless"
 662                      *  entries going through passage, which can never be used for
 663                      *  actual motion, but can be spotted by "go back". */
 664                     /* FIXME: Arithmetic on location numbers */
 665                     game.newloc = 99 + 100 - game.loc;
 666                     if (game.holdng > 1 || (game.holdng == 1 && !TOTING(EMERALD))) {
 667                         game.newloc = game.loc;
 668                         RSPEAK(MUST_DROP);
 669                     }
 670                     return true;
 671                 case 2:
 672                     /*  Travel 302.  Plover transport.  Drop the emerald (only use
 673                      *  special travel if toting it), so he's forced to use the
 674                      *  plover-passage to get it out.  Having dropped it, go back and
 675                      *  pretend he wasn't carrying it after all. */
 676                     DROP(EMERALD, game.loc);
 677                     do {
 678                         if (TRAVEL[kk] < 0)
 679                             BUG(CONDITIONAL_TRAVEL_ENTRY_WITH_NO_ALTERATION);
 680                         ++kk;
 681                         game.newloc = labs(TRAVEL[kk]) / 1000;
 682                     } while
 683                     (game.newloc == scratchloc);
 684                     scratchloc = game.newloc;
 685                     continue; /* goto L12 */
 686                 case 3:
 687                     /*  Travel 303.  Troll bridge.  Must be done only as special
 688                      *  motion so that dwarves won't wander across and encounter
 689                      *  the bear.  (They won't follow the player there because
 690                      *  that region is forbidden to the pirate.)  If
 691                      *  game.prop(TROLL)=1, he's crossed since paying, so step out
 692                      *  and block him.  (standard travel entries check for
 693                      *  game.prop(TROLL)=0.)  Special stuff for bear. */
 694                     if (game.prop[TROLL] == 1) {
 695                         PSPEAK(TROLL, 1);
 696                         game.prop[TROLL] = 0;
 697                         MOVE(TROLL2, 0);
 698                         MOVE(TROLL2 + NOBJECTS, 0);
 699                         MOVE(TROLL, PLAC[TROLL]);
 700                         MOVE(TROLL + NOBJECTS, FIXD[TROLL]);
 701                         JUGGLE(CHASM);
 702                         game.newloc = game.loc;
 703                         return true;
 704                     } else {
 705                         game.newloc = PLAC[TROLL] + FIXD[TROLL] - game.loc;
 706                         if (game.prop[TROLL] == 0)game.prop[TROLL] = 1;
 707                         if (!TOTING(BEAR)) return true;
 708                         RSPEAK(BRIDGE_COLLAPSE);
 709                         game.prop[CHASM] = 1;
 710                         game.prop[TROLL] = 2;
 711                         DROP(BEAR, game.newloc);
 712                         game.fixed[BEAR] = -1;
 713                         game.prop[BEAR] = 3;
 714                         game.oldlc2 = game.newloc;
 715                         croak();
 716                         return true;
 717                     }
 718                 }
 719                 BUG(SPECIAL_TRAVEL_500_GT_L_GT_300_EXCEEDS_GOTO_LIST);
 720             }
 721             break; /* Leave L12 loop */
 722         }
 723     } while
 724     (false);
 725     /* FIXME: Arithmetic on location number, becoming a message number */
 726     RSPEAK(game.newloc - 500);
 727     game.newloc = game.loc;
 728     return true;
 729 }
 730
 731 static bool closecheck(void)
 732 /*  Handle the closing of the cave.  The cave closes "clock1" turns
 733  *  after the last treasure has been located (including the pirate's
 734  *  chest, which may of course never show up).  Note that the
 735  *  treasures need not have been taken yet, just located.  Hence
 736  *  clock1 must be large enough to get out of the cave (it only ticks
 737  *  while inside the cave).  When it hits zero, we branch to 10000 to
 738  *  start closing the cave, and then sit back and wait for him to try
 739  *  to get out.  If he doesn't within clock2 turns, we close the cave;
 740  *  if he does try, we assume he panics, and give him a few additional
 741  *  turns to get frantic before we close.  When clock2 hits zero, we
 742  *  branch to 11000 to transport him into the final puzzle.  Note that
 743  *  the puzzle depends upon all sorts of random things.  For instance,
 744  *  there must be no water or oil, since there are beanstalks which we
 745  *  don't want to be able to water, since the code can't handle it.
 746  *  Also, we can have no keys, since there is a grate (having moved
 747  *  the fixed object!) there separating him from all the treasures.
 748  *  Most of these problems arise from the use of negative prop numbers
 749  *  to suppress the object descriptions until he's actually moved the
 750  *  objects. */
 751 {
 752     if (game.tally == 0 && INDEEP(game.loc) && game.loc != 33)
 753         --game.clock1;
 754
 755     /*  When the first warning comes, we lock the grate, destroy
 756      *  the bridge, kill all the dwarves (and the pirate), remove
 757      *  the troll and bear (unless dead), and set "closng" to
 758      *  true.  Leave the dragon; too much trouble to move it.
 759      *  from now until clock2 runs out, he cannot unlock the
 760      *  grate, move to any location outside the cave, or create
 761      *  the bridge.  Nor can he be resurrected if he dies.  Note
 762      *  that the snake is already gone, since he got to the
 763      *  treasure accessible only via the hall of the mountain
 764      *  king. Also, he's been in giant room (to get eggs), so we
 765      *  can refer to it.  Also also, he's gotten the pearl, so we
 766      *  know the bivalve is an oyster.  *And*, the dwarves must
 767      *  have been activated, since we've found chest. */
 768     if (game.clock1 == 0) {
 769         game.prop[GRATE] = 0;
 770         game.prop[FISSURE] = 0;
 771         for (int i = 1; i <= NDWARVES; i++) {
 772             game.dseen[i] = false;
 773             game.dloc[i] = 0;
 774         }
 775         MOVE(TROLL, 0);
 776         MOVE(TROLL + NOBJECTS, 0);
 777         MOVE(TROLL2, PLAC[TROLL]);
 778         MOVE(TROLL2 + NOBJECTS, FIXD[TROLL]);
 779         JUGGLE(CHASM);
 780         if (game.prop[BEAR] != 3)DESTROY(BEAR);
 781         game.prop[CHAIN] = 0;
 782         game.fixed[CHAIN] = 0;
 783         game.prop[AXE] = 0;
 784         game.fixed[AXE] = 0;
 785         RSPEAK(CAVE_CLOSING);
 786         game.clock1 = -1;
 787         game.closng = true;
 788         return true;
 789     } else if (game.clock1 < 0)
 790         --game.clock2;
 791     if (game.clock2 == 0) {
 792         /*  Once he's panicked, and clock2 has run out, we come here
 793          *  to set up the storage room.  The room has two locs,
 794          *  hardwired as 115 (ne) and 116 (sw).  At the ne end, we
 795          *  place empty bottles, a nursery of plants, a bed of
 796          *  oysters, a pile of lamps, rods with stars, sleeping
 797          *  dwarves, and him.  At the sw end we place grate over
 798          *  treasures, snake pit, covey of caged birds, more rods, and
 799          *  pillows.  A mirror stretches across one wall.  Many of the
 800          *  objects come from known locations and/or states (e.g. the
 801          *  snake is known to have been destroyed and needn't be
 802          *  carried away from its old "place"), making the various
 803          *  objects be handled differently.  We also drop all other
 804          *  objects he might be carrying (lest he have some which
 805          *  could cause trouble, such as the keys).  We describe the
 806          *  flash of light and trundle back. */
 807         game.prop[BOTTLE] = PUT(BOTTLE, LOC_NE, 1);
 808         game.prop[PLANT] = PUT(PLANT, LOC_NE, 0);
 809         game.prop[OYSTER] = PUT(OYSTER, LOC_NE, 0);
 810         OBJTXT[OYSTER] = 3;
 811         game.prop[LAMP] = PUT(LAMP, LOC_NE, 0);
 812         game.prop[ROD] = PUT(ROD, LOC_NE, 0);
 813         game.prop[DWARF] = PUT(DWARF, LOC_NE, 0);
 814         game.loc = LOC_NE;
 815         game.oldloc = LOC_NE;
 816         game.newloc = LOC_NE;
 817         /*  Leave the grate with normal (non-negative) property.
 818          *  Reuse sign. */
 819         PUT(GRATE, LOC_SW, 0);
 820         PUT(SIGN, LOC_SW, 0);
 821         ++OBJTXT[SIGN];
 822         game.prop[SNAKE] = PUT(SNAKE, LOC_SW, 1);
 823         game.prop[BIRD] = PUT(BIRD, LOC_SW, 1);
 824         game.prop[CAGE] = PUT(CAGE, LOC_SW, 0);
 825         game.prop[ROD2] = PUT(ROD2, LOC_SW, 0);
 826         game.prop[PILLOW] = PUT(PILLOW, LOC_SW, 0);
 827
 828         game.prop[MIRROR] = PUT(MIRROR, LOC_NE, 0);
 829         game.fixed[MIRROR] = LOC_SW;
 830
 831         for (int i = 1; i <= NOBJECTS; i++) {
 832             if (TOTING(i))
 833                 DESTROY(i);
 834         }
 835
 836         RSPEAK(CAVE_CLOSED);
 837         game.closed = true;
 838         return true;
 839     }
 840
 841     return false;
 842 }
 843
 844 static void lampcheck(void)
 845 /* Check game limit and lamp timers */
 846 {
 847     if (game.prop[LAMP] == 1)
 848         --game.limit;
 849
 850     /*  Another way we can force an end to things is by having the
 851      *  lamp give out.  When it gets close, we come here to warn him.
 852      *  First following arm checks if the lamp and fresh batteries are
 853      *  here, in which case we replace the batteries and continue.
 854      *  Second is for other cases of lamp dying.  Eve after it goes
 855      *  out, he can explore outside for a while if desired. */
 856     if (game.limit <= WARNTIME && HERE(BATTERY) && game.prop[BATTERY] == 0 && HERE(LAMP)) {
 857         RSPEAK(REPLACE_BATTERIES);
 858         game.prop[BATTERY] = 1;
 859         if (TOTING(BATTERY))
 860             DROP(BATTERY, game.loc);
 861         game.limit += BATTERYLIFE;
 862         game.lmwarn = false;
 863     } else if (game.limit == 0) {
 864         game.limit = -1;
 865         game.prop[LAMP] = 0;
 866         if (HERE(LAMP))
 867             RSPEAK(LAMP_OUT);
 868     } else if (game.limit <= WARNTIME) {
 869         if (!game.lmwarn && HERE(LAMP)) {
 870             game.lmwarn = true;
 871             int spk = GET_BATTERIES;
 872             if (game.place[BATTERY] == LOC_NOWHERE)spk = LAMP_DIM;
 873             if (game.prop[BATTERY] == 1)spk = MISSING_BATTERYIES;
 874             RSPEAK(spk);
 875         }
 876     }
 877 }
 878
 879 static void listobjects(void)
 880 /*  Print out descriptions of objects at this location.  If
 881  *  not closing and property value is negative, tally off
 882  *  another treasure.  Rug is special case; once seen, its
 883  *  game.prop is 1 (dragon on it) till dragon is killed.
 884  *  Similarly for chain; game.prop is initially 1 (locked to
 885  *  bear).  These hacks are because game.prop=0 is needed to
 886  *  get full score. */
 887 {
 888     if (!DARK(game.loc)) {
 889         ++game.abbrev[game.loc];
 890         for (int i = game.atloc[game.loc]; i != 0; i = game.link[i]) {
 891             long obj = i;
 892             if (obj > NOBJECTS)obj = obj - NOBJECTS;
 893             if (obj == STEPS && TOTING(NUGGET))
 894                 continue;
 895             if (game.prop[obj] < 0) {
 896                 if (game.closed)
 897                     continue;
 898                 game.prop[obj] = 0;
 899                 if (obj == RUG || obj == CHAIN)
 900                     game.prop[obj] = 1;
 901                 --game.tally;
 902                 /*  Note: There used to be a test here to see whether the
 903                  *  player had blown it so badly that he could never ever see
 904                  *  the remaining treasures, and if so the lamp was zapped to
 905                  *  35 turns.  But the tests were too simple-minded; things
 906                  *  like killing the bird before the snake was gone (can never
 907                  *  see jewelry), and doing it "right" was hopeless.  E.G.,
 908                  *  could cross troll bridge several times, using up all
 909                  *  available treasures, breaking vase, using coins to buy
 910                  *  batteries, etc., and eventually never be able to get
 911                  *  across again.  If bottle were left on far side, could then
 912                  *  never get eggs or trident, and the effects propagate.  So
 913                  *  the whole thing was flushed.  anyone who makes such a
 914                  *  gross blunder isn't likely to find everything else anyway
 915                  *  (so goes the rationalisation). */
 916             }
 917             int kk = game.prop[obj];
 918             if (obj == STEPS && game.loc == game.fixed[STEPS])
 919                 kk = 1;
 920             PSPEAK(obj, kk);
 921         }
 922     }
 923 }
 924
 925 static bool do_command(FILE *cmdin)
 926 /* Get and execute a command */
 927 {
 928     long V1, V2;
 929     long kmod, defn;
 930     static long igo = 0;
 931     static struct command_t command;
 932     command.verb = 0;
 933
 934     /*  Can't leave cave once it's closing (except by main office). */
 935     if (OUTSID(game.newloc) && game.newloc != 0 && game.closng) {
 936         RSPEAK(EXIT_CLOSED);
 937         game.newloc = game.loc;
 938         if (!game.panic)game.clock2 = PANICTIME;
 939         game.panic = true;
 940     }
 941
 942     /*  See if a dwarf has seen him and has come from where he
 943      *  wants to go.  If so, the dwarf's blocking his way.  If
 944      *  coming from place forbidden to pirate (dwarves rooted in
 945      *  place) let him get out (and attacked). */
 946     if (game.newloc != game.loc && !FORCED(game.loc) && !CNDBIT(game.loc, NOARRR)) {
 947         for (size_t i = 1; i <= NDWARVES - 1; i++) {
 948             if (game.odloc[i] == game.newloc && game.dseen[i]) {
 949                 game.newloc = game.loc;
 950                 RSPEAK(DWARF_BLOCK);
 951                 break;
 952             }
 953         }
 954     }
 955     game.loc = game.newloc;
 956
 957     if (!dwarfmove())
 958         croak();
 959
 960     /*  Describe the current location and (maybe) get next command. */
 961
 962     for (;;) {
 963         if (game.loc == 0)
 964             croak();
 965         const char* msg = locations[game.loc].description.small;
 966         if (MOD(game.abbrev[game.loc], game.abbnum) == 0 || msg == 0)
 967             msg = locations[game.loc].description.big;
 968         if (!FORCED(game.loc) && DARK(game.loc)) {
 969             /*  The easiest way to get killed is to fall into a pit in
 970              *  pitch darkness. */
 971             if (game.wzdark && PCT(35)) {
 972                 RSPEAK(PIT_FALL);
 973                 game.oldlc2 = game.loc;
 974                 croak();
 975                 continue;       /* back to top of main interpreter loop */
 976             }
 977             msg = arbitrary_messages[PITCH_DARK];
 978         }
 979         if (TOTING(BEAR))RSPEAK(TAME_BEAR);
 980         speak(msg);
 981         if (FORCED(game.loc)) {
 982             if (playermove(command.verb, 1))
 983                 return true;
 984             else
 985                 continue;       /* back to top of main interpreter loop */
 986         }
 987         if (game.loc == LOC_Y2 && PCT(25) && !game.closng)
 988             RSPEAK(SAYS_PLUGH);
 989
 990         listobjects();
 991
 992 L2012:
 993         command.verb = 0;
 994         game.oldobj = command.obj;
 995         command.obj = 0;
 996
 997 L2600:
 998         checkhints();
 999
1000         /*  If closing time, check for any objects being toted with
1001          *  game.prop < 0 and set the prop to -1-game.prop.  This way
1002          *  objects won't be described until they've been picked up
1003          *  and put down separate from their respective piles.  Don't
1004          *  tick game.clock1 unless well into cave (and not at Y2). */
1005         if (game.closed) {
1006             if (game.prop[OYSTER] < 0 && TOTING(OYSTER))
1007                 PSPEAK(OYSTER, 1);
1008             for (size_t i = 1; i <= NOBJECTS; i++) {
1009                 if (TOTING(i) && game.prop[i] < 0)
1010                     game.prop[i] = -1 - game.prop[i];
1011             }
1012         }
1013         game.wzdark = DARK(game.loc);
1014         if (game.knfloc > 0 && game.knfloc != game.loc)
1015             game.knfloc = 0;
1016
1017         /* This is where we get a new command from the user */
1018         if (!GETIN(cmdin, &WD1, &WD1X, &WD2, &WD2X))
1019             return false;
1020
1021         /*  Every input, check "game.foobar" flag.  If zero, nothing's
1022          *  going on.  If pos, make neg.  If neg, he skipped a word,
1023          *  so make it zero. */
1024 L2607:
1025         game.foobar = (game.foobar > 0 ? -game.foobar : 0);
1026         ++game.turns;
1027
1028         /* If a turn threshold has been met, apply penalties and tell
1029          * the player about it. */
1030         for (int i = turn_threshold_count; i >= 0; --i)
1031           {
1032             if (game.turns == turn_thresholds[i].threshold)
1033               {
1034                 game.trnluz += turn_thresholds[i].point_loss;
1035                 speak(turn_thresholds[i].message);
1036               }
1037           }
1038         /* if (game.turns == game.thresh) { */
1039         /*     speak(turn_threshold_messages[game.trndex]); */
1040         /*     game.trnluz = game.trnluz + TRNVAL[game.trndex] / 100000; */
1041         /*     ++game.trndex; */
1042         /*     game.thresh = -1; */
1043         /*     if (game.trndex <= TRNVLS) */
1044         /*         game.thresh = MOD(TRNVAL[game.trndex], 100000) + 1; */
1045         /* } */
1046         if (command.verb == SAY && WD2 > 0)
1047             command.verb = 0;
1048         if (command.verb == SAY) {
1049             command.part = transitive;
1050             goto Laction;
1051         }
1052         if (closecheck()) {
1053             if (game.closed)
1054                 return true;
1055         } else
1056             lampcheck();
1057
1058         V1 = VOCAB(WD1, -1);
1059         V2 = VOCAB(WD2, -1);
1060         if (V1 == ENTER && (V2 == STREAM || V2 == 1000 + WATER)) {
1061             if (LIQLOC(game.loc) == WATER) {
1062                 RSPEAK(FEET_WET);
1063             } else {
1064                 RSPEAK(WHERE_QUERY);
1065             }
1066             goto L2012;
1067         }
1068         if (V1 == ENTER && WD2 > 0) {
1069             WD1 = WD2;
1070             WD1X = WD2X;
1071             wordclear(&WD2);
1072         } else {
1073             /* FIXME: Magic numbers */
1074             if (!((V1 != 1000 + WATER && V1 != 1000 + OIL) ||
1075                   (V2 != 1000 + PLANT && V2 != 1000 + DOOR))) {
1076                 if (AT(V2 - 1000))
1077                     WD2 = MAKEWD(WORD_POUR);
1078             }
1079             if (V1 == 1000 + CAGE && V2 == 1000 + BIRD && HERE(CAGE) && HERE(BIRD))
1080                 WD1 = MAKEWD(WORD_CATCH);
1081         }
1082 L2620:
1083         if (wordeq(WD1, MAKEWD(WORD_WEST))) {
1084             ++game.iwest;
1085             if (game.iwest == 10)
1086                 RSPEAK(W_IS_WEST);
1087         }
1088         if (wordeq(WD1, MAKEWD(WORD_GO)) && !wordempty(WD2)) {
1089             if (++igo == 10)
1090                 RSPEAK(GO_UNNEEDED);
1091         }
1092 Lookup:
1093         defn = VOCAB(WD1, -1);
1094         if (defn == -1) {
1095             /* Gee, I don't understand. */
1096             if (fallback_handler(rawbuf))
1097                 continue;
1098             SETPRM(1, WD1, WD1X);
1099             RSPEAK(DONT_KNOW);
1100             goto L2600;
1101         }
1102         kmod = MOD(defn, 1000);
1103         switch (defn / 1000) {
1104         case 0:
1105             if (playermove(command.verb, kmod))
1106                 return true;
1107             else
1108                 continue;       /* back to top of main interpreter loop */
1109         case 1:
1110             command.part = unknown;
1111             command.obj = kmod;
1112             break;
1113         case 2:
1114             command.part = intransitive;
1115             command.verb = kmod;
1116             break;
1117         case 3:
1118             RSPEAK(kmod);
1119             goto L2012;
1120         default:
1121             BUG(VOCABULARY_TYPE_N_OVER_1000_NOT_BETWEEN_0_AND_3);
1122         }
1123
1124 Laction:
1125         switch (action(cmdin, command)) {
1126         case GO_TERMINATE:
1127             return true;
1128         case GO_MOVE:
1129             playermove(command.verb, NUL);
1130             return true;
1131         case GO_TOP:
1132             continue;   /* back to top of main interpreter loop */
1133         case GO_CLEAROBJ:
1134             goto L2012;
1135         case GO_CHECKHINT:
1136             goto L2600;
1137         case GO_CHECKFOO:
1138             goto L2607;
1139         case GO_LOOKUP:
1140             goto Lookup;
1141         case GO_WORD2:
1142             /* Get second word for analysis. */
1143             WD1 = WD2;
1144             WD1X = WD2X;
1145             wordclear(&WD2);
1146             goto L2620;
1147         case GO_UNKNOWN:
1148             /*  Random intransitive verbs come here.  Clear obj just in case
1149              *  (see attack()). */
1150             SETPRM(1, WD1, WD1X);
1151             RSPEAK(DO_WHAT);
1152             command.obj = 0;
1153             goto L2600;
1154         case GO_DWARFWAKE:
1155             /*  Oh dear, he's disturbed the dwarves. */
1156             RSPEAK(DWARVES_AWAKEN);
1157             terminate(endgame);
1158         default:
1159             BUG(ACTION_RETURNED_PHASE_CODE_BEYOND_END_OF_SWITCH);
1160         }
1161     }
1162 }
1163
1164 /* end */