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