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