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)
 655             BUG(26);
 656         if(K == NUL)
 657             return true;
 658         if(K == BACK) {
 659             /*  Handle "go back".  Look for verb which goes from game.loc to
 660              *  game.oldloc, or to game.oldlc2 If game.oldloc has forced-motion.
 661              *  K2 saves entry -> forced loc -> previous loc. */
 662             K=game.oldloc;
 663             if(FORCED(K))K=game.oldlc2;
 664             game.oldlc2=game.oldloc;
 665             game.oldloc=game.loc;
 666             K2=0;
 667             if(K == game.loc)K2=91;
 668             if(CNDBIT(game.loc,4))K2=274;
 669             if(K2 == 0) goto L21;
 670             RSPEAK(K2);
 671             return true;
 672         }
 673         if(K == LOOK) {
 674             /*  Look.  Can't give more detail.  Pretend it wasn't dark
 675              *  (though it may "now" be dark) so he won't fall into a
 676              *  pit while staring into the gloom. */
 677             if(game.detail < 3)RSPEAK(15);
 678             game.detail=game.detail+1;
 679             game.wzdark=false;
 680             game.abbrev[game.loc]=0;
 681             return true;
 682         }
 683         if(K == CAVE) {
 684             /*  Cave.  Different messages depending on whether above ground. */
 685             RSPEAK((OUTSID(game.loc) && game.loc != 8) ? 57 : 58);
 686             return true;
 687         }
 688         game.oldlc2=game.oldloc;
 689         game.oldloc=game.loc;
 690
 691 L9:     LL=labs(TRAVEL[KK]);
 692         if(MOD(LL,1000) == 1 || MOD(LL,1000) == K) goto L10;
 693         if(TRAVEL[KK] < 0) goto L50;
 694         KK=KK+1;
 695         goto L9;
 696
 697 L10:    LL=LL/1000;
 698 L11:    game.newloc=LL/1000;
 699          K=MOD(game.newloc,100);        /* ESR: an instance of NOBJECTS? */
 700         if(game.newloc <= 300) goto L13;
 701         if(game.prop[K] != game.newloc/100-3) goto L16;
 702 L12:    if(TRAVEL[KK] < 0)BUG(25);
 703         KK=KK+1;
 704         game.newloc=labs(TRAVEL[KK])/1000;
 705         if(game.newloc == LL) goto L12;
 706         LL=game.newloc;
 707          goto L11;
 708
 709 L13:    if(game.newloc <= 100) goto L14;        /* ESR: an instance of NOBJECTS? */
 710         if(TOTING(K) || (game.newloc > 200 && AT(K))) goto L16;
 711          goto L12;
 712
 713 L14:    if(game.newloc != 0 && !PCT(game.newloc)) goto L12;
 714 L16:    game.newloc=MOD(LL,1000);
 715         if(game.newloc <= 300) return true;
 716         if(game.newloc <= 500) goto L30000;
 717         RSPEAK(game.newloc-500);
 718         game.newloc=game.loc;
 719          return true;
 720
 721 /*  Special motions come here.  Labelling convention: statement numbers NNNXX
 722  *  (XX=00-99) are used for special case number NNN (NNN=301-500). */
 723
 724 L30000: game.newloc=game.newloc-300;
 725          switch (game.newloc) { case 1: goto L30100; case 2: goto L30200; case 3: goto
 726                 L30300; }
 727         BUG(20);
 728
 729 /*  Travel 301.  Plover-alcove passage.  Can carry only emerald.  Note: travel
 730  *  table must include "useless" entries going through passage, which can never
 731  *  be used for actual motion, but can be spotted by "go back". */
 732
 733 L30100: game.newloc=99+100-game.loc;    /* ESR: an instance of NOBJECTS? */
 734         if(game.holdng == 0 || (game.holdng == 1 && TOTING(EMRALD))) return true;
 735         game.newloc=game.loc;
 736         RSPEAK(117);
 737         return true;
 738
 739 /*  Travel 302.  Plover transport.  Drop the emerald (only use special travel if
 740  *  toting it), so he's forced to use the plover-passage to get it out.  Having
 741  *  dropped it, go back and pretend he wasn't carrying it after all. */
 742
 743 L30200: DROP(EMRALD,game.loc);
 744          goto L12;
 745
 746 /*  Travel 303.  Troll bridge.  Must be done only as special motion so that
 747  *  dwarves won't wander across and encounter the bear.  (They won't follow the
 748  *  player there because that region is forbidden to the pirate.)  If
 749  *  game.prop(TROLL)=1, he's crossed since paying, so step out and block him.
 750  *  (standard travel entries check for game.prop(TROLL)=0.)  Special stuff for bear. */
 751
 752 L30300: if(game.prop[TROLL] != 1) goto L30310;
 753         PSPEAK(TROLL,1);
 754         game.prop[TROLL]=0;
 755         MOVE(TROLL2,0);
 756         MOVE(TROLL2+NOBJECTS,0);
 757         MOVE(TROLL,PLAC[TROLL]);
 758         MOVE(TROLL+NOBJECTS,FIXD[TROLL]);
 759         JUGGLE(CHASM);
 760         game.newloc=game.loc;
 761         return true;
 762
 763 L30310: game.newloc=PLAC[TROLL]+FIXD[TROLL]-game.loc;
 764         if(game.prop[TROLL] == 0)game.prop[TROLL]=1;
 765         if(!TOTING(BEAR)) return true;
 766         RSPEAK(162);
 767         game.prop[CHASM]=1;
 768         game.prop[TROLL]=2;
 769         DROP(BEAR,game.newloc);
 770         game.fixed[BEAR]= -1;
 771         game.prop[BEAR]=3;
 772         game.oldlc2=game.newloc;
 773          goto L99;
 774
 775 /*  End of specials. */
 776
 777
 778 L21:    LL=MOD((labs(TRAVEL[KK])/1000),1000);
 779         if(LL != K) {
 780                 if(LL <= 300) {
 781                         J=KEY[LL];
 782                         if(FORCED(LL) && MOD((labs(TRAVEL[J])/1000),1000) == K)
 783                                 K2=KK;
 784                 }
 785                 if(TRAVEL[KK] < 0)
 786                     goto L23;
 787                 KK=KK+1;
 788                 goto L21;
 789
 790 L23:            KK=K2;
 791                 if(KK == 0) {
 792                         RSPEAK(140);
 793                         return true;
 794                 }
 795         }
 796
 797         K=MOD(labs(TRAVEL[KK]),1000);
 798         KK=KEY[game.loc];
 799         goto L9;
 800
 801
 802 /*  Non-applicable motion.  Various messages depending on word given. */
 803
 804 L50:    SPK=12;
 805         if(K >= 43 && K <= 50)SPK=52;
 806         if(K == 29 || K == 30)SPK=52;
 807         if(K == 7 || K == 36 || K == 37)SPK=10;
 808         if(K == 11 || K == 19)SPK=11;
 809         if(VERB == FIND || VERB == INVENT)SPK=59;
 810         if(K == 62 || K == 65)SPK=42;
 811         if(K == 17)SPK=80;
 812         RSPEAK(SPK);
 813         return true;
 814
 815 /*  "You're dead, Jim."
 816  *
 817  *  If the current loc is zero, it means the clown got himself killed.  We'll
 818  *  allow this maxdie times.  MAXDIE is automatically set based on the number of
 819  *  snide messages available.  Each death results in a message (81, 83, etc.)
 820  *  which offers reincarnation; if accepted, this results in message 82, 84,
 821  *  etc.  The last time, if he wants another chance, he gets a snide remark as
 822  *  we exit.  When reincarnated, all objects being carried get dropped at game.oldlc2
 823  *  (presumably the last place prior to being killed) without change of props.
 824  *  the loop runs backwards to assure that the bird is dropped before the cage.
 825  *  (this kluge could be changed once we're sure all references to bird and cage
 826  *  are done by keywords.)  The lamp is a special case (it wouldn't do to leave
 827  *  it in the cave).  It is turned off and left outside the building (only if he
 828  *  was carrying it, of course).  He himself is left inside the building (and
 829  *  heaven help him if he tries to xyzzy back into the cave without the lamp!).
 830  *  game.oldloc is zapped so he can't just "retreat". */
 831
 832 /*  The easiest way to get killed is to fall into a pit in pitch darkness. */
 833
 834 L90:    RSPEAK(23);
 835         game.oldlc2=game.loc;
 836
 837 /*  Okay, he's dead.  Let's get on with it. */
 838
 839 L99:    if(game.closng) {
 840         /*  He died during closing time.  No resurrection.  Tally up a
 841          *  death and exit. */
 842             RSPEAK(131);
 843             ++game.numdie;
 844             score(0);
 845         } else {
 846             ++game.numdie;
 847             if(!YES(cmdin,79+game.numdie*2,80+game.numdie*2,54))
 848                 score(0);
 849             if(game.numdie == MAXDIE)
 850                 score(0);
 851             game.place[WATER]=0;
 852             game.place[OIL]=0;
 853             if(TOTING(LAMP))
 854                 game.prop[LAMP]=0;
 855             for (J=1; J<=NOBJECTS; J++) {
 856                 I=NOBJECTS + 1 - J;
 857                 if(TOTING(I)) {
 858                     K=game.oldlc2;
 859                     if(I == LAMP)
 860                         K=1;
 861                     DROP(I,K);
 862                 }
 863             }
 864             game.loc=3;
 865             game.oldloc=game.loc;
 866             goto L2000;
 867         }
 868
 869 /*  Cave closing and scoring */
 870
 871
 872 /*  These sections handle the closing of the cave.  The cave closes "clock1"
 873  *  turns after the last treasure has been located (including the pirate's
 874  *  chest, which may of course never show up).  Note that the treasures need not
 875  *  have been taken yet, just located.  Hence clock1 must be large enough to get
 876  *  out of the cave (it only ticks while inside the cave).  When it hits zero,
 877  *  we branch to 10000 to start closing the cave, and then sit back and wait for
 878  *  him to try to get out.  If he doesn't within clock2 turns, we close the
 879  *  cave; if he does try, we assume he panics, and give him a few additional
 880  *  turns to get frantic before we close.  When clock2 hits zero, we branch to
 881  *  11000 to transport him into the final puzzle.  Note that the puzzle depends
 882  *  upon all sorts of random things.  For instance, there must be no water or
 883  *  oil, since there are beanstalks which we don't want to be able to water,
 884  *  since the code can't handle it.  Also, we can have no keys, since there is a
 885  *  grate (having moved the fixed object!) there separating him from all the
 886  *  treasures.  Most of these problems arise from the use of negative prop
 887  *  numbers to suppress the object descriptions until he's actually moved the
 888  *  objects. */
 889
 890 /*  When the first warning comes, we lock the grate, destroy the bridge, kill
 891  *  all the dwarves (and the pirate), remove the troll and bear (unless dead),
 892  *  and set "closng" to true.  Leave the dragon; too much trouble to move it.
 893  *  from now until clock2 runs out, he cannot unlock the grate, move to any
 894  *  location outside the cave, or create the bridge.  Nor can he be
 895  *  resurrected if he dies.  Note that the snake is already gone, since he got
 896  *  to the treasure accessible only via the hall of the mountain king. Also, he's
 897  *  been in giant room (to get eggs), so we can refer to it.  Also also, he's
 898  *  gotten the pearl, so we know the bivalve is an oyster.  *And*, the dwarves
 899  *  must have been activated, since we've found chest. */
 900
 901 L10000: game.prop[GRATE]=0;
 902         game.prop[FISSUR]=0;
 903         for (I=1; I<=NDWARVES; I++) {
 904         game.dseen[I]=false;
 905         game.dloc[I]=0;
 906         } /* end loop */
 907         MOVE(TROLL,0);
 908         MOVE(TROLL+NOBJECTS,0);
 909         MOVE(TROLL2,PLAC[TROLL]);
 910         MOVE(TROLL2+NOBJECTS,FIXD[TROLL]);
 911         JUGGLE(CHASM);
 912         if(game.prop[BEAR] != 3)DSTROY(BEAR);
 913         game.prop[CHAIN]=0;
 914         game.fixed[CHAIN]=0;
 915         game.prop[AXE]=0;
 916         game.fixed[AXE]=0;
 917         RSPEAK(129);
 918         game.clock1= -1;
 919         game.closng=true;
 920          goto L19999;
 921
 922 /*  Once he's panicked, and clock2 has run out, we come here to set up the
 923  *  storage room.  The room has two locs, hardwired as 115 (ne) and 116 (sw).
 924  *  At the ne end, we place empty bottles, a nursery of plants, a bed of
 925  *  oysters, a pile of lamps, rods with stars, sleeping dwarves, and him.  At
 926  *  the sw end we place grate over treasures, snake pit, covey of caged birds,
 927  *  more rods, and pillows.  A mirror stretches across one wall.  Many of the
 928  *  objects come from known locations and/or states (e.g. the snake is known to
 929  *  have been destroyed and needn't be carried away from its old "place"),
 930  *  making the various objects be handled differently.  We also drop all other
 931  *  objects he might be carrying (lest he have some which could cause trouble,
 932  *  such as the keys).  We describe the flash of light and trundle back. */
 933
 934 L11000: game.prop[BOTTLE]=PUT(BOTTLE,115,1);
 935         game.prop[PLANT]=PUT(PLANT,115,0);
 936         game.prop[OYSTER]=PUT(OYSTER,115,0);
 937         OBJTXT[OYSTER]=3;
 938         game.prop[LAMP]=PUT(LAMP,115,0);
 939         game.prop[ROD]=PUT(ROD,115,0);
 940         game.prop[DWARF]=PUT(DWARF,115,0);
 941         game.loc=115;
 942         game.oldloc=115;
 943         game.newloc=115;
 944
 945 /*  Leave the grate with normal (non-negative) property.  Reuse sign. */
 946
 947         I=PUT(GRATE,116,0);
 948         I=PUT(SIGN,116,0);
 949         OBJTXT[SIGN]=OBJTXT[SIGN]+1;
 950         game.prop[SNAKE]=PUT(SNAKE,116,1);
 951         game.prop[BIRD]=PUT(BIRD,116,1);
 952         game.prop[CAGE]=PUT(CAGE,116,0);
 953         game.prop[ROD2]=PUT(ROD2,116,0);
 954         game.prop[PILLOW]=PUT(PILLOW,116,0);
 955
 956         game.prop[MIRROR]=PUT(MIRROR,115,0);
 957         game.fixed[MIRROR]=116;
 958
 959         for (I=1; I<=NOBJECTS; I++) {
 960                 if(TOTING(I))
 961                         DSTROY(I);
 962         } /* end loop */
 963
 964         RSPEAK(132);
 965         game.closed=true;
 966         return true;
 967
 968 /*  Another way we can force an end to things is by having the lamp give out.
 969  *  When it gets close, we come here to warn him.  We go to 12000 if the lamp
 970  *  and fresh batteries are here, in which case we replace the batteries and
 971  *  continue.  12200 is for other cases of lamp dying.  12400 is when it goes
 972  *  out.  Even then, he can explore outside for a while if desired. */
 973
 974 L12000: RSPEAK(188);
 975         game.prop[BATTER]=1;
 976         if(TOTING(BATTER))DROP(BATTER,game.loc);
 977         game.limit=game.limit+2500;
 978         game.lmwarn=false;
 979          goto L19999;
 980
 981 L12200: if(game.lmwarn || !HERE(LAMP)) goto L19999;
 982         game.lmwarn=true;
 983         SPK=187;
 984         if(game.place[BATTER] == 0)SPK=183;
 985         if(game.prop[BATTER] == 1)SPK=189;
 986         RSPEAK(SPK);
 987          goto L19999;
 988
 989 L12400: game.limit= -1;
 990         game.prop[LAMP]=0;
 991         if(HERE(LAMP))RSPEAK(184);
 992          goto L19999;
 993
 994 /*  Oh dear, he's disturbed the dwarves. */
 995
 996 L18999: RSPEAK(SPK);
 997 L19000: RSPEAK(136);
 998         score(0);
 999         return true;
1000 }