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