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