main.c

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