main.c

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