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