+ /* (ESR) We've found a destination that goes with the motion verb.
+ * Next we need to check any conditional(s) on this destination, and
+ * possibly on following entries. */
+ /* FIXME: Magic numbers related to move opcodes */
+ do {
+ for (;;) { /* L12 loop */
+ for (;;) {
+ long cond = travel[travel_entry].cond;
+ long arg = MOD(cond, 100);
+ if (!SPECIAL(cond)) {
+ /* YAML N and [pct N] conditionals */
+ if (cond <= 100) {
+ if (cond == 0 ||
+ PCT(cond))
+ break;
+ /* else fall through */
+ }
+ /* YAML [with OBJ] clause */
+ if (TOTING(arg) ||
+ (cond > 200 && AT(arg)))
+ break;
+ /* else fall through to check [not OBJ STATE] */
+ } else if (game.prop[arg] != cond / 100 - 3)
+ break;
+
+ /* We arrive here on conditional failure.
+ * Skip to next non-matching destination */
+ long te_tmp = travel_entry;
+ do {
+ if (travel[te_tmp].stop)
+ BUG(CONDITIONAL_TRAVEL_ENTRY_WITH_NO_ALTERATION); // LCOV_EXCL_LINE
+ ++te_tmp;
+ } while
+ (traveleq(travel_entry, te_tmp));
+ travel_entry = te_tmp;
+ }
+
+ /* Found an eligible rule, now execute it */
+ game.newloc = travel[travel_entry].dest;
+ if (!SPECIAL(game.newloc))
+ return;
+
+ if (game.newloc > 500) {
+ /* Execute a speak rule */
+ rspeak(L_SPEAK(game.newloc));
+ game.newloc = game.loc;
+ return;
+ } else {
+ game.newloc -= SPECIALBASE;
+ switch (game.newloc) {
+ case 1:
+ /* Special travel 1. 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". */
+ game.newloc = (game.loc == LOC_PLOVER)
+ ? LOC_ALCOVE
+ : LOC_PLOVER;
+ if (game.holdng > 1 ||
+ (game.holdng == 1 && !TOTING(EMERALD))) {
+ game.newloc = game.loc;
+ rspeak(MUST_DROP);
+ }
+ return;
+ case 2:
+ /* Special travel 2. 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);
+ int te_tmp = travel_entry;
+ do {
+ if (travel[te_tmp].stop)
+ BUG(CONDITIONAL_TRAVEL_ENTRY_WITH_NO_ALTERATION); // LCOV_EXCL_LINE
+ ++te_tmp;
+ } while
+ (traveleq(travel_entry, te_tmp));
+ travel_entry = te_tmp;
+ continue; /* goto L12 */
+ case 3:
+ /* Special travel 3. 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] == TROLL_PAIDONCE) {
+ pspeak(TROLL, look, TROLL_PAIDONCE, true);
+ game.prop[TROLL] = TROLL_UNPAID;
+ move(TROLL2, 0);
+ move(TROLL2 + NOBJECTS, 0);
+ move(TROLL, objects[TROLL].plac);
+ move(TROLL + NOBJECTS, objects[TROLL].fixd);
+ juggle(CHASM);
+ game.newloc = game.loc;
+ return;
+ } else {
+ game.newloc = objects[TROLL].plac + objects[TROLL].fixd - game.loc;
+ if (game.prop[TROLL] == TROLL_UNPAID)
+ game.prop[TROLL] = TROLL_PAIDONCE;
+ if (!TOTING(BEAR))
+ return;
+ state_change(CHASM, BRIDGE_WRECKED);
+ game.prop[TROLL] = TROLL_GONE;
+ drop(BEAR, game.newloc);
+ game.fixed[BEAR] = IS_FIXED;
+ game.prop[BEAR] = BEAR_DEAD;
+ game.oldlc2 = game.newloc;
+ croak();
+ return;
+ }
+ default:
+ BUG(SPECIAL_TRAVEL_500_GT_L_GT_300_EXCEEDS_GOTO_LIST); // LCOV_EXCL_LINE
+ }
+ }
+ break; /* Leave L12 loop */
+ }
+ } while
+ (false);
+}
+
+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
+ * 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. */
+{
+ /* Don't tick game.clock1 unless well into cave (and not at Y2). */
+ if (game.tally == 0 && INDEEP(game.loc) && game.loc != LOC_Y2)
+ --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] = GRATE_CLOSED;
+ game.prop[FISSURE] = UNBRIDGED;
+ for (int i = 1; i <= NDWARVES; i++) {
+ game.dseen[i] = false;
+ game.dloc[i] = 0;
+ }
+ move(TROLL, 0);
+ move(TROLL + NOBJECTS, 0);
+ move(TROLL2, objects[TROLL].plac);
+ move(TROLL2 + NOBJECTS, objects[TROLL].fixd);
+ juggle(CHASM);
+ if (game.prop[BEAR] != BEAR_DEAD)
+ DESTROY(BEAR);
+ game.prop[CHAIN] = CHAIN_HEAP;
+ game.fixed[CHAIN] = IS_FREE;
+ game.prop[AXE] = AXE_HERE;
+ game.fixed[AXE] = IS_FREE;
+ 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 LOC_NE and LOC_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, EMPTY_BOTTLE);
+ game.prop[PLANT] = put(PLANT, LOC_NE, 0);
+ game.prop[OYSTER] = put(OYSTER, LOC_NE, 0);
+ 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);
+ game.prop[SIGN] = ENDGAME_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;
+ }
+
+ return false;
+}
+
+static void lampcheck(void)
+/* Check game limit and lamp timers */
+{
+ if (game.prop[LAMP] == LAMP_BRIGHT)
+ --game.limit;
+
+ /* Another way we can force an end to things is by having the
+ * lamp give out. When it gets close, we come here to warn him.
+ * First following arm checks if the lamp and fresh batteries are
+ * here, in which case we replace the batteries and continue.
+ * Second is for other cases of lamp dying. Eve after it goes
+ * out, he can explore outside for a while if desired. */
+ if (game.limit <= WARNTIME && HERE(BATTERY) && game.prop[BATTERY] == FRESH_BATTERIES && HERE(LAMP)) {
+ rspeak(REPLACE_BATTERIES);
+ game.prop[BATTERY] = DEAD_BATTERIES;
+ if (TOTING(BATTERY))
+ drop(BATTERY, game.loc);
+ game.limit += BATTERYLIFE;
+ game.lmwarn = false;
+ } else if (game.limit == 0) {
+ game.limit = -1;
+ game.prop[LAMP] = LAMP_DARK;
+ if (HERE(LAMP))
+ rspeak(LAMP_OUT);
+ } else if (game.limit <= WARNTIME) {
+ if (!game.lmwarn && HERE(LAMP)) {
+ game.lmwarn = true;
+ int spk = GET_BATTERIES;
+ if (game.place[BATTERY] == LOC_NOWHERE)
+ spk = LAMP_DIM;
+ if (game.prop[BATTERY] == DEAD_BATTERIES)
+ spk = MISSING_BATTERIES;
+ rspeak(spk);
+ }
+ }
+}