main.c

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