- K=MOD(labs(TRAVEL[KK]),1000);
- KK=KEY[game.loc];
- goto L9;
-
-/* Cave closing and scoring */
-
-
-/* These sections 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. */
-
-/* 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. */
-
-L10000: game.prop[GRATE]=0;
- game.prop[FISSUR]=0;
- for (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)DSTROY(BEAR);
- game.prop[CHAIN]=0;
- game.fixed[CHAIN]=0;
- game.prop[AXE]=0;
- game.fixed[AXE]=0;
- RSPEAK(129);
- game.clock1= -1;
- game.closng=true;
- goto L19999;
-
-/* 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. */
-
-L11000: game.prop[BOTTLE]=PUT(BOTTLE,115,1);
- game.prop[PLANT]=PUT(PLANT,115,0);
- game.prop[OYSTER]=PUT(OYSTER,115,0);
- OBJTXT[OYSTER]=3;
- game.prop[LAMP]=PUT(LAMP,115,0);
- game.prop[ROD]=PUT(ROD,115,0);
- game.prop[DWARF]=PUT(DWARF,115,0);
- game.loc=115;
- game.oldloc=115;
- game.newloc=115;
-
-/* Leave the grate with normal (non-negative) property. Reuse sign. */
-
- PUT(GRATE,116,0);
- PUT(SIGN,116,0);
- OBJTXT[SIGN]=OBJTXT[SIGN]+1;
- game.prop[SNAKE]=PUT(SNAKE,116,1);
- game.prop[BIRD]=PUT(BIRD,116,1);
- game.prop[CAGE]=PUT(CAGE,116,0);
- game.prop[ROD2]=PUT(ROD2,116,0);
- game.prop[PILLOW]=PUT(PILLOW,116,0);
-
- game.prop[MIRROR]=PUT(MIRROR,115,0);
- game.fixed[MIRROR]=116;
-
- for (int i=1; i<=NOBJECTS; i++) {
- if(TOTING(i))
- DSTROY(i);
- } /* end loop */
-
- RSPEAK(132);
- game.closed=true;
- return true;
-
-/* 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. We go to 12000 if the lamp
- * and fresh batteries are here, in which case we replace the batteries and
- * continue. 12200 is for other cases of lamp dying. 12400 is when it goes
- * out. Even then, he can explore outside for a while if desired. */
-
-L12000: RSPEAK(188);
- game.prop[BATTER]=1;
- if(TOTING(BATTER))DROP(BATTER,game.loc);
- game.limit=game.limit+2500;
- game.lmwarn=false;
- goto L19999;
-
-L12200: if(game.lmwarn || !HERE(LAMP)) goto L19999;
- game.lmwarn=true;
- SPK=187;
- if(game.place[BATTER] == 0)SPK=183;
- if(game.prop[BATTER] == 1)SPK=189;
- RSPEAK(SPK);
- goto L19999;
-
-L12400: game.limit= -1;
- game.prop[LAMP]=0;
- if(HERE(LAMP))RSPEAK(184);
- goto L19999;
-
-/* Oh dear, he's disturbed the dwarves. */
-
-L18999: RSPEAK(SPK);
-L19000: RSPEAK(136);
- score(0);
- return true;
+ /* (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. */
+ do {
+ for (;;) { /* L12 loop */
+ for (;;) {
+ enum condtype_t condtype = travel[travel_entry].condtype;
+ int condarg1 = travel[travel_entry].condarg1;
+ int condarg2 = travel[travel_entry].condarg2;
+ if (condtype < cond_not) {
+ /* YAML N and [pct N] conditionals */
+ if (condtype == cond_goto || condtype == cond_pct) {
+ if (condarg1 == 0 ||
+ PCT(condarg1))
+ break;
+ /* else fall through */
+ }
+ /* YAML [with OBJ] clause */
+ else if (TOTING(condarg1) ||
+ (condtype == cond_with && AT(condarg1)))
+ break;
+ /* else fall through to check [not OBJ STATE] */
+ } else if (game.prop[condarg1] != condarg2)
+ break;
+
+ /* We arrive here on conditional failure.
+ * Skip to next non-matching destination */
+ 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;
+ }
+
+ /* Found an eligible rule, now execute it */
+ enum desttype_t desttype = travel[travel_entry].desttype;
+ game.newloc = travel[travel_entry].destval;
+ if (desttype == dest_goto)
+ return;
+
+ if (desttype == dest_speak) {
+ /* Execute a speak rule */
+ rspeak(game.newloc);
+ game.newloc = game.loc;
+ return;
+ } else {
+ 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]=TROLL_PAIDONCE, he's crossed
+ * since paying, so step out and block him.
+ * (standard travel entries check for
+ * game.prop[TROLL]=TROLL_UNPAID.) Special stuff
+ * for bear. */
+ if (game.prop[TROLL] == TROLL_PAIDONCE) {
+ pspeak(TROLL, look, true, TROLL_PAIDONCE);
+ game.prop[TROLL] = TROLL_UNPAID;
+ DESTROY(TROLL2);
+ move(TROLL2 + NOBJECTS, IS_FREE);
+ 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: // LCOV_EXCL_LINE
+ BUG(SPECIAL_TRAVEL_500_GT_L_GT_300_EXCEEDS_GOTO_LIST); // LCOV_EXCL_LINE
+ }
+ }
+ break; /* Leave L12 loop */
+ }
+ } while
+ (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. Even after it goes
+ * out, he can explore outside for a while if desired. */
+ if (game.limit <= WARNTIME) {
+ if (HERE(BATTERY) && game.prop[BATTERY] == FRESH_BATTERIES && HERE(LAMP)) {
+ rspeak(REPLACE_BATTERIES);
+ game.prop[BATTERY] = DEAD_BATTERIES;
+#ifdef __unused__
+ /* This code from the original game seems to have been faulty.
+ * No tests ever passed the guard, and with the guard removed
+ * the game hangs when the lamp limit is reached.
+ */
+ if (TOTING(BATTERY))
+ drop(BATTERY, game.loc);
+#endif
+ game.limit += BATTERYLIFE;
+ game.lmwarn = false;
+ } else if (!game.lmwarn && HERE(LAMP)) {
+ game.lmwarn = true;
+ if (game.prop[BATTERY] == DEAD_BATTERIES)
+ rspeak(MISSING_BATTERIES);
+ else if (game.place[BATTERY] == LOC_NOWHERE)
+ rspeak(LAMP_DIM);
+ else
+ rspeak(GET_BATTERIES);
+ }
+ }
+ if (game.limit == 0) {
+ game.limit = -1;
+ game.prop[LAMP] = LAMP_DARK;
+ if (HERE(LAMP))
+ rspeak(LAMP_OUT);
+ }
+}
+
+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. */
+{
+ /* If a turn threshold has been met, apply penalties and tell
+ * the player about it. */
+ for (int i = 0; i < NTHRESHOLDS; ++i) {
+ if (game.turns == turn_thresholds[i].threshold + 1) {
+ game.trnluz += turn_thresholds[i].point_loss;
+ speak(turn_thresholds[i].message);
+ }
+ }
+
+ /* 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] = LOC_NOWHERE;
+ }
+ DESTROY(TROLL);
+ move(TROLL + NOBJECTS, IS_FREE);
+ 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 game.closed;
+ } 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, PLANT_THIRSTY);
+ game.prop[OYSTER] = put(OYSTER, LOC_NE, STATE_FOUND);
+ game.prop[LAMP] = put(LAMP, LOC_NE, LAMP_DARK);
+ game.prop[ROD] = put(ROD, LOC_NE, STATE_FOUND);
+ 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, SNAKE_CHASED);
+ game.prop[BIRD] = put(BIRD, LOC_SW, BIRD_CAGED);
+ game.prop[CAGE] = put(CAGE, LOC_SW, STATE_FOUND);
+ game.prop[ROD2] = put(ROD2, LOC_SW, STATE_FOUND);
+ game.prop[PILLOW] = put(PILLOW, LOC_SW, STATE_FOUND);
+
+ game.prop[MIRROR] = put(MIRROR, LOC_NE, STATE_FOUND);
+ game.fixed[MIRROR] = LOC_SW;
+
+ for (int i = 1; i <= NOBJECTS; i++) {
+ if (TOTING(i))
+ DESTROY(i);
+ }
+
+ rspeak(CAVE_CLOSED);
+ game.closed = true;
+ return game.closed;
+ }
+
+ lampcheck();
+ return false;
+}
+
+static void listobjects(void)
+/* Print out descriptions of objects at this location. If
+ * not closing and property value is negative, tally off
+ * another treasure. Rug is special case; once seen, its
+ * game.prop is RUG_DRAGON (dragon on it) till dragon is killed.
+ * Similarly for chain; game.prop is initially CHAINING_BEAR (locked to
+ * bear). These hacks are because game.prop=0 is needed to
+ * get full score. */
+{
+ if (!DARK(game.loc)) {
+ ++game.abbrev[game.loc];
+ for (int i = game.atloc[game.loc]; i != 0; i = game.link[i]) {
+ obj_t obj = i;
+ if (obj > NOBJECTS)
+ obj = obj - NOBJECTS;
+ if (obj == STEPS && TOTING(NUGGET))
+ continue;
+ if (game.prop[obj] < 0) {
+ if (game.closed)
+ continue;
+ game.prop[obj] = STATE_FOUND;
+ if (obj == RUG)
+ game.prop[RUG] = RUG_DRAGON;
+ if (obj == CHAIN)
+ game.prop[CHAIN] = CHAINING_BEAR;
+ --game.tally;
+ /* Note: There used to be a test here to see whether the
+ * player had blown it so badly that he could never ever see
+ * the remaining treasures, and if so the lamp was zapped to
+ * 35 turns. But the tests were too simple-minded; things
+ * like killing the bird before the snake was gone (can never
+ * see jewelry), and doing it "right" was hopeless. E.G.,
+ * could cross troll bridge several times, using up all
+ * available treasures, breaking vase, using coins to buy
+ * batteries, etc., and eventually never be able to get
+ * across again. If bottle were left on far side, could then
+ * never get eggs or trident, and the effects propagate. So
+ * the whole thing was flushed. anyone who makes such a
+ * gross blunder isn't likely to find everything else anyway
+ * (so goes the rationalisation). */
+ }
+ int kk = game.prop[obj];
+ if (obj == STEPS)
+ kk = (game.loc == game.fixed[STEPS])
+ ? STEPS_UP
+ : STEPS_DOWN;
+ pspeak(obj, look, true, kk);
+ }
+ }
+}
+
+static bool preprocess_command(command_t *command)
+/* Pre-processes a command input to see if we need to tease out a few specific cases:
+ * - "enter water" or "enter stream":
+ * weird specific case that gets the user wet, and then kicks us back to get another command
+ * - <object> <verb>:
+ * Irregular form of input, but should be allowed. We switch back to <verb> <object> form for
+ * further processing.
+ * - "grate":
+ * If in location with grate, we move to that grate. If we're in a number of other places,
+ * we move to the entrance.
+ * - "water plant", "oil plant", "water door", "oil door":
+ * Change to "pour water" or "pour oil" based on context
+ * - "cage bird":
+ * If bird is present, we change to "carry bird"
+ *
+ * Returns true if pre-processing is complete, and we're ready to move to the primary command
+ * processing, false otherwise. */
+{
+ if (command->word[0].type == MOTION && command->word[0].id == ENTER
+ && (command->word[1].id == STREAM || command->word[1].id == WATER)) {
+ if (LIQLOC(game.loc) == WATER)
+ rspeak(FEET_WET);
+ else
+ rspeak(WHERE_QUERY);
+ } else {
+ if (command->word[0].type == OBJECT) {
+ /* From OV to VO form */
+ if (command->word[1].type == ACTION) {
+ command_word_t stage = command->word[0];
+ command->word[0] = command->word[1];
+ command->word[1] = stage;
+ }
+
+ if (command->word[0].id == GRATE) {
+ command->word[0].type = MOTION;
+ if (game.loc == LOC_START ||
+ game.loc == LOC_VALLEY ||
+ game.loc == LOC_SLIT) {
+ command->word[0].id = DEPRESSION;
+ }
+ if (game.loc == LOC_COBBLE ||
+ game.loc == LOC_DEBRIS ||
+ game.loc == LOC_AWKWARD ||
+ game.loc == LOC_BIRDCHAMBER ||
+ game.loc == LOC_PITTOP) {
+ command->word[0].id = ENTRANCE;
+ }
+ }
+ if ((command->word[0].id == WATER || command->word[0].id == OIL) &&
+ (command->word[1].id == PLANT || command->word[1].id == DOOR)) {
+ if (AT(command->word[1].id)) {
+ command->word[1] = command->word[0];
+ command->word[0].id = POUR;
+ command->word[0].type = ACTION;
+ strncpy(command->word[0].raw, "pour", LINESIZE - 1);
+ }
+ }
+ if (command->word[0].id == CAGE && command->word[1].id == BIRD && HERE(CAGE) && HERE(BIRD)) {
+ command->word[0].id = CARRY;
+ command->word[0].type = ACTION;
+ }
+ }
+
+ /* If no word type is given for the first word, we assume it's a motion. */
+ if (command->word[0].type == NO_WORD_TYPE)
+ command->word[0].type = MOTION;
+
+ command->state = PREPROCESSED;
+ return true;
+ }
+ return false;
+}
+
+static bool do_move(void)
+/* Actually execute the move to the new location and dwarf movement */
+{
+ /* Can't leave cave once it's closing (except by main office). */
+ if (OUTSID(game.newloc) && game.newloc != 0 && game.closng) {
+ rspeak(EXIT_CLOSED);
+ game.newloc = game.loc;
+ if (!game.panic)
+ game.clock2 = PANICTIME;
+ game.panic = true;
+ }
+
+ /* See if a dwarf has seen him and has come from where he
+ * wants to go. If so, the dwarf's blocking his way. If
+ * coming from place forbidden to pirate (dwarves rooted in
+ * place) let him get out (and attacked). */
+ if (game.newloc != game.loc && !FORCED(game.loc) && !CNDBIT(game.loc, COND_NOARRR)) {
+ for (size_t i = 1; i <= NDWARVES - 1; i++) {
+ if (game.odloc[i] == game.newloc && game.dseen[i]) {
+ game.newloc = game.loc;
+ rspeak(DWARF_BLOCK);
+ break;
+ }
+ }
+ }
+ game.loc = game.newloc;
+
+ if (!dwarfmove())
+ croak();
+
+ if (game.loc == LOC_NOWHERE)
+ croak();
+
+ /* The easiest way to get killed is to fall into a pit in
+ * pitch darkness. */
+ if (!FORCED(game.loc) && DARK(game.loc) && game.wzdark && PCT(35)) { // FIXME: magic number
+ rspeak(PIT_FALL);
+ game.oldlc2 = game.loc;
+ croak();
+ return false;
+ }
+
+ return true;
+}
+
+static bool do_command(void)
+/* Get and execute a command */
+{
+ static command_t command;
+ clear_command(&command);
+
+ /* Describe the current location and (maybe) get next command. */
+ while (command.state != EXECUTED) {
+ describe_location();
+
+ if (FORCED(game.loc)) {
+ playermove(HERE);
+ return true;
+ }
+
+ listobjects();
+
+ /* Command not yet given; keep getting commands from user
+ * until valid command is both given and executed. */
+ clear_command(&command);
+ while (command.state <= GIVEN) {
+
+ if (game.closed) {
+ /* If closing time, check for any objects being toted with
+ * game.prop < 0 and stash them. This way objects won't be
+ * described until they've been picked up and put down
+ * separate from their respective piles. */
+ if (game.prop[OYSTER] < 0 && TOTING(OYSTER))
+ pspeak(OYSTER, look, true, 1);
+ for (size_t i = 1; i <= NOBJECTS; i++) {
+ if (TOTING(i) && game.prop[i] < 0)
+ game.prop[i] = STASHED(i);
+ }
+ }
+
+ /* Check to see if the room is dark. If the knife is here,
+ * and it's dark, the knife permanently disappears */
+ game.wzdark = DARK(game.loc);
+ if (game.knfloc != LOC_NOWHERE && game.knfloc != game.loc)
+ game.knfloc = LOC_NOWHERE;
+
+ /* Check some for hints, get input from user, increment
+ * turn, and pre-process commands. Keep going until
+ * pre-processing is done. */
+ while ( command.state < PREPROCESSED ) {
+ checkhints();
+
+ /* Get command input from user */
+ if (!get_command_input(&command))
+ return false;
+
+ /* Every input, check "foobar" flag. If zero, nothing's going
+ * on. If pos, make neg. If neg, he skipped a word, so make it
+ * zero.
+ */
+ game.foobar = (game.foobar > WORD_EMPTY) ? -game.foobar : WORD_EMPTY;
+
+ ++game.turns;
+ preprocess_command(&command);
+ }
+
+ /* check if game is closed, and exit if it is */
+ if (closecheck() )
+ return true;
+
+ /* loop until all words in command are processed */
+ while (command.state == PREPROCESSED ) {
+ command.state = PROCESSING;
+
+ if (command.word[0].id == WORD_NOT_FOUND) {
+ /* Gee, I don't understand. */
+ sspeak(DONT_KNOW, command.word[0].raw);
+ clear_command(&command);
+ continue;
+ }
+
+ /* Give user hints of shortcuts */
+ if (strncasecmp(command.word[0].raw, "west", sizeof("west")) == 0) {
+ if (++game.iwest == 10)
+ rspeak(W_IS_WEST);
+ }
+ if (strncasecmp(command.word[0].raw, "go", sizeof("go")) == 0 && command.word[1].id != WORD_EMPTY) {
+ if (++game.igo == 10)
+ rspeak(GO_UNNEEDED);
+ }
+
+ switch (command.word[0].type) {
+ case MOTION:
+ playermove(command.word[0].id);
+ command.state = EXECUTED;
+ continue;
+ case OBJECT:
+ command.part = unknown;
+ command.obj = command.word[0].id;
+ break;
+ case ACTION:
+ if (command.word[1].type == NUMERIC)
+ command.part = transitive;
+ else
+ command.part = intransitive;
+ command.verb = command.word[0].id;
+ break;
+ case NUMERIC:
+ if (!settings.oldstyle) {
+ sspeak(DONT_KNOW, command.word[0].raw);
+ clear_command(&command);
+ continue;
+ }
+ break;// LCOV_EXCL_LINE
+ default: // LCOV_EXCL_LINE
+ case NO_WORD_TYPE: // LCOV_EXCL_LINE
+ BUG(VOCABULARY_TYPE_N_OVER_1000_NOT_BETWEEN_0_AND_3); // LCOV_EXCL_LINE
+ }
+
+ switch (action(command)) {
+ case GO_TERMINATE:
+ command.state = EXECUTED;
+ break;
+ case GO_MOVE:
+ playermove(NUL);
+ command.state = EXECUTED;
+ break;
+ case GO_WORD2:
+#ifdef GDEBUG
+ printf("Word shift\n");
+#endif /* GDEBUG */
+ /* Get second word for analysis. */
+ command.word[0] = command.word[1];
+ command.word[1] = empty_command_word;
+ command.state = PREPROCESSED;
+ break;
+ case GO_UNKNOWN:
+ /* Random intransitive verbs come here. Clear obj just in case
+ * (see attack()). */
+ command.word[0].raw[0] = toupper(command.word[0].raw[0]);
+ sspeak(DO_WHAT, command.word[0].raw);
+ command.obj = NO_OBJECT;
+
+ /* object cleared; we need to go back to the preprocessing step */
+ command.state = GIVEN;
+ break;
+ case GO_CHECKHINT: // FIXME: re-name to be more contextual; this was previously a label
+ command.state = GIVEN;
+ break;
+ case GO_DWARFWAKE:
+ /* Oh dear, he's disturbed the dwarves. */
+ rspeak(DWARVES_AWAKEN);
+ terminate(endgame);
+ case GO_CLEAROBJ: // FIXME: re-name to be more contextual; this was previously a label
+ clear_command(&command);
+ break;
+ case GO_TOP: // FIXME: re-name to be more contextual; this was previously a label
+ break;
+ default: // LCOV_EXCL_LINE
+ BUG(ACTION_RETURNED_PHASE_CODE_BEYOND_END_OF_SWITCH); // LCOV_EXCL_LINE
+ }
+ } /* while command has not been fully processed */
+ } /* while command is not yet given */
+ } /* while command is not executed */
+
+ /* command completely executed; we return true. */
+ return true;
+}
+
+/*
+ * MAIN PROGRAM
+ *
+ * Adventure (rev 2: 20 treasures)
+ * History: Original idea & 5-treasure version (adventures) by Willie Crowther
+ * 15-treasure version (adventure) by Don Woods, April-June 1977
+ * 20-treasure version (rev 2) by Don Woods, August 1978
+ * Errata fixed: 78/12/25
+ * Revived 2017 as Open Adventure.
+ */
+
+int main(int argc, char *argv[])
+{
+ int ch;
+
+ /* Options. */
+
+#if defined ADVENT_AUTOSAVE
+ const char* opts = "dl:oa:";
+ const char* usage = "Usage: %s [-l logfilename] [-o] [-a filename] [script...]\n";
+ FILE *rfp = NULL;
+ const char* autosave_filename = NULL;
+#elif !defined ADVENT_NOSAVE
+ const char* opts = "dl:or:";
+ const char* usage = "Usage: %s [-l logfilename] [-o] [-r restorefilename] [script...]\n";
+ FILE *rfp = NULL;
+#else
+ const char* opts = "dl:o";
+ const char* usage = "Usage: %s [-l logfilename] [-o] [script...]\n";
+#endif
+ while ((ch = getopt(argc, argv, opts)) != EOF) {
+ switch (ch) {
+ case 'd': // LCOV_EXCL_LINE
+ settings.debug +=1; // LCOV_EXCL_LINE
+ break; // LCOV_EXCL_LINE
+ case 'l':
+ settings.logfp = fopen(optarg, "w");
+ if (settings.logfp == NULL)
+ fprintf(stderr,
+ "advent: can't open logfile %s for write\n",
+ optarg);
+ signal(SIGINT, sig_handler);
+ break;
+ case 'o':
+ settings.oldstyle = true;
+ settings.prompt = false;
+ break;
+#ifdef ADVENT_AUTOSAVE
+ case 'a':
+ rfp = fopen(optarg, READ_MODE);
+ autosave_filename = optarg;
+ signal(SIGHUP, sig_handler);
+ signal(SIGTERM, sig_handler);
+ break;
+#elif !defined ADVENT_NOSAVE
+ case 'r':
+ rfp = fopen(optarg, "r");
+ if (rfp == NULL)
+ fprintf(stderr,
+ "advent: can't open save file %s for read\n",
+ optarg);
+ break;
+#endif
+ default:
+ fprintf(stderr,
+ usage, argv[0]);
+ fprintf(stderr,
+ " -l create a log file of your game named as specified'\n");
+ fprintf(stderr,
+ " -o 'oldstyle' (no prompt, no command editing, displays 'Initialising...')\n");
+#if defined ADVENT_AUTOSAVE
+ fprintf(stderr,
+ " -a automatic save/restore from specified saved game file\n");
+#elif !defined ADVENT_NOSAVE
+ fprintf(stderr,
+ " -r restore from specified saved game file\n");
+#endif
+ exit(EXIT_FAILURE);
+ break;
+ }
+ }
+
+ /* copy invocation line part after switches */
+ settings.argc = argc - optind;
+ settings.argv = argv + optind;
+ settings.optind = 0;
+
+ /* Initialize game variables */
+ int seedval = initialise();
+
+#if !defined ADVENT_NOSAVE
+ if (!rfp) {
+ game.novice = yes_or_no(arbitrary_messages[WELCOME_YOU], arbitrary_messages[CAVE_NEARBY], arbitrary_messages[NO_MESSAGE]);
+ if (game.novice)
+ game.limit = NOVICELIMIT;
+ } else {
+ restore(rfp);
+#if defined ADVENT_AUTOSAVE
+ score(scoregame);
+#endif
+ }
+#if defined ADVENT_AUTOSAVE
+ if (autosave_filename != NULL) {
+ if ((autosave_fp = fopen(autosave_filename, WRITE_MODE)) == NULL) {
+ perror(autosave_filename);
+ return EXIT_FAILURE;
+ }
+ autosave();
+ }
+#endif
+#else
+ game.novice = yes_or_no(arbitrary_messages[WELCOME_YOU], arbitrary_messages[CAVE_NEARBY], arbitrary_messages[NO_MESSAGE]);
+ if (game.novice)
+ game.limit = NOVICELIMIT;
+#endif
+
+ if (settings.logfp)
+ fprintf(settings.logfp, "seed %d\n", seedval);
+
+ /* interpret commands until EOF or interrupt */
+ for (;;) {
+ // if we're supposed to move, move
+ if (!do_move())
+ continue;
+
+ // get command
+ if (!do_command())
+ break;
+ }
+ /* show score and exit */
+ terminate(quitgame);