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