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             /* C doesn't have what the Structured rogramming
 312              * Theorem says we need here - multi-level loop
 313              * breakout. We simulate with a goto. Irreducible, alas.
 314              */
 315             return true; //goto jumpout;
 316         }
 317         if (HERE(j))
 318             k=1;
 319     }
 320     /* Force chest placement before player finds last treasure */
 321     if (game.tally == 1 && k == 0 && game.place[CHEST] == 0 && HERE(LAMP) && game.prop[LAMP] == 1) {
 322         RSPEAK(186);
 323         MOVE(CHEST,game.chloc);
 324         MOVE(MESSAG,game.chloc2);
 325         game.dloc[PIRATE]=game.chloc;
 326         game.odloc[PIRATE]=game.chloc;
 327         game.dseen[PIRATE]=false;
 328         return true;
 329     }
 330     if (game.odloc[PIRATE] != game.dloc[PIRATE] && PCT(20))
 331         RSPEAK(127);
 332     return true;
 333 }
 334
 335 static bool dwarfmove(void)
 336 /* Dwarves move.  Return true if player survives, false if he dies. */
 337 {
 338     int kk, stick, attack;
 339     long TK[21];
 340
 341         /*  Dwarf stuff.  See earlier comments for description of
 342      *  variables.  Remember sixth dwarf is pirate and is thus
 343      *  very different except for motion rules. */
 344
 345     /*  First off, don't let the dwarves follow him into a pit or
 346      *  a wall.  Activate the whole mess the first time he gets as
 347      *  far as the hall of mists (loc 15).  If game.newloc is
 348      *  forbidden to pirate (in particular, if it's beyond the
 349      *  troll bridge), bypass dwarf stuff.  That way pirate can't
 350      *  steal return toll, and dwarves can't meet the bear.  Also
 351      *  means dwarves won't follow him into dead end in maze, but
 352      *  c'est la vie.  They'll wait for him outside the dead
 353      *  end. */
 354     if (game.loc == 0 || FORCED(game.loc) || CNDBIT(game.newloc,3))
 355         return true;
 356
 357     /* Dwarf activity level ratchets up */
 358     if (game.dflag == 0) {
 359         if (INDEEP(game.loc))
 360             game.dflag=1;
 361         return true;
 362     }
 363
 364     /*  When we encounter the first dwarf, we kill 0, 1, or 2 of
 365      *  the 5 dwarves.  If any of the survivors is at loc,
 366      *  replace him with the alternate. */
 367     if (game.dflag == 1) {
 368         if (!INDEEP(game.loc) || (PCT(95) && (!CNDBIT(game.loc,4) || PCT(85))))
 369             return true;
 370         game.dflag=2;
 371         for (int i=1; i<=2; i++) {
 372             int j=1+randrange(NDWARVES-1);
 373             if (PCT(50))
 374                 game.dloc[j]=0;
 375         }
 376         for (int i=1; i<=NDWARVES-1; i++) {
 377             if (game.dloc[i] == game.loc)
 378                 game.dloc[i]=DALTLC;
 379             game.odloc[i]=game.dloc[i];
 380         }
 381         RSPEAK(3);
 382         DROP(AXE,game.loc);
 383         return true;
 384     }
 385
 386     /*  Things are in full swing.  Move each dwarf at random,
 387      *  except if he's seen us he sticks with us.  Dwarves stay
 388      *  deep inside.  If wandering at random, they don't back up
 389      *  unless there's no alternative.  If they don't have to
 390      *  move, they attack.  And, of course, dead dwarves don't do
 391      *  much of anything. */
 392     game.dtotal=0;
 393     attack=0;
 394     stick=0;
 395     for (int i=1; i<=NDWARVES; i++) {
 396         if (game.dloc[i] == 0)
 397             continue;
 398         /*  Fill TK array with all the places this dwarf might go. */
 399         int j=1;
 400         kk=KEY[game.dloc[i]];
 401         if (kk != 0)
 402             do {
 403                 game.newloc=MOD(labs(TRAVEL[kk])/1000,1000);
 404                 /* Have we avoided a dwarf enciounter? */
 405                 bool avoided = (game.newloc > 300 ||
 406                                 !INDEEP(game.newloc) ||
 407                                 game.newloc == game.odloc[i] ||
 408                                 (j > 1 && game.newloc == TK[j-1]) ||
 409                                 j >= 20 ||
 410                                 game.newloc == game.dloc[i] ||
 411                                 FORCED(game.newloc) ||
 412                                 (i == PIRATE && CNDBIT(game.newloc,3)) ||
 413                                 labs(TRAVEL[kk])/1000000 == 100);
 414                 if (!avoided) {
 415                     TK[j++] = game.newloc;
 416                 }
 417                 ++kk;
 418             } while
 419                 (TRAVEL[kk-1] >= 0);
 420         TK[j]=game.odloc[i];
 421         if (j >= 2)
 422             --j;
 423         j=1+randrange(j);
 424         game.odloc[i]=game.dloc[i];
 425         game.dloc[i]=TK[j];
 426         game.dseen[i]=(game.dseen[i] && INDEEP(game.loc)) || (game.dloc[i] == game.loc || game.odloc[i] == game.loc);
 427         if (!game.dseen[i]) continue;
 428         game.dloc[i]=game.loc;
 429         if (spotted_by_pirate(i))
 430             continue;
 431         /* This threatening little dwarf is in the room with him! */
 432         ++game.dtotal;
 433         if (game.odloc[i] == game.dloc[i]) {
 434             ++attack;
 435             if (game.knfloc >= 0)
 436                 game.knfloc=game.loc;
 437             if (randrange(1000) < 95*(game.dflag-2))
 438                 ++stick;
 439         }
 440     }
 441
 442     /*  Now we know what's happening.  Let's tell the poor sucker about it.
 443      *  Note that various of the "knife" messages must have specific relative
 444      *  positions in the RSPEAK database. */
 445     if (game.dtotal == 0)
 446         return true;
 447     SETPRM(1,game.dtotal,0);
 448     RSPEAK(4+1/game.dtotal);
 449     if (attack == 0)
 450         return true;
 451     if (game.dflag == 2)game.dflag=3;
 452     SETPRM(1,attack,0);
 453     int k=6;
 454     if (attack > 1)k=250;
 455     RSPEAK(k);
 456     SETPRM(1,stick,0);
 457     RSPEAK(k+1+2/(1+stick));
 458     if (stick == 0)
 459         return true;
 460     game.oldlc2=game.loc;
 461     return false;
 462 }
 463
 464 /*  "You're dead, Jim."
 465  *
 466  *  If the current loc is zero, it means the clown got himself killed.
 467  *  We'll allow this maxdie times.  MAXDIE is automatically set based
 468  *  on the number of snide messages available.  Each death results in
 469  *  a message (81, 83, etc.)  which offers reincarnation; if accepted,
 470  *  this results in message 82, 84, etc.  The last time, if he wants
 471  *  another chance, he gets a snide remark as we exit.  When
 472  *  reincarnated, all objects being carried get dropped at game.oldlc2
 473  *  (presumably the last place prior to being killed) without change
 474  *  of props.  the loop runs backwards to assure that the bird is
 475  *  dropped before the cage.  (this kluge could be changed once we're
 476  *  sure all references to bird and cage are done by keywords.)  The
 477  *  lamp is a special case (it wouldn't do to leave it in the cave).
 478  *  It is turned off and left outside the building (only if he was
 479  *  carrying it, of course).  He himself is left inside the building
 480  *  (and heaven help him if he tries to xyzzy back into the cave
 481  *  without the lamp!).  game.oldloc is zapped so he can't just
 482  *  "retreat". */
 483
 484 static void croak(FILE *cmdin)
 485 /*  Okay, he's dead.  Let's get on with it. */
 486 {
 487     if (game.closng) {
 488         /*  He died during closing time.  No resurrection.  Tally up a
 489          *  death and exit. */
 490         RSPEAK(131);
 491         ++game.numdie;
 492         score(0);
 493     } else {
 494         ++game.numdie;
 495         if (!YES(cmdin,79+game.numdie*2,80+game.numdie*2,54))
 496             score(0);
 497         if (game.numdie == MAXDIE)
 498             score(0);
 499         game.place[WATER]=0;
 500         game.place[OIL]=0;
 501         if (TOTING(LAMP))
 502             game.prop[LAMP]=0;
 503         for (int j=1; j<=NOBJECTS; j++) {
 504             int i=NOBJECTS + 1 - j;
 505             if (TOTING(i)) {
 506                 int k=game.oldlc2;
 507                 if (i == LAMP)
 508                     k=1;
 509                 DROP(i,k);
 510             }
 511         }
 512         game.loc=3;
 513         game.oldloc=game.loc;
 514     }
 515 }
 516
 517 /*  Given the current location in "game.loc", and a motion verb number in
 518  *  "K", put the new location in "game.newloc".  The current loc is saved
 519  *  in "game.oldloc" in case he wants to retreat.  The current
 520  *  game.oldloc is saved in game.oldlc2, in case he dies.  (if he
 521  *  does, game.newloc will be limbo, and game.oldloc will be what killed
 522  *  him, so we need game.oldlc2, which is the last place he was
 523  *  safe.) */
 524
 525 static bool playermove(FILE *cmdin, token_t verb, int motion)
 526 {
 527     int LL, K2, KK=KEY[game.loc];
 528     game.newloc=game.loc;
 529     if (KK == 0)
 530         BUG(26);
 531     if (motion == NUL)
 532         return true;
 533     else if (motion == BACK) {
 534         /*  Handle "go back".  Look for verb which goes from game.loc to
 535          *  game.oldloc, or to game.oldlc2 If game.oldloc has forced-motion.
 536          *  K2 saves entry -> forced loc -> previous loc. */
 537         motion=game.oldloc;
 538         if (FORCED(motion))
 539             motion=game.oldlc2;
 540         game.oldlc2=game.oldloc;
 541         game.oldloc=game.loc;
 542         K2=0;
 543         if (motion == game.loc)K2=91;
 544         if (CNDBIT(game.loc,4))K2=274;
 545         if (K2 == 0) {
 546             for (;;) {
 547                 LL=MOD((labs(TRAVEL[KK])/1000),1000);
 548                 if (LL != motion) {
 549                     if (LL <= 300) {
 550                         if (FORCED(LL) && MOD((labs(TRAVEL[KEY[LL]])/1000),1000) == motion)
 551                             K2=KK;
 552                     }
 553                     if (TRAVEL[KK] >= 0) {
 554                         ++KK;
 555                         continue;
 556                     }
 557                     KK=K2;
 558                     if (KK == 0) {
 559                         RSPEAK(140);
 560                         return true;
 561                     }
 562                 }
 563
 564                 motion=MOD(labs(TRAVEL[KK]),1000);
 565                 KK=KEY[game.loc];
 566                 break; /* fall through to ordinary travel */
 567             }
 568         } else {
 569             RSPEAK(K2);
 570             return true;
 571         }
 572     }
 573     else if (motion == LOOK) {
 574         /*  Look.  Can't give more detail.  Pretend it wasn't dark
 575          *  (though it may "now" be dark) so he won't fall into a
 576          *  pit while staring into the gloom. */
 577         if (game.detail < 3)RSPEAK(15);
 578         ++game.detail;
 579         game.wzdark=false;
 580         game.abbrev[game.loc]=0;
 581         return true;
 582     }
 583     else if (motion == CAVE) {
 584         /*  Cave.  Different messages depending on whether above ground. */
 585         RSPEAK((OUTSID(game.loc) && game.loc != 8) ? 57 : 58);
 586         return true;
 587     }
 588     else {
 589         /* none of the specials */
 590         game.oldlc2=game.oldloc;
 591         game.oldloc=game.loc;
 592     }
 593
 594     /* ordinary travel */
 595     for (;;) {
 596         LL=labs(TRAVEL[KK]);
 597         if (MOD(LL,1000) == 1 || MOD(LL,1000) == motion)
 598             break;
 599         if (TRAVEL[KK] < 0) {
 600             /*  Non-applicable motion.  Various messages depending on
 601              *  word given. */
 602             int spk=12;
 603             if (motion >= 43 && motion <= 50)spk=52;
 604             if (motion == 29 || motion == 30)spk=52;
 605             if (motion == 7 || motion == 36 || motion == 37)spk=10;
 606             if (motion == 11 || motion == 19)spk=11;
 607             if (verb == FIND || verb == INVENT)spk=59;
 608             if (motion == 62 || motion == 65)spk=42;
 609             if (motion == 17)spk=80;
 610             RSPEAK(spk);
 611             return true;
 612         }
 613         ++KK;
 614     }
 615     LL=LL/1000;
 616
 617     do {
 618         /*
 619          * (ESR) This special-travel loop may have to be repeated if it includes
 620          * the plover passage.  Same deal for any future cases wgerw we beed to
 621          * block travel and then redo it once the blocking condition has been
 622          * removed.
 623          */
 624         for (;;) {
 625             game.newloc=LL/1000;
 626             motion=MOD(game.newloc,100);
 627             if (game.newloc <= 300) {
 628                 if (game.newloc <= 100) {
 629                     if (game.newloc == 0 || PCT(game.newloc))
 630                         break;
 631                     /* else fall through */
 632                 } if (TOTING(motion) || (game.newloc > 200 && AT(motion)))
 633                       break;
 634                 /* else fall through */
 635             }
 636             else if (game.prop[motion] != game.newloc/100-3)
 637                 break;
 638             do {
 639                 if (TRAVEL[KK] < 0)BUG(25);
 640                 ++KK;
 641                 game.newloc=labs(TRAVEL[KK])/1000;
 642             } while
 643                 (game.newloc == LL);
 644             LL=game.newloc;
 645         }
 646
 647         game.newloc=MOD(LL,1000);
 648         if (game.newloc <= 300)
 649             return true;
 650         if (game.newloc <= 500) {
 651             game.newloc=game.newloc-300;
 652             switch (game.newloc)
 653             {
 654             case 1:
 655                 /*  Travel 301.  Plover-alcove passage.  Can carry only
 656                  *  emerald.  Note: travel table must include "useless"
 657                  *  entries going through passage, which can never be used for
 658                  *  actual motion, but can be spotted by "go back". */
 659                 game.newloc=99+100-game.loc;
 660                 if (game.holdng == 0 || (game.holdng == 1 && TOTING(EMRALD)))
 661                     return true;
 662                 game.newloc=game.loc;
 663                 RSPEAK(117);
 664                 return true;
 665             case 2:
 666                 /*  Travel 302.  Plover transport.  Drop the emerald (only use
 667                  *  special travel if toting it), so he's forced to use the
 668                  *  plover-passage to get it out.  Having dropped it, go back and
 669                  *  pretend he wasn't carrying it after all. */
 670                 DROP(EMRALD,game.loc);
 671                 do {
 672                     if (TRAVEL[KK] < 0)BUG(25);
 673                     ++KK;
 674                     game.newloc=labs(TRAVEL[KK])/1000;
 675                 } while
 676                     (game.newloc == LL);
 677                 continue;       /* back to top of do/while loop */
 678             case 3:
 679                 /*  Travel 303.  Troll bridge.  Must be done only as special
 680                  *  motion so that dwarves won't wander across and encounter
 681                  *  the bear.  (They won't follow the player there because
 682                  *  that region is forbidden to the pirate.)  If
 683                  *  game.prop(TROLL)=1, he's crossed since paying, so step out
 684                  *  and block him.  (standard travel entries check for
 685                  *  game.prop(TROLL)=0.)  Special stuff for bear. */
 686                 if (game.prop[TROLL] == 1) {
 687                     PSPEAK(TROLL,1);
 688                     game.prop[TROLL]=0;
 689                     MOVE(TROLL2,0);
 690                     MOVE(TROLL2+NOBJECTS,0);
 691                     MOVE(TROLL,PLAC[TROLL]);
 692                     MOVE(TROLL+NOBJECTS,FIXD[TROLL]);
 693                     JUGGLE(CHASM);
 694                     game.newloc=game.loc;
 695                     return true;
 696                 } else {
 697                     game.newloc=PLAC[TROLL]+FIXD[TROLL]-game.loc;
 698                     if (game.prop[TROLL] == 0)game.prop[TROLL]=1;
 699                     if (!TOTING(BEAR)) return true;
 700                     RSPEAK(162);
 701                     game.prop[CHASM]=1;
 702                     game.prop[TROLL]=2;
 703                     DROP(BEAR,game.newloc);
 704                     game.fixed[BEAR]= -1;
 705                     game.prop[BEAR]=3;
 706                     game.oldlc2=game.newloc;
 707                     croak(cmdin);
 708                     return false;
 709                 }
 710             }
 711             BUG(20);
 712         }
 713     } while
 714             (false);
 715     RSPEAK(game.newloc-500);
 716     game.newloc=game.loc;
 717     return true;
 718 }
 719
 720 static bool closecheck(void)
 721 /*  Handle the closing of the cave.  The cave closes "clock1" turns
 722  *  after the last treasure has been located (including the pirate's
 723  *  chest, which may of course never show up).  Note that the
 724  *  treasures need not have been taken yet, just located.  Hence
 725  *  clock1 must be large enough to get out of the cave (it only ticks
 726  *  while inside the cave).  When it hits zero, we branch to 10000 to
 727  *  start closing the cave, and then sit back and wait for him to try
 728  *  to get out.  If he doesn't within clock2 turns, we close the cave;
 729  *  if he does try, we assume he panics, and give him a few additional
 730  *  turns to get frantic before we close.  When clock2 hits zero, we
 731  *  branch to 11000 to transport him into the final puzzle.  Note that
 732  *  the puzzle depends upon all sorts of random things.  For instance,
 733  *  there must be no water or oil, since there are beanstalks which we
 734  *  don't want to be able to water, since the code can't handle it.
 735  *  Also, we can have no keys, since there is a grate (having moved
 736  *  the fixed object!) there separating him from all the treasures.
 737  *  Most of these problems arise from the use of negative prop numbers
 738  *  to suppress the object descriptions until he's actually moved the
 739  *  objects. */
 740 {
 741     if (game.tally == 0 && INDEEP(game.loc) && game.loc != 33)
 742         --game.clock1;
 743
 744     /*  When the first warning comes, we lock the grate, destroy
 745      *  the bridge, kill all the dwarves (and the pirate), remove
 746      *  the troll and bear (unless dead), and set "closng" to
 747      *  true.  Leave the dragon; too much trouble to move it.
 748      *  from now until clock2 runs out, he cannot unlock the
 749      *  grate, move to any location outside the cave, or create
 750      *  the bridge.  Nor can he be resurrected if he dies.  Note
 751      *  that the snake is already gone, since he got to the
 752      *  treasure accessible only via the hall of the mountain
 753      *  king. Also, he's been in giant room (to get eggs), so we
 754      *  can refer to it.  Also also, he's gotten the pearl, so we
 755      *  know the bivalve is an oyster.  *And*, the dwarves must
 756      *  have been activated, since we've found chest. */
 757     if (game.clock1 == 0)
 758     {
 759         game.prop[GRATE]=0;
 760         game.prop[FISSUR]=0;
 761         for (int i=1; i<=NDWARVES; i++) {
 762             game.dseen[i]=false;
 763             game.dloc[i]=0;
 764         }
 765         MOVE(TROLL,0);
 766         MOVE(TROLL+NOBJECTS,0);
 767         MOVE(TROLL2,PLAC[TROLL]);
 768         MOVE(TROLL2+NOBJECTS,FIXD[TROLL]);
 769         JUGGLE(CHASM);
 770         if (game.prop[BEAR] != 3)DSTROY(BEAR);
 771         game.prop[CHAIN]=0;
 772         game.fixed[CHAIN]=0;
 773         game.prop[AXE]=0;
 774         game.fixed[AXE]=0;
 775         RSPEAK(129);
 776         game.clock1= -1;
 777         game.closng=true;
 778         return true;
 779     } else if (game.clock1 < 0)
 780         --game.clock2;
 781     if (game.clock2 == 0) {
 782         /*  Once he's panicked, and clock2 has run out, we come here
 783          *  to set up the storage room.  The room has two locs,
 784          *  hardwired as 115 (ne) and 116 (sw).  At the ne end, we
 785          *  place empty bottles, a nursery of plants, a bed of
 786          *  oysters, a pile of lamps, rods with stars, sleeping
 787          *  dwarves, and him.  At the sw end we place grate over
 788          *  treasures, snake pit, covey of caged birds, more rods, and
 789          *  pillows.  A mirror stretches across one wall.  Many of the
 790          *  objects come from known locations and/or states (e.g. the
 791          *  snake is known to have been destroyed and needn't be
 792          *  carried away from its old "place"), making the various
 793          *  objects be handled differently.  We also drop all other
 794          *  objects he might be carrying (lest he have some which
 795          *  could cause trouble, such as the keys).  We describe the
 796          *  flash of light and trundle back. */
 797         game.prop[BOTTLE]=PUT(BOTTLE,115,1);
 798         game.prop[PLANT]=PUT(PLANT,115,0);
 799         game.prop[OYSTER]=PUT(OYSTER,115,0);
 800         OBJTXT[OYSTER]=3;
 801         game.prop[LAMP]=PUT(LAMP,115,0);
 802         game.prop[ROD]=PUT(ROD,115,0);
 803         game.prop[DWARF]=PUT(DWARF,115,0);
 804         game.loc=115;
 805         game.oldloc=115;
 806         game.newloc=115;
 807         /*  Leave the grate with normal (non-negative) property.
 808          *  Reuse sign. */
 809         PUT(GRATE,116,0);
 810         PUT(SIGN,116,0);
 811         ++OBJTXT[SIGN];
 812         game.prop[SNAKE]=PUT(SNAKE,116,1);
 813         game.prop[BIRD]=PUT(BIRD,116,1);
 814         game.prop[CAGE]=PUT(CAGE,116,0);
 815         game.prop[ROD2]=PUT(ROD2,116,0);
 816         game.prop[PILLOW]=PUT(PILLOW,116,0);
 817
 818         game.prop[MIRROR]=PUT(MIRROR,115,0);
 819         game.fixed[MIRROR]=116;
 820
 821         for (int i=1; i<=NOBJECTS; i++) {
 822             if (TOTING(i))
 823                 DSTROY(i);
 824         }
 825
 826         RSPEAK(132);
 827         game.closed=true;
 828         return true;
 829     }
 830
 831     return false;
 832 }
 833
 834 static void lampcheck(void)
 835 /* Check game limit and lamp timers */
 836 {
 837     if (game.prop[LAMP] == 1)
 838         --game.limit;
 839
 840     /*  Another way we can force an end to things is by having the
 841      *  lamp give out.  When it gets close, we come here to warn
 842      *  him.  First following ar, if the lamp and fresh batteries are
 843      *  here, in which case we replace the batteries and continue.
 844      *  Second is for other cases of lamp dying.  12400 is when it
 845      *  goes out.  Even then, he can explore outside for a while
 846      *  if desired. */
 847     if (game.limit<=30 && HERE(BATTER) && game.prop[BATTER]==0 && HERE(LAMP))
 848     {
 849         RSPEAK(188);
 850         game.prop[BATTER]=1;
 851         if (TOTING(BATTER))
 852             DROP(BATTER,game.loc);
 853         game.limit=game.limit+2500;
 854         game.lmwarn=false;
 855     } else if (game.limit == 0) {
 856         game.limit= -1;
 857         game.prop[LAMP]=0;
 858         if (HERE(LAMP))
 859             RSPEAK(184);
 860     } else if (game.limit <= 30) {
 861         if (!game.lmwarn && HERE(LAMP)) {
 862             game.lmwarn=true;
 863             int spk=187;
 864             if (game.place[BATTER] == 0)spk=183;
 865             if (game.prop[BATTER] == 1)spk=189;
 866             RSPEAK(spk);
 867         }
 868     }
 869 }
 870
 871 static void listobjects(void)
 872 /*  Print out descriptions of objects at this location.  If
 873  *  not closing and property value is negative, tally off
 874  *  another treasure.  Rug is special case; once seen, its
 875  *  game.prop is 1 (dragon on it) till dragon is killed.
 876  *  Similarly for chain; game.prop is initially 1 (locked to
 877  *  bear).  These hacks are because game.prop=0 is needed to
 878  *  get full score. */
 879 {
 880     if (!DARK(game.loc)) {
 881         long obj;
 882         ++game.abbrev[game.loc];
 883         for (int i=game.atloc[game.loc]; i != 0; i=game.link[i]) {
 884             obj=i;
 885             if (obj > NOBJECTS)obj=obj-NOBJECTS;
 886             if (obj == STEPS && TOTING(NUGGET))
 887                 continue;
 888             if (game.prop[obj] < 0) {
 889                 if (game.closed)
 890                     continue;
 891                 game.prop[obj]=0;
 892                 if (obj == RUG || obj == CHAIN)
 893                     game.prop[obj]=1;
 894                 --game.tally;
 895                 /*  Note: There used to be a test here to see whether the
 896                  *  player had blown it so badly that he could never ever see
 897                  *  the remaining treasures, and if so the lamp was zapped to
 898                  *  35 turns.  But the tests were too simple-minded; things
 899                  *  like killing the bird before the snake was gone (can never
 900                  *  see jewelry), and doing it "right" was hopeless.  E.G.,
 901                  *  could cross troll bridge several times, using up all
 902                  *  available treasures, breaking vase, using coins to buy
 903                  *  batteries, etc., and eventually never be able to get
 904                  *  across again.  If bottle were left on far side, could then
 905                  *  never get eggs or trident, and the effects propagate.  So
 906                  *  the whole thing was flushed.  anyone who makes such a
 907                  *  gross blunder isn't likely to find everything else anyway
 908                  *  (so goes the rationalisation). */
 909             }
 910             int kk=game.prop[obj];
 911             if (obj == STEPS && game.loc == game.fixed[STEPS])
 912                 kk=1;
 913             PSPEAK(obj,kk);
 914         }
 915     }
 916 }
 917
 918 static bool do_command(FILE *cmdin)
 919 /* Get and execute a command */
 920 {
 921     long KQ, VERB, KK, V1, V2;
 922     long i, k, KMOD;
 923     static long igo = 0;
 924     static long obj = 0;
 925     enum speechpart part;
 926
 927     /*  Can't leave cave once it's closing (except by main office). */
 928     if (OUTSID(game.newloc) && game.newloc != 0 && game.closng) {
 929         RSPEAK(130);
 930         game.newloc=game.loc;
 931         if (!game.panic)game.clock2=15;
 932         game.panic=true;
 933     }
 934
 935     /*  See if a dwarf has seen him and has come from where he
 936      *  wants to go.  If so, the dwarf's blocking his way.  If
 937      *  coming from place forbidden to pirate (dwarves rooted in
 938      *  place) let him get out (and attacked). */
 939     if (game.newloc != game.loc && !FORCED(game.loc) && !CNDBIT(game.loc,3)) {
 940         for (i=1; i<=NDWARVES-1; i++) {
 941             if (game.odloc[i] == game.newloc && game.dseen[i]) {
 942                 game.newloc=game.loc;
 943                 RSPEAK(2);
 944                 break;
 945             }
 946         }
 947     }
 948     game.loc=game.newloc;
 949
 950     if (!dwarfmove())
 951         croak(cmdin);
 952
 953     /*  Describe the current location and (maybe) get next command. */
 954
 955     for (;;) {
 956         if (game.loc == 0)
 957             croak(cmdin);
 958         char* msg = short_location_descriptions[game.loc];
 959         if (MOD(game.abbrev[game.loc],game.abbnum) == 0 || msg == 0)
 960             msg=long_location_descriptions[game.loc];
 961         if (!FORCED(game.loc) && DARK(game.loc)) {
 962             /*  The easiest way to get killed is to fall into a pit in
 963              *  pitch darkness. */
 964             if (game.wzdark && PCT(35)) {
 965                 RSPEAK(23);
 966                 game.oldlc2 = game.loc;
 967                 croak(cmdin);
 968                 continue;       /* back to top of main interpreter loop */
 969             }
 970             msg=arbitrary_messages[16];
 971         }
 972         if (TOTING(BEAR))RSPEAK(141);
 973         newspeak(msg);
 974         if (FORCED(game.loc)) {
 975             if (playermove(cmdin, VERB, 1))
 976                 return true;
 977             else
 978                 continue;       /* back to top of main interpreter loop */
 979         }
 980         if (game.loc == 33 && PCT(25) && !game.closng)RSPEAK(7);
 981
 982         listobjects();
 983
 984     L2012:
 985         VERB=0;
 986         game.oldobj=obj;
 987         obj=0;
 988
 989     L2600:
 990         checkhints(cmdin);
 991
 992         /*  If closing time, check for any objects being toted with
 993          *  game.prop < 0 and set the prop to -1-game.prop.  This way
 994          *  objects won't be described until they've been picked up
 995          *  and put down separate from their respective piles.  Don't
 996          *  tick game.clock1 unless well into cave (and not at Y2). */
 997         if (game.closed) {
 998             if (game.prop[OYSTER] < 0 && TOTING(OYSTER))
 999                 PSPEAK(OYSTER,1);
1000             for (i=1; i<=NOBJECTS; i++) {
1001                 if (TOTING(i) && game.prop[i] < 0)
1002                     game.prop[i] = -1-game.prop[i];
1003             }
1004         }
1005         game.wzdark=DARK(game.loc);
1006         if (game.knfloc > 0 && game.knfloc != game.loc)
1007             game.knfloc=0;
1008
1009         /* This is where we get a new command from the user */
1010         if (!GETIN(cmdin, &WD1,&WD1X,&WD2,&WD2X))
1011             return false;
1012
1013         /*  Every input, check "game.foobar" flag.  If zero, nothing's
1014          *  going on.  If pos, make neg.  If neg, he skipped a word,
1015          *  so make it zero. */
1016     L2607:
1017         game.foobar=(game.foobar>0 ? -game.foobar : 0);
1018         ++game.turns;
1019         if (game.turns == game.thresh) {
1020             newspeak(turn_threshold_messages[game.trndex]);
1021             game.trnluz=game.trnluz+TRNVAL[game.trndex]/100000;
1022             ++game.trndex;
1023             game.thresh = -1;
1024             if (game.trndex <= TRNVLS)
1025                 game.thresh=MOD(TRNVAL[game.trndex],100000)+1;
1026         }
1027         if (VERB == SAY && WD2 > 0)
1028             VERB=0;
1029         if (VERB == SAY) {
1030             part=transitive;
1031             goto Laction;
1032         }
1033         if (closecheck()) {
1034             if (game.closed)
1035                 return true;
1036         } else
1037             lampcheck();
1038
1039         k=43;
1040         if (LIQLOC(game.loc) == WATER)k=70;
1041         V1=VOCAB(WD1,-1);
1042         V2=VOCAB(WD2,-1);
1043         if (V1 == ENTER && (V2 == STREAM || V2 == 1000+WATER)) {
1044             RSPEAK(k);
1045             goto L2012;
1046         }
1047         if (V1 == ENTER && WD2 > 0) {
1048             WD1=WD2;
1049             WD1X=WD2X;
1050             WD2=0;
1051         } else {
1052             if (!((V1 != 1000+WATER && V1 != 1000+OIL) ||
1053                   (V2 != 1000+PLANT && V2 != 1000+DOOR))) {
1054                 if (AT(V2-1000))
1055                     WD2=MAKEWD(16152118);
1056             }
1057             if (V1 == 1000+CAGE && V2 == 1000+BIRD && HERE(CAGE) && HERE(BIRD))
1058                 WD1=MAKEWD(301200308);
1059         }
1060     L2620:
1061         if (WD1 == MAKEWD(23051920)) {
1062             ++game.iwest;
1063             if (game.iwest == 10)
1064                 RSPEAK(17);
1065         }
1066         if (WD1 == MAKEWD( 715) && WD2 != 0) {
1067             if (++igo == 10)
1068                 RSPEAK(276);
1069         }
1070     L2630:
1071         i=VOCAB(WD1,-1);
1072         if (i == -1) {
1073             /* Gee, I don't understand. */
1074             if (fallback_handler(rawbuf))
1075                 return true;
1076             SETPRM(1,WD1,WD1X);
1077             RSPEAK(254);
1078             goto L2600;
1079         }
1080         KMOD=MOD(i,1000);
1081         KQ=i/1000+1;
1082         switch (KQ-1)
1083         {
1084         case 0:
1085             if (playermove(cmdin, VERB, KMOD))
1086                 return true;
1087             else
1088                 continue;       /* back to top of main interpreter loop */
1089         case 1: part=unknown; obj = KMOD; break;
1090         case 2: part=intransitive; VERB = KMOD; break;
1091         case 3: RSPEAK(KMOD); goto L2012;
1092         default: BUG(22);
1093         }
1094
1095     Laction:
1096         switch (action(cmdin, part, VERB, obj)) {
1097         case GO_TERMINATE:
1098             return true;
1099         case GO_MOVE:
1100             playermove(cmdin, VERB, NUL);
1101             return true;
1102         case GO_TOP: continue;  /* back to top of main interpreter loop */
1103         case GO_CLEAROBJ: goto L2012;
1104         case GO_CHECKHINT: goto L2600;
1105         case GO_CHECKFOO: goto L2607;
1106         case GO_LOOKUP: goto L2630;
1107         case GO_WORD2:
1108             /* Get second word for analysis. */
1109             WD1=WD2;
1110             WD1X=WD2X;
1111             WD2=0;
1112             goto L2620;
1113         case GO_UNKNOWN:
1114             /*  Random intransitive verbs come here.  Clear obj just in case
1115              *  (see attack()). */
1116             SETPRM(1,WD1,WD1X);
1117             RSPEAK(257);
1118             obj=0;
1119             goto L2600;
1120         case GO_DWARFWAKE:
1121             /*  Oh dear, he's disturbed the dwarves. */
1122             RSPEAK(136);
1123             score(0);
1124             return true;
1125         default:
1126             BUG(99);
1127         }
1128     }
1129 }
1130
1131 /* end */