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