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