+ scratchloc = scratchloc / 1000;
+
+ do {
+ /*
+ * (ESR) This special-travel loop may have to be repeated if it includes
+ * the plover passage. Same deal for any future cases where we need to
+ * block travel and then redo it once the blocking condition has been
+ * removed.
+ */
+ for (;;) { /* L12 loop */
+ for (;;) {
+ game.newloc = scratchloc / 1000;
+ motion = MOD(game.newloc, 100);
+ if (!SPECIAL(game.newloc)) {
+ if (game.newloc <= 100) {
+ if (game.newloc == 0 || PCT(game.newloc))
+ break;
+ /* else fall through */
+ }
+ if (TOTING(motion) || (game.newloc > 200 && AT(motion)))
+ break;
+ /* else fall through */
+ } else if (game.prop[motion] != game.newloc / 100 - 3)
+ break;
+ do {
+ if (TRAVEL[kk] < 0)
+ BUG(CONDITIONAL_TRAVEL_ENTRY_WITH_NO_ALTERATION);
+ ++kk;
+ game.newloc = labs(TRAVEL[kk]) / 1000;
+ } while
+ (game.newloc == scratchloc);
+ scratchloc = game.newloc;
+ }
+
+ game.newloc = MOD(scratchloc, 1000);
+ if (!SPECIAL(game.newloc))
+ return true;
+ if (game.newloc <= 500) {
+ game.newloc -= SPECIALBASE;
+ switch (game.newloc) {
+ case 1:
+ /* Travel 301. Plover-alcove passage. Can carry only
+ * emerald. Note: travel table must include "useless"
+ * entries going through passage, which can never be used for
+ * actual motion, but can be spotted by "go back". */
+ /* FIXME: Arithmetic on location numbers */
+ game.newloc = 99 + 100 - game.loc;
+ if (game.holdng > 1 || (game.holdng == 1 && !TOTING(EMERALD))) {
+ game.newloc = game.loc;
+ rspeak(MUST_DROP);
+ }
+ return true;
+ case 2:
+ /* Travel 302. Plover transport. Drop the emerald (only use
+ * special travel if toting it), so he's forced to use the
+ * plover-passage to get it out. Having dropped it, go back and
+ * pretend he wasn't carrying it after all. */
+ DROP(EMERALD, game.loc);
+ do {
+ if (TRAVEL[kk] < 0)
+ BUG(CONDITIONAL_TRAVEL_ENTRY_WITH_NO_ALTERATION);
+ ++kk;
+ game.newloc = labs(TRAVEL[kk]) / 1000;
+ } while
+ (game.newloc == scratchloc);
+ scratchloc = game.newloc;
+ continue; /* goto L12 */
+ case 3:
+ /* Travel 303. Troll bridge. Must be done only as special
+ * motion so that dwarves won't wander across and encounter
+ * the bear. (They won't follow the player there because
+ * that region is forbidden to the pirate.) If
+ * game.prop(TROLL)=1, he's crossed since paying, so step out
+ * and block him. (standard travel entries check for
+ * game.prop(TROLL)=0.) Special stuff for bear. */
+ if (game.prop[TROLL] == 1) {
+ pspeak(TROLL, 1);
+ game.prop[TROLL] = 0;
+ MOVE(TROLL2, 0);
+ MOVE(TROLL2 + NOBJECTS, 0);
+ MOVE(TROLL, PLAC[TROLL]);
+ MOVE(TROLL + NOBJECTS, FIXD[TROLL]);
+ JUGGLE(CHASM);
+ game.newloc = game.loc;
+ return true;
+ } else {
+ game.newloc = PLAC[TROLL] + FIXD[TROLL] - game.loc;
+ if (game.prop[TROLL] == 0)game.prop[TROLL] = 1;
+ if (!TOTING(BEAR)) return true;
+ rspeak(BRIDGE_COLLAPSE);
+ game.prop[CHASM] = 1;
+ game.prop[TROLL] = 2;
+ DROP(BEAR, game.newloc);
+ game.fixed[BEAR] = -1;
+ game.prop[BEAR] = 3;
+ game.oldlc2 = game.newloc;
+ croak();
+ return true;
+ }
+ }
+ BUG(SPECIAL_TRAVEL_500_GT_L_GT_300_EXCEEDS_GOTO_LIST);
+ }
+ break; /* Leave L12 loop */
+ }
+ } while
+ (false);
+ /* FIXME: Arithmetic on location number, becoming a message number */
+ rspeak(game.newloc - 500);
+ game.newloc = game.loc;
+ return true;
+}
+
+static bool closecheck(void)
+/* Handle the closing of the cave. The cave closes "clock1" turns
+ * after the last treasure has been located (including the pirate's
+ * chest, which may of course never show up). Note that the
+ * treasures need not have been taken yet, just located. Hence
+ * clock1 must be large enough to get out of the cave (it only ticks
+ * while inside the cave). When it hits zero, we branch to 10000 to
+ * start closing the cave, and then sit back and wait for him to try
+ * to get out. If he doesn't within clock2 turns, we close the cave;
+ * if he does try, we assume he panics, and give him a few additional
+ * turns to get frantic before we close. When clock2 hits zero, we
+ * branch to 11000 to transport him into the final puzzle. Note that
+ * the puzzle depends upon all sorts of random things. For instance,
+ * there must be no water or oil, since there are beanstalks which we
+ * don't want to be able to water, since the code can't handle it.
+ * Also, we can have no keys, since there is a grate (having moved
+ * the fixed object!) there separating him from all the treasures.
+ * Most of these problems arise from the use of negative prop numbers
+ * to suppress the object descriptions until he's actually moved the
+ * objects. */
+{
+ if (game.tally == 0 && INDEEP(game.loc) && game.loc != 33)
+ --game.clock1;
+
+ /* When the first warning comes, we lock the grate, destroy
+ * the bridge, kill all the dwarves (and the pirate), remove
+ * the troll and bear (unless dead), and set "closng" to
+ * true. Leave the dragon; too much trouble to move it.
+ * from now until clock2 runs out, he cannot unlock the
+ * grate, move to any location outside the cave, or create
+ * the bridge. Nor can he be resurrected if he dies. Note
+ * that the snake is already gone, since he got to the
+ * treasure accessible only via the hall of the mountain
+ * king. Also, he's been in giant room (to get eggs), so we
+ * can refer to it. Also also, he's gotten the pearl, so we
+ * know the bivalve is an oyster. *And*, the dwarves must
+ * have been activated, since we've found chest. */
+ if (game.clock1 == 0) {
+ game.prop[GRATE] = 0;
+ game.prop[FISSURE] = 0;
+ for (int i = 1; i <= NDWARVES; i++) {
+ game.dseen[i] = false;
+ game.dloc[i] = 0;
+ }
+ MOVE(TROLL, 0);
+ MOVE(TROLL + NOBJECTS, 0);
+ MOVE(TROLL2, PLAC[TROLL]);
+ MOVE(TROLL2 + NOBJECTS, FIXD[TROLL]);
+ JUGGLE(CHASM);
+ if (game.prop[BEAR] != 3)DESTROY(BEAR);
+ game.prop[CHAIN] = 0;
+ game.fixed[CHAIN] = 0;
+ game.prop[AXE] = 0;
+ game.fixed[AXE] = 0;
+ rspeak(CAVE_CLOSING);
+ game.clock1 = -1;
+ game.closng = true;
+ return true;
+ } else if (game.clock1 < 0)
+ --game.clock2;
+ if (game.clock2 == 0) {
+ /* Once he's panicked, and clock2 has run out, we come here
+ * to set up the storage room. The room has two locs,
+ * hardwired as 115 (ne) and 116 (sw). At the ne end, we
+ * place empty bottles, a nursery of plants, a bed of
+ * oysters, a pile of lamps, rods with stars, sleeping
+ * dwarves, and him. At the sw end we place grate over
+ * treasures, snake pit, covey of caged birds, more rods, and
+ * pillows. A mirror stretches across one wall. Many of the
+ * objects come from known locations and/or states (e.g. the
+ * snake is known to have been destroyed and needn't be
+ * carried away from its old "place"), making the various
+ * objects be handled differently. We also drop all other
+ * objects he might be carrying (lest he have some which
+ * could cause trouble, such as the keys). We describe the
+ * flash of light and trundle back. */
+ game.prop[BOTTLE] = PUT(BOTTLE, LOC_NE, 1);
+ game.prop[PLANT] = PUT(PLANT, LOC_NE, 0);
+ game.prop[OYSTER] = PUT(OYSTER, LOC_NE, 0);
+ OBJTXT[OYSTER] = 3;
+ game.prop[LAMP] = PUT(LAMP, LOC_NE, 0);
+ game.prop[ROD] = PUT(ROD, LOC_NE, 0);
+ game.prop[DWARF] = PUT(DWARF, LOC_NE, 0);
+ game.loc = LOC_NE;
+ game.oldloc = LOC_NE;
+ game.newloc = LOC_NE;
+ /* Leave the grate with normal (non-negative) property.
+ * Reuse sign. */
+ PUT(GRATE, LOC_SW, 0);
+ PUT(SIGN, LOC_SW, 0);
+ ++OBJTXT[SIGN];
+ game.prop[SNAKE] = PUT(SNAKE, LOC_SW, 1);
+ game.prop[BIRD] = PUT(BIRD, LOC_SW, 1);
+ game.prop[CAGE] = PUT(CAGE, LOC_SW, 0);
+ game.prop[ROD2] = PUT(ROD2, LOC_SW, 0);
+ game.prop[PILLOW] = PUT(PILLOW, LOC_SW, 0);
+
+ game.prop[MIRROR] = PUT(MIRROR, LOC_NE, 0);
+ game.fixed[MIRROR] = LOC_SW;
+
+ for (int i = 1; i <= NOBJECTS; i++) {
+ if (TOTING(i))
+ DESTROY(i);
+ }
+
+ rspeak(CAVE_CLOSED);
+ game.closed = true;
+ return true;