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     for (;;) {
 610         game.newloc=LL/1000;
 611         motion=MOD(game.newloc,100);
 612         if (game.newloc <= 300) {
 613             if (game.newloc <= 100) {
 614                 if (game.newloc == 0 || PCT(game.newloc))
 615                     break;
 616                 /* else fall through */
 617             } if (TOTING(motion) || (game.newloc > 200 && AT(motion)))
 618                   break;
 619             /* else fall through */
 620         }
 621         else if (game.prop[motion] != game.newloc/100-3)
 622             break;
 623     L12:
 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             goto L12;
 658         case 3:
 659             /*  Travel 303.  Troll bridge.  Must be done only as special
 660              *  motion so that dwarves won't wander across and encounter
 661              *  the bear.  (They won't follow the player there because
 662              *  that region is forbidden to the pirate.)  If
 663              *  game.prop(TROLL)=1, he's crossed since paying, so step out
 664              *  and block him.  (standard travel entries check for
 665              *  game.prop(TROLL)=0.)  Special stuff for bear. */
 666             if (game.prop[TROLL] == 1) {
 667                 PSPEAK(TROLL,1);
 668                 game.prop[TROLL]=0;
 669                 MOVE(TROLL2,0);
 670                 MOVE(TROLL2+NOBJECTS,0);
 671                 MOVE(TROLL,PLAC[TROLL]);
 672                 MOVE(TROLL+NOBJECTS,FIXD[TROLL]);
 673                 JUGGLE(CHASM);
 674                 game.newloc=game.loc;
 675                 return true;
 676             } else {
 677                 game.newloc=PLAC[TROLL]+FIXD[TROLL]-game.loc;
 678                 if (game.prop[TROLL] == 0)game.prop[TROLL]=1;
 679                 if (!TOTING(BEAR)) return true;
 680                 RSPEAK(162);
 681                 game.prop[CHASM]=1;
 682                 game.prop[TROLL]=2;
 683                 DROP(BEAR,game.newloc);
 684                 game.fixed[BEAR]= -1;
 685                 game.prop[BEAR]=3;
 686                 game.oldlc2=game.newloc;
 687                 croak(cmdin);
 688                 return false;
 689             }
 690         }
 691         BUG(20);
 692     }
 693     RSPEAK(game.newloc-500);
 694     game.newloc=game.loc;
 695     return true;
 696 }
 697
 698 static bool closecheck(void)
 699 /*  Handle the closing of the cave.  The cave closes "clock1" turns
 700  *  after the last treasure has been located (including the pirate's
 701  *  chest, which may of course never show up).  Note that the
 702  *  treasures need not have been taken yet, just located.  Hence
 703  *  clock1 must be large enough to get out of the cave (it only ticks
 704  *  while inside the cave).  When it hits zero, we branch to 10000 to
 705  *  start closing the cave, and then sit back and wait for him to try
 706  *  to get out.  If he doesn't within clock2 turns, we close the cave;
 707  *  if he does try, we assume he panics, and give him a few additional
 708  *  turns to get frantic before we close.  When clock2 hits zero, we
 709  *  branch to 11000 to transport him into the final puzzle.  Note that
 710  *  the puzzle depends upon all sorts of random things.  For instance,
 711  *  there must be no water or oil, since there are beanstalks which we
 712  *  don't want to be able to water, since the code can't handle it.
 713  *  Also, we can have no keys, since there is a grate (having moved
 714  *  the fixed object!) there separating him from all the treasures.
 715  *  Most of these problems arise from the use of negative prop numbers
 716  *  to suppress the object descriptions until he's actually moved the
 717  *  objects. */
 718 {
 719     if (game.tally == 0 && INDEEP(game.loc) && game.loc != 33)
 720         --game.clock1;
 721
 722     /*  When the first warning comes, we lock the grate, destroy
 723      *  the bridge, kill all the dwarves (and the pirate), remove
 724      *  the troll and bear (unless dead), and set "closng" to
 725      *  true.  Leave the dragon; too much trouble to move it.
 726      *  from now until clock2 runs out, he cannot unlock the
 727      *  grate, move to any location outside the cave, or create
 728      *  the bridge.  Nor can he be resurrected if he dies.  Note
 729      *  that the snake is already gone, since he got to the
 730      *  treasure accessible only via the hall of the mountain
 731      *  king. Also, he's been in giant room (to get eggs), so we
 732      *  can refer to it.  Also also, he's gotten the pearl, so we
 733      *  know the bivalve is an oyster.  *And*, the dwarves must
 734      *  have been activated, since we've found chest. */
 735     if (game.clock1 == 0)
 736     {
 737         game.prop[GRATE]=0;
 738         game.prop[FISSUR]=0;
 739         for (int i=1; i<=NDWARVES; i++) {
 740             game.dseen[i]=false;
 741             game.dloc[i]=0;
 742         }
 743         MOVE(TROLL,0);
 744         MOVE(TROLL+NOBJECTS,0);
 745         MOVE(TROLL2,PLAC[TROLL]);
 746         MOVE(TROLL2+NOBJECTS,FIXD[TROLL]);
 747         JUGGLE(CHASM);
 748         if (game.prop[BEAR] != 3)DSTROY(BEAR);
 749         game.prop[CHAIN]=0;
 750         game.fixed[CHAIN]=0;
 751         game.prop[AXE]=0;
 752         game.fixed[AXE]=0;
 753         RSPEAK(129);
 754         game.clock1= -1;
 755         game.closng=true;
 756         return true;
 757     } else if (game.clock1 < 0)
 758         --game.clock2;
 759     if (game.clock2 == 0) {
 760         /*  Once he's panicked, and clock2 has run out, we come here
 761          *  to set up the storage room.  The room has two locs,
 762          *  hardwired as 115 (ne) and 116 (sw).  At the ne end, we
 763          *  place empty bottles, a nursery of plants, a bed of
 764          *  oysters, a pile of lamps, rods with stars, sleeping
 765          *  dwarves, and him.  At the sw end we place grate over
 766          *  treasures, snake pit, covey of caged birds, more rods, and
 767          *  pillows.  A mirror stretches across one wall.  Many of the
 768          *  objects come from known locations and/or states (e.g. the
 769          *  snake is known to have been destroyed and needn't be
 770          *  carried away from its old "place"), making the various
 771          *  objects be handled differently.  We also drop all other
 772          *  objects he might be carrying (lest he have some which
 773          *  could cause trouble, such as the keys).  We describe the
 774          *  flash of light and trundle back. */
 775         game.prop[BOTTLE]=PUT(BOTTLE,115,1);
 776         game.prop[PLANT]=PUT(PLANT,115,0);
 777         game.prop[OYSTER]=PUT(OYSTER,115,0);
 778         OBJTXT[OYSTER]=3;
 779         game.prop[LAMP]=PUT(LAMP,115,0);
 780         game.prop[ROD]=PUT(ROD,115,0);
 781         game.prop[DWARF]=PUT(DWARF,115,0);
 782         game.loc=115;
 783         game.oldloc=115;
 784         game.newloc=115;
 785         /*  Leave the grate with normal (non-negative) property.
 786          *  Reuse sign. */
 787         PUT(GRATE,116,0);
 788         PUT(SIGN,116,0);
 789         ++OBJTXT[SIGN];
 790         game.prop[SNAKE]=PUT(SNAKE,116,1);
 791         game.prop[BIRD]=PUT(BIRD,116,1);
 792         game.prop[CAGE]=PUT(CAGE,116,0);
 793         game.prop[ROD2]=PUT(ROD2,116,0);
 794         game.prop[PILLOW]=PUT(PILLOW,116,0);
 795
 796         game.prop[MIRROR]=PUT(MIRROR,115,0);
 797         game.fixed[MIRROR]=116;
 798
 799         for (int i=1; i<=NOBJECTS; i++) {
 800             if (TOTING(i))
 801                 DSTROY(i);
 802         }
 803
 804         RSPEAK(132);
 805         game.closed=true;
 806         return true;
 807     }
 808
 809     return false;
 810 }
 811
 812 static void lampcheck(void)
 813 /* Check game limit and lamp timers */
 814 {
 815     if (game.prop[LAMP] == 1)
 816         --game.limit;
 817
 818     /*  Another way we can force an end to things is by having the
 819      *  lamp give out.  When it gets close, we come here to warn
 820      *  him.  First following ar, if the lamp and fresh batteries are
 821      *  here, in which case we replace the batteries and continue.
 822      *  Second is for other cases of lamp dying.  12400 is when it
 823      *  goes out.  Even then, he can explore outside for a while
 824      *  if desired. */
 825     if (game.limit<=30 && HERE(BATTER) && game.prop[BATTER]==0 && HERE(LAMP))
 826     {
 827         RSPEAK(188);
 828         game.prop[BATTER]=1;
 829         if (TOTING(BATTER))
 830             DROP(BATTER,game.loc);
 831         game.limit=game.limit+2500;
 832         game.lmwarn=false;
 833     } else if (game.limit == 0) {
 834         game.limit= -1;
 835         game.prop[LAMP]=0;
 836         if (HERE(LAMP))
 837             RSPEAK(184);
 838     } else if (game.limit <= 30) {
 839         if (!game.lmwarn && HERE(LAMP)) {
 840             game.lmwarn=true;
 841             int spk=187;
 842             if (game.place[BATTER] == 0)spk=183;
 843             if (game.prop[BATTER] == 1)spk=189;
 844             RSPEAK(spk);
 845         }
 846     }
 847 }
 848
 849 static void listobjects(void)
 850 /*  Print out descriptions of objects at this location.  If
 851  *  not closing and property value is negative, tally off
 852  *  another treasure.  Rug is special case; once seen, its
 853  *  game.prop is 1 (dragon on it) till dragon is killed.
 854  *  Similarly for chain; game.prop is initially 1 (locked to
 855  *  bear).  These hacks are because game.prop=0 is needed to
 856  *  get full score. */
 857 {
 858     if (!DARK(game.loc)) {
 859         long obj;
 860         ++game.abbrev[game.loc];
 861         for (int i=game.atloc[game.loc]; i != 0; i=game.link[i]) {
 862             obj=i;
 863             if (obj > NOBJECTS)obj=obj-NOBJECTS;
 864             if (obj == STEPS && TOTING(NUGGET))
 865                 continue;
 866             if (game.prop[obj] < 0) {
 867                 if (game.closed)
 868                     continue;
 869                 game.prop[obj]=0;
 870                 if (obj == RUG || obj == CHAIN)
 871                     game.prop[obj]=1;
 872                 --game.tally;
 873                 /*  Note: There used to be a test here to see whether the
 874                  *  player had blown it so badly that he could never ever see
 875                  *  the remaining treasures, and if so the lamp was zapped to
 876                  *  35 turns.  But the tests were too simple-minded; things
 877                  *  like killing the bird before the snake was gone (can never
 878                  *  see jewelry), and doing it "right" was hopeless.  E.G.,
 879                  *  could cross troll bridge several times, using up all
 880                  *  available treasures, breaking vase, using coins to buy
 881                  *  batteries, etc., and eventually never be able to get
 882                  *  across again.  If bottle were left on far side, could then
 883                  *  never get eggs or trident, and the effects propagate.  So
 884                  *  the whole thing was flushed.  anyone who makes such a
 885                  *  gross blunder isn't likely to find everything else anyway
 886                  *  (so goes the rationalisation). */
 887             }
 888             int kk=game.prop[obj];
 889             if (obj == STEPS && game.loc == game.fixed[STEPS])
 890                 kk=1;
 891             PSPEAK(obj,kk);
 892         }
 893     }
 894 }
 895
 896 static bool do_command(FILE *cmdin)
 897 /* Get and execute a command */
 898 {
 899     long KQ, VERB, KK, V1, V2;
 900     long i, k, KMOD;
 901     static long igo = 0;
 902     static long obj = 0;
 903     enum speechpart part;
 904
 905     /*  Can't leave cave once it's closing (except by main office). */
 906     if (OUTSID(game.newloc) && game.newloc != 0 && game.closng) {
 907         RSPEAK(130);
 908         game.newloc=game.loc;
 909         if (!game.panic)game.clock2=15;
 910         game.panic=true;
 911     }
 912
 913     /*  See if a dwarf has seen him and has come from where he
 914      *  wants to go.  If so, the dwarf's blocking his way.  If
 915      *  coming from place forbidden to pirate (dwarves rooted in
 916      *  place) let him get out (and attacked). */
 917     if (game.newloc != game.loc && !FORCED(game.loc) && !CNDBIT(game.loc,3)) {
 918         for (i=1; i<=NDWARVES-1; i++) {
 919             if (game.odloc[i] == game.newloc && game.dseen[i]) {
 920                 game.newloc=game.loc;
 921                 RSPEAK(2);
 922                 break;
 923             }
 924         }
 925     }
 926     game.loc=game.newloc;
 927
 928     if (!dwarfmove())
 929         croak(cmdin);
 930
 931     /*  Describe the current location and (maybe) get next command. */
 932
 933     for (;;) {
 934         if (game.loc == 0)
 935             croak(cmdin);
 936         char* msg = short_location_descriptions[game.loc];
 937         if (MOD(game.abbrev[game.loc],game.abbnum) == 0 || msg == 0)
 938             msg=long_location_descriptions[game.loc];
 939         if (!FORCED(game.loc) && DARK(game.loc)) {
 940             /*  The easiest way to get killed is to fall into a pit in
 941              *  pitch darkness. */
 942             if (game.wzdark && PCT(35)) {
 943                 RSPEAK(23);
 944                 game.oldlc2 = game.loc;
 945                 croak(cmdin);
 946                 continue;       /* back to top of main interpreter loop */
 947             }
 948             msg=arbitrary_messages[16];
 949         }
 950         if (TOTING(BEAR))RSPEAK(141);
 951         newspeak(msg);
 952         if (FORCED(game.loc)) {
 953             if (playermove(cmdin, VERB, 1))
 954                 return true;
 955             else
 956                 continue;       /* back to top of main interpreter loop */
 957         }
 958         if (game.loc == 33 && PCT(25) && !game.closng)RSPEAK(7);
 959
 960         listobjects();
 961
 962     L2012:
 963         VERB=0;
 964         game.oldobj=obj;
 965         obj=0;
 966
 967     L2600:
 968         checkhints(cmdin);
 969
 970         /*  If closing time, check for any objects being toted with
 971          *  game.prop < 0 and set the prop to -1-game.prop.  This way
 972          *  objects won't be described until they've been picked up
 973          *  and put down separate from their respective piles.  Don't
 974          *  tick game.clock1 unless well into cave (and not at Y2). */
 975         if (game.closed) {
 976             if (game.prop[OYSTER] < 0 && TOTING(OYSTER))
 977                 PSPEAK(OYSTER,1);
 978             for (i=1; i<=NOBJECTS; i++) {
 979                 if (TOTING(i) && game.prop[i] < 0)
 980                     game.prop[i] = -1-game.prop[i];
 981             }
 982         }
 983         game.wzdark=DARK(game.loc);
 984         if (game.knfloc > 0 && game.knfloc != game.loc)
 985             game.knfloc=0;
 986
 987         /* This is where we get a new command from the user */
 988         if (!GETIN(cmdin, &WD1,&WD1X,&WD2,&WD2X))
 989             return false;
 990
 991         /*  Every input, check "game.foobar" flag.  If zero, nothing's
 992          *  going on.  If pos, make neg.  If neg, he skipped a word,
 993          *  so make it zero. */
 994     L2607:
 995         game.foobar=(game.foobar>0 ? -game.foobar : 0);
 996         ++game.turns;
 997         if (game.turns == game.thresh) {
 998             newspeak(turn_threshold_messages[game.trndex]);
 999             game.trnluz=game.trnluz+TRNVAL[game.trndex]/100000;
1000             ++game.trndex;
1001             game.thresh = -1;
1002             if (game.trndex <= TRNVLS)
1003                 game.thresh=MOD(TRNVAL[game.trndex],100000)+1;
1004         }
1005         if (VERB == SAY && WD2 > 0)
1006             VERB=0;
1007         if (VERB == SAY) {
1008             part=transitive;
1009             goto Laction;
1010         }
1011         if (closecheck())
1012             if (game.closed)
1013                 return true;
1014             else
1015                 goto L19999;
1016
1017         lampcheck();
1018
1019     L19999:
1020         k=43;
1021         if (LIQLOC(game.loc) == WATER)k=70;
1022         V1=VOCAB(WD1,-1);
1023         V2=VOCAB(WD2,-1);
1024         if (V1 == ENTER && (V2 == STREAM || V2 == 1000+WATER)) {
1025             RSPEAK(k);
1026             goto L2012;
1027         }
1028         if (V1 == ENTER && WD2 > 0) {
1029             WD1=WD2;
1030             WD1X=WD2X;
1031             WD2=0;
1032         } else {
1033             if (!((V1 != 1000+WATER && V1 != 1000+OIL) ||
1034                   (V2 != 1000+PLANT && V2 != 1000+DOOR))) {
1035                 if (AT(V2-1000))
1036                     WD2=MAKEWD(16152118);
1037             }
1038             if (V1 == 1000+CAGE && V2 == 1000+BIRD && HERE(CAGE) && HERE(BIRD))
1039                 WD1=MAKEWD(301200308);
1040         }
1041     L2620:
1042         if (WD1 == MAKEWD(23051920)) {
1043             ++game.iwest;
1044             if (game.iwest == 10)
1045                 RSPEAK(17);
1046         }
1047         if (WD1 == MAKEWD( 715) && WD2 != 0) {
1048             if (++igo == 10)
1049                 RSPEAK(276);
1050         }
1051     L2630:
1052         i=VOCAB(WD1,-1);
1053         if (i == -1) {
1054             /* Gee, I don't understand. */
1055             if (fallback_handler(rawbuf))
1056                 return true;
1057             SETPRM(1,WD1,WD1X);
1058             RSPEAK(254);
1059             goto L2600;
1060         }
1061         KMOD=MOD(i,1000);
1062         KQ=i/1000+1;
1063         switch (KQ-1)
1064         {
1065         case 0:
1066             if (playermove(cmdin, VERB, KMOD))
1067                 return true;
1068             else
1069                 continue;       /* back to top of main interpreter loop */
1070         case 1: part=unknown; obj = KMOD; break;
1071         case 2: part=intransitive; VERB = KMOD; break;
1072         case 3: RSPEAK(KMOD); goto L2012;
1073         default: BUG(22);
1074         }
1075
1076     Laction:
1077         switch (action(cmdin, part, VERB, obj)) {
1078         case GO_TERMINATE:
1079             return true;
1080         case GO_MOVE:
1081             playermove(cmdin, VERB, NUL);
1082             return true;
1083         case GO_TOP: continue;  /* back to top of main interpreter loop */
1084         case GO_CLEAROBJ: goto L2012;
1085         case GO_CHECKHINT: goto L2600;
1086         case GO_CHECKFOO: goto L2607;
1087         case GO_LOOKUP: goto L2630;
1088         case GO_WORD2:
1089             /* Get second word for analysis. */
1090             WD1=WD2;
1091             WD1X=WD2X;
1092             WD2=0;
1093             goto L2620;
1094         case GO_UNKNOWN:
1095             /*  Random intransitive verbs come here.  Clear obj just in case
1096              *  (see attack()). */
1097             SETPRM(1,WD1,WD1X);
1098             RSPEAK(257);
1099             obj=0;
1100             goto L2600;
1101         case GO_DWARFWAKE:
1102             /*  Oh dear, he's disturbed the dwarves. */
1103             RSPEAK(136);
1104             score(0);
1105             return true;
1106         default:
1107             BUG(99);
1108         }
1109     }
1110 }
1111
1112 /* end */