X-Git-Url: https://jxself.org/git/?a=blobdiff_plain;f=actions.c;h=20f0b9041bcd7bae6d3af99ff715e542c90c3495;hb=eebc87f889b0fa1404684aa6e72dda5a5e53d96b;hp=f38f9e5ad271f5dc9229b4a544e68a3c6c43ed5d;hpb=8984e48e78c8e83df9c93d6e34c0d8e1cfabc2b5;p=open-adventure.git

diff --git a/actions.c b/actions.c
index f38f9e5..20f0b90 100644
--- a/actions.c
+++ b/actions.c
@@ -1,9 +1,9 @@
 /*
- * Actions for the duneon-running code.
+ * Actions for the dungeon-running code.
  *
- * Copyright (c) 1977, 2005 by Will Crowther and Don Woods
- * Copyright (c) 2017 by Eric S. Raymond
- * SPDX-License-Identifier: BSD-2-clause
+ * SPDX-FileCopyrightText: 1977, 2005 by Will Crowther and Don Woods
+ * SPDX-FileCopyrightText 2017 by Eric S. Raymond
+ * SPDX-License-Identifier: BSD-2-Clause
  */
 
 #include <stdlib.h>
@@ -34,7 +34,7 @@ static phase_codes_t attack(command_t command)
             obj = SNAKE;
             ++changes;
         }
-        if (AT(DRAGON) && game.prop[DRAGON] == DRAGON_BARS) {
+        if (AT(DRAGON) && game.objects[DRAGON].prop == DRAGON_BARS) {
             obj = DRAGON;
             ++changes;
         }
@@ -46,7 +46,7 @@ static phase_codes_t attack(command_t command)
             obj = OGRE;
             ++changes;
         }
-        if (HERE(BEAR) && game.prop[BEAR] == UNTAMED_BEAR) {
+        if (HERE(BEAR) && game.objects[BEAR].prop == UNTAMED_BEAR) {
             obj = BEAR;
             ++changes;
         }
@@ -83,13 +83,13 @@ static phase_codes_t attack(command_t command)
     }
     if (obj == VEND) {
         state_change(VEND,
-                     game.prop[VEND] == VEND_BLOCKS ? VEND_UNBLOCKS : VEND_BLOCKS);
+                     game.objects[VEND].prop == VEND_BLOCKS ? VEND_UNBLOCKS : VEND_BLOCKS);
 
         return GO_CLEAROBJ;
     }
 
     if (obj == BEAR) {
-        switch (game.prop[BEAR]) {
+        switch (game.objects[BEAR].prop) {
         case UNTAMED_BEAR:
             rspeak(BEAR_HANDS);
             break;
@@ -105,18 +105,18 @@ static phase_codes_t attack(command_t command)
         }
         return GO_CLEAROBJ;
     }
-    if (obj == DRAGON && game.prop[DRAGON] == DRAGON_BARS) {
+    if (obj == DRAGON && game.objects[DRAGON].prop == DRAGON_BARS) {
         /*  Fun stuff for dragon.  If he insists on attacking it, win!
          *  Set game.prop to dead, move dragon to central loc (still
          *  fixed), move rug there (not fixed), and move him there,
          *  too.  Then do a null motion to get new description. */
         rspeak(BARE_HANDS_QUERY);
-        if (!silent_yes()) {
+        if (!silent_yes_or_no()) {
             speak(arbitrary_messages[NASTY_DRAGON]);
             return GO_MOVE;
         }
         state_change(DRAGON, DRAGON_DEAD);
-        game.prop[RUG] = RUG_FLOOR;
+        game.objects[RUG].prop = RUG_FLOOR;
         /* Hardcoding LOC_SECRET5 as the dragon's death location is ugly.
          * The way it was computed before was worse; it depended on the
          * two dragon locations being LOC_SECRET4 and LOC_SECRET6 and
@@ -128,8 +128,8 @@ static phase_codes_t attack(command_t command)
         move(RUG, LOC_SECRET5);
         drop(BLOOD, LOC_SECRET5);
         for (obj_t i = 1; i <= NOBJECTS; i++) {
-            if (game.place[i] == objects[DRAGON].plac ||
-                game.place[i] == objects[DRAGON].fixd)
+            if (game.objects[i].place == objects[DRAGON].plac ||
+                game.objects[i].place == objects[DRAGON].fixd)
                 move(i, LOC_SECRET5);
         }
         game.loc = LOC_SECRET5;
@@ -145,10 +145,10 @@ static phase_codes_t attack(command_t command)
         DESTROY(OGRE);
         int dwarves = 0;
         for (int i = 1; i < PIRATE; i++) {
-            if (game.dloc[i] == game.loc) {
+            if (game.dwarves[i].loc == game.loc) {
                 ++dwarves;
-                game.dloc[i] = LOC_LONGWEST;
-                game.dseen[i] = false;
+                game.dwarves[i].loc = LOC_LONGWEST;
+                game.dwarves[i].seen = false;
             }
         }
         rspeak((dwarves > 1) ?
@@ -187,30 +187,39 @@ static phase_codes_t attack(command_t command)
 }
 
 static phase_codes_t bigwords(vocab_t id)
-/*  FEE FIE FOE FOO (AND FUM).  Advance to next state if given in proper order.
- *  Look up foo in special section of vocab to determine which word we've got.
- *  Last word zips the eggs back to the giant room (unless already there). */
+/* Only called on FEE FIE FOE FOO (AND FUM).  Advance to next state if given
+ * in proper order. Look up foo in special section of vocab to determine which
+ * word we've got. Last word zips the eggs back to the giant room (unless
+ * already there). */
 {
-    if ((game.foobar == WORD_EMPTY && id == FEE) ||
-        (game.foobar == FEE && id == FIE) ||
-        (game.foobar == FIE && id == FOE) ||
-        (game.foobar == FOE && id == FOO) ||
-        (game.foobar == FOE && id == FUM)) {
+    int foobar = abs(game.foobar);
+
+    /* Only FEE can start a magic-word sequence. */
+    if ((foobar == WORD_EMPTY) && (id == FIE || id == FOE || id == FOO || id == FUM)) {
+	rspeak(NOTHING_HAPPENS);
+	return GO_CLEAROBJ;
+    }
+    
+    if ((foobar == WORD_EMPTY && id == FEE) ||
+        (foobar == FEE && id == FIE) ||
+        (foobar == FIE && id == FOE) ||
+        (foobar == FOE && id == FOO)) {
         game.foobar = id;
-        if ((id != FOO) && (id != FUM)) {
+        if (id != FOO) {
             rspeak(OK_MAN);
             return GO_CLEAROBJ;
         }
         game.foobar = WORD_EMPTY;
-        if (game.place[EGGS] == objects[EGGS].plac ||
+        if (game.objects[EGGS].place == objects[EGGS].plac ||
             (TOTING(EGGS) && game.loc == objects[EGGS].plac)) {
             rspeak(NOTHING_HAPPENS);
             return GO_CLEAROBJ;
         } else {
             /*  Bring back troll if we steal the eggs back from him before
              *  crossing. */
-            if (game.place[EGGS] == LOC_NOWHERE && game.place[TROLL] == LOC_NOWHERE && game.prop[TROLL] == TROLL_UNPAID)
-                game.prop[TROLL] = TROLL_PAIDONCE;
+            if (game.objects[EGGS].place == LOC_NOWHERE && game.objects[TROLL].place == LOC_NOWHERE
+		&& game.objects[TROLL].prop == TROLL_UNPAID)
+                game.objects[TROLL].prop = TROLL_PAIDONCE;
             if (HERE(EGGS))
                 pspeak(EGGS, look, true, EGGS_VANISHED);
             else if (game.loc == objects[EGGS].plac)
@@ -222,13 +231,11 @@ static phase_codes_t bigwords(vocab_t id)
             return GO_CLEAROBJ;
         }
     } else {
-        if (game.loc == LOC_GIANTROOM) {
-            rspeak(START_OVER);
-        } else {
-            /* This is new begavior in Open Adventure - sounds better when
-             * player isn't in the Giant Room. */
-            rspeak(WELL_POINTLESS);
-        }
+	/* Magic-word sequence was started but is incorrect */
+	if (settings.oldstyle || game.seenbigwords)
+	    rspeak(START_OVER);
+	else
+	    rspeak(WELL_POINTLESS);
         game.foobar = WORD_EMPTY;
         return GO_CLEAROBJ;
     }
@@ -237,8 +244,7 @@ static phase_codes_t bigwords(vocab_t id)
 static void blast(void)
 /*  Blast.  No effect unless you've got dynamite, which is a neat trick! */
 {
-    if (game.prop[ROD2] == STATE_NOTFOUND ||
-        !game.closed)
+    if (game.objects[ROD2].prop == STATE_NOTFOUND || !game.closed)
         rspeak(REQUIRES_DYNAMITE);
     else {
         if (HERE(ROD2)) {
@@ -268,11 +274,11 @@ static phase_codes_t vbreak(verb_t verb, obj_t obj)
             break;
         }
     case VASE:
-        if (game.prop[VASE] == VASE_WHOLE) {
+        if (game.objects[VASE].prop == VASE_WHOLE) {
             if (TOTING(VASE))
                 drop(VASE, game.loc);
             state_change(VASE, VASE_BROKEN);
-            game.fixed[VASE] = IS_FIXED;
+            game.objects[VASE].fixed = IS_FIXED;
             break;
         }
     /* FALLTHRU */
@@ -298,11 +304,11 @@ static phase_codes_t vcarry(verb_t verb, obj_t obj)
 {
     if (obj == INTRANSITIVE) {
         /*  Carry, no object given yet.  OK if only one object present. */
-        if (game.atloc[game.loc] == NO_OBJECT ||
-            game.link[game.atloc[game.loc]] != 0 ||
+        if (game.locs[game.loc].atloc == NO_OBJECT ||
+            game.link[game.locs[game.loc].atloc] != 0 ||
             atdwrf(game.loc) > 0)
             return GO_UNKNOWN;
-        obj = game.atloc[game.loc];
+        obj = game.locs[game.loc].atloc;
     }
 
     if (TOTING(obj)) {
@@ -316,20 +322,20 @@ static phase_codes_t vcarry(verb_t verb, obj_t obj)
         return GO_CLEAROBJ;
     }
 
-    if (game.fixed[obj] != IS_FREE) {
+    if (game.objects[obj].fixed != IS_FREE) {
         switch (obj) {
         case PLANT:
             /* Next guard tests whether plant is tiny or stashed */
-            rspeak(game.prop[PLANT] <= PLANT_THIRSTY ? DEEP_ROOTS : YOU_JOKING);
+            rspeak(game.objects[PLANT].prop <= PLANT_THIRSTY ? DEEP_ROOTS : YOU_JOKING);
             break;
         case BEAR:
-            rspeak( game.prop[BEAR] == SITTING_BEAR ? BEAR_CHAINED : YOU_JOKING);
+            rspeak( game.objects[BEAR].prop == SITTING_BEAR ? BEAR_CHAINED : YOU_JOKING);
             break;
         case CHAIN:
-            rspeak( game.prop[BEAR] != UNTAMED_BEAR ? STILL_LOCKED : YOU_JOKING);
+            rspeak( game.objects[BEAR].prop != UNTAMED_BEAR ? STILL_LOCKED : YOU_JOKING);
             break;
         case RUG:
-            rspeak(game.prop[RUG] == RUG_HOVER ? RUG_HOVERS : YOU_JOKING);
+            rspeak(game.objects[RUG].prop == RUG_HOVER ? RUG_HOVERS : YOU_JOKING);
             break;
         case URN:
             rspeak(URN_NOBUDGE);
@@ -349,15 +355,13 @@ static phase_codes_t vcarry(verb_t verb, obj_t obj)
         return GO_CLEAROBJ;
     }
 
-    if (obj == WATER ||
-        obj == OIL) {
-        if (!HERE(BOTTLE) ||
-            LIQUID() != obj) {
+    if (obj == WATER || obj == OIL) {
+        if (!HERE(BOTTLE) || LIQUID() != obj) {
             if (!TOTING(BOTTLE)) {
                 rspeak(NO_CONTAINER);
                 return GO_CLEAROBJ;
             }
-            if (game.prop[BOTTLE] == EMPTY_BOTTLE) {
+            if (game.objects[BOTTLE].prop == EMPTY_BOTTLE) {
                 return (fill(verb, BOTTLE));
             } else
                 rspeak(BOTTLE_FULL);
@@ -372,8 +376,8 @@ static phase_codes_t vcarry(verb_t verb, obj_t obj)
 
     }
 
-    if (obj == BIRD && game.prop[BIRD] != BIRD_CAGED && STASHED(BIRD) != BIRD_CAGED) {
-        if (game.prop[BIRD] == BIRD_FOREST_UNCAGED) {
+    if (obj == BIRD && game.objects[BIRD].prop != BIRD_CAGED && STASHED(BIRD) != BIRD_CAGED) {
+        if (game.objects[BIRD].prop == BIRD_FOREST_UNCAGED) {
             DESTROY(BIRD);
             rspeak(BIRD_CRAP);
             return GO_CLEAROBJ;
@@ -386,11 +390,10 @@ static phase_codes_t vcarry(verb_t verb, obj_t obj)
             rspeak(BIRD_EVADES);
             return GO_CLEAROBJ;
         }
-        game.prop[BIRD] = BIRD_CAGED;
+        game.objects[BIRD].prop = BIRD_CAGED;
     }
-    if ((obj == BIRD ||
-         obj == CAGE) &&
-        (game.prop[BIRD] == BIRD_CAGED || STASHED(BIRD) == BIRD_CAGED)) {
+    if ((obj == BIRD || obj == CAGE) &&
+        (game.objects[BIRD].prop == BIRD_CAGED || STASHED(BIRD) == BIRD_CAGED)) {
         /* expression maps BIRD to CAGE and CAGE to BIRD */
         carry(BIRD + CAGE - obj, game.loc);
     }
@@ -398,11 +401,11 @@ static phase_codes_t vcarry(verb_t verb, obj_t obj)
     carry(obj, game.loc);
 
     if (obj == BOTTLE && LIQUID() != NO_OBJECT)
-        game.place[LIQUID()] = CARRIED;
+        game.objects[LIQUID()].place = CARRIED;
 
-    if (GSTONE(obj) && game.prop[obj] != STATE_FOUND) {
-        game.prop[obj] = STATE_FOUND;
-        game.prop[CAVITY] = CAVITY_EMPTY;
+    if (GSTONE(obj) && game.objects[obj].prop != STATE_FOUND) {
+        game.objects[obj].prop = STATE_FOUND;
+        game.objects[CAVITY].prop = CAVITY_EMPTY;
     }
     rspeak(OK_MAN);
     return GO_CLEAROBJ;
@@ -412,36 +415,36 @@ static int chain(verb_t verb)
 /* Do something to the bear's chain */
 {
     if (verb != LOCK) {
-        if (game.prop[BEAR] == UNTAMED_BEAR) {
+        if (game.objects[BEAR].prop == UNTAMED_BEAR) {
             rspeak(BEAR_BLOCKS);
             return GO_CLEAROBJ;
         }
-        if (game.prop[CHAIN] == CHAIN_HEAP) {
+        if (game.objects[CHAIN].prop == CHAIN_HEAP) {
             rspeak(ALREADY_UNLOCKED);
             return GO_CLEAROBJ;
         }
-        game.prop[CHAIN] = CHAIN_HEAP;
-        game.fixed[CHAIN] = IS_FREE;
-        if (game.prop[BEAR] != BEAR_DEAD)
-            game.prop[BEAR] = CONTENTED_BEAR;
+        game.objects[CHAIN].prop = CHAIN_HEAP;
+        game.objects[CHAIN].fixed = IS_FREE;
+        if (game.objects[BEAR].prop != BEAR_DEAD)
+            game.objects[BEAR].prop = CONTENTED_BEAR;
 
-        switch (game.prop[BEAR]) {
+        switch (game.objects[BEAR].prop) {
         // LCOV_EXCL_START
         case BEAR_DEAD:
             /* Can't be reached until the bear can die in some way other
              * than a bridge collapse. Leave in in case this changes, but
              * exclude from coverage testing. */
-            game.fixed[BEAR] = IS_FIXED;
+            game.objects[BEAR].fixed = IS_FIXED;
             break;
         // LCOV_EXCL_STOP
         default:
-            game.fixed[BEAR] = IS_FREE;
+            game.objects[BEAR].fixed = IS_FREE;
         }
         rspeak(CHAIN_UNLOCKED);
         return GO_CLEAROBJ;
     }
 
-    if (game.prop[CHAIN] != CHAIN_HEAP) {
+    if (game.objects[CHAIN].prop != CHAIN_HEAP) {
         rspeak(ALREADY_LOCKED);
         return GO_CLEAROBJ;
     }
@@ -450,11 +453,11 @@ static int chain(verb_t verb)
         return GO_CLEAROBJ;
     }
 
-    game.prop[CHAIN] = CHAIN_FIXED;
+    game.objects[CHAIN].prop = CHAIN_FIXED;
 
     if (TOTING(CHAIN))
         drop(CHAIN, game.loc);
-    game.fixed[CHAIN] = IS_FIXED;
+    game.objects[CHAIN].fixed = IS_FIXED;
 
     rspeak(CHAIN_LOCKED);
     return GO_CLEAROBJ;
@@ -474,12 +477,12 @@ static phase_codes_t discard(verb_t verb, obj_t obj)
         return GO_CLEAROBJ;
     }
 
-    if (GSTONE(obj) && AT(CAVITY) && game.prop[CAVITY] != CAVITY_FULL) {
+    if (GSTONE(obj) && AT(CAVITY) && game.objects[CAVITY].prop != CAVITY_FULL) {
         rspeak(GEM_FITS);
-        game.prop[obj] = STATE_IN_CAVITY;
-        game.prop[CAVITY] = CAVITY_FULL;
-        if (HERE(RUG) && ((obj == EMERALD && game.prop[RUG] != RUG_HOVER) ||
-                          (obj == RUBY && game.prop[RUG] == RUG_HOVER))) {
+        game.objects[obj].prop = STATE_IN_CAVITY;
+        game.objects[CAVITY].prop = CAVITY_FULL;
+        if (HERE(RUG) && ((obj == EMERALD && game.objects[RUG].prop != RUG_HOVER) ||
+                          (obj == RUBY && game.objects[RUG].prop == RUG_HOVER))) {
             if (obj == RUBY)
                 rspeak(RUG_SETTLES);
             else if (TOTING(RUG))
@@ -487,8 +490,8 @@ static phase_codes_t discard(verb_t verb, obj_t obj)
             else
                 rspeak(RUG_RISES);
             if (!TOTING(RUG) || obj == RUBY) {
-                int k = (game.prop[RUG] == RUG_HOVER) ? RUG_FLOOR : RUG_HOVER;
-                game.prop[RUG] = k;
+                int k = (game.objects[RUG].prop == RUG_HOVER) ? RUG_FLOOR : RUG_HOVER;
+                game.objects[RUG].prop = k;
                 if (k == RUG_HOVER)
                     k = objects[SAPPH].plac;
                 move(RUG + NOBJECTS, k);
@@ -508,7 +511,7 @@ static phase_codes_t discard(verb_t verb, obj_t obj)
     if (LIQUID() == obj)
         obj = BOTTLE;
     if (obj == BOTTLE && LIQUID() != NO_OBJECT) {
-        game.place[LIQUID()] = LOC_NOWHERE;
+        game.objects[LIQUID()].place = LOC_NOWHERE;
     }
 
     if (obj == BEAR && AT(TROLL)) {
@@ -527,19 +530,19 @@ static phase_codes_t discard(verb_t verb, obj_t obj)
             state_change(VASE, AT(PILLOW)
                          ? VASE_WHOLE
                          : VASE_DROPPED);
-            if (game.prop[VASE] != VASE_WHOLE)
-                game.fixed[VASE] = IS_FIXED;
+            if (game.objects[VASE].prop != VASE_WHOLE)
+                game.objects[VASE].fixed = IS_FIXED;
             drop(obj, game.loc);
             return GO_CLEAROBJ;
         }
     }
 
-    if (obj == CAGE && game.prop[BIRD] == BIRD_CAGED) {
+    if (obj == CAGE && game.objects[BIRD].prop == BIRD_CAGED) {
         drop(BIRD, game.loc);
     }
 
     if (obj == BIRD) {
-        if (AT(DRAGON) && game.prop[DRAGON] == DRAGON_BARS) {
+        if (AT(DRAGON) && game.objects[DRAGON].prop == DRAGON_BARS) {
             rspeak(BIRD_BURNT);
             DESTROY(BIRD);
             return GO_CLEAROBJ;
@@ -550,11 +553,11 @@ static phase_codes_t discard(verb_t verb, obj_t obj)
                 return GO_DWARFWAKE;
             DESTROY(SNAKE);
             /* Set game.prop for use by travel options */
-            game.prop[SNAKE] = SNAKE_CHASED;
+            game.objects[SNAKE].prop = SNAKE_CHASED;
         } else
             rspeak(OK_MAN);
 
-        game.prop[BIRD] = FOREST(game.loc) ? BIRD_FOREST_UNCAGED : BIRD_UNCAGED;
+        game.objects[BIRD].prop = FOREST(game.loc) ? BIRD_FOREST_UNCAGED : BIRD_UNCAGED;
         drop(obj, game.loc);
         return GO_CLEAROBJ;
     }
@@ -585,7 +588,7 @@ static phase_codes_t drink(verb_t verb, obj_t obj)
         return GO_CLEAROBJ;
     }
     if (LIQUID() == WATER && HERE(BOTTLE)) {
-        game.place[WATER] = LOC_NOWHERE;
+        game.objects[WATER].place = LOC_NOWHERE;
         state_change(BOTTLE, EMPTY_BOTTLE);
         return GO_CLEAROBJ;
     }
@@ -628,9 +631,9 @@ static phase_codes_t extinguish(verb_t verb, obj_t obj)
 /* Extinguish.  Lamp, urn, dragon/volcano (nice try). */
 {
     if (obj == INTRANSITIVE) {
-        if (HERE(LAMP) && game.prop[LAMP] == LAMP_BRIGHT)
+        if (HERE(LAMP) && game.objects[LAMP].prop == LAMP_BRIGHT)
             obj = LAMP;
-        if (HERE(URN) && game.prop[URN] == URN_LIT)
+        if (HERE(URN) && game.objects[URN].prop == URN_LIT)
             obj = URN;
         if (obj == INTRANSITIVE)
             return GO_UNKNOWN;
@@ -638,7 +641,7 @@ static phase_codes_t extinguish(verb_t verb, obj_t obj)
 
     switch (obj) {
     case URN:
-        if (game.prop[URN] != URN_EMPTY) {
+        if (game.objects[URN].prop != URN_EMPTY) {
             state_change(URN, URN_DARK);
         } else {
             pspeak(URN, change, true, URN_DARK);
@@ -669,7 +672,7 @@ static phase_codes_t feed(verb_t verb, obj_t obj)
         rspeak(BIRD_PINING);
         break;
     case DRAGON:
-        if (game.prop[DRAGON] != DRAGON_BARS)
+        if (game.objects[DRAGON].prop != DRAGON_BARS)
             rspeak(RIDICULOUS_ATTEMPT);
         else
             rspeak(NOTHING_EDIBLE);
@@ -692,15 +695,15 @@ static phase_codes_t feed(verb_t verb, obj_t obj)
             speak(actions[verb].message);
         break;
     case BEAR:
-        if (game.prop[BEAR] == BEAR_DEAD) {
+        if (game.objects[BEAR].prop == BEAR_DEAD) {
             rspeak(RIDICULOUS_ATTEMPT);
             break;
         }
-        if (game.prop[BEAR] == UNTAMED_BEAR) {
+        if (game.objects[BEAR].prop == UNTAMED_BEAR) {
             if (HERE(FOOD)) {
                 DESTROY(FOOD);
-                game.fixed[AXE] = IS_FREE;
-                game.prop[AXE] = AXE_HERE;
+                game.objects[AXE].fixed = IS_FREE;
+                game.objects[AXE].prop = AXE_HERE;
                 state_change(BEAR, SITTING_BEAR);
             } else
                 rspeak(NOTHING_EDIBLE);
@@ -734,14 +737,14 @@ phase_codes_t fill(verb_t verb, obj_t obj)
             return GO_CLEAROBJ;
         }
         rspeak(SHATTER_VASE);
-        game.prop[VASE] = VASE_BROKEN;
-        game.fixed[VASE] = IS_FIXED;
+        game.objects[VASE].prop = VASE_BROKEN;
+        game.objects[VASE].fixed = IS_FIXED;
         drop(VASE, game.loc);
         return GO_CLEAROBJ;
     }
 
     if (obj == URN) {
-        if (game.prop[URN] != URN_EMPTY) {
+        if (game.objects[URN].prop != URN_EMPTY) {
             rspeak(FULL_URN);
             return GO_CLEAROBJ;
         }
@@ -752,12 +755,12 @@ phase_codes_t fill(verb_t verb, obj_t obj)
         int k = LIQUID();
         switch (k) {
         case WATER:
-            game.prop[BOTTLE] = EMPTY_BOTTLE;
+            game.objects[BOTTLE].prop = EMPTY_BOTTLE;
             rspeak(WATER_URN);
             break;
         case OIL:
-            game.prop[URN] = URN_DARK;
-            game.prop[BOTTLE] = EMPTY_BOTTLE;
+            game.objects[URN].prop = URN_DARK;
+            game.objects[BOTTLE].prop = EMPTY_BOTTLE;
             rspeak(OIL_URN);
             break;
         case NO_OBJECT:
@@ -765,7 +768,7 @@ phase_codes_t fill(verb_t verb, obj_t obj)
             rspeak(FILL_INVALID);
             return GO_CLEAROBJ;
         }
-        game.place[k] = LOC_NOWHERE;
+        game.objects[k].place = LOC_NOWHERE;
         return GO_CLEAROBJ;
     }
     if (obj != INTRANSITIVE && obj != BOTTLE) {
@@ -775,7 +778,7 @@ phase_codes_t fill(verb_t verb, obj_t obj)
     if (obj == INTRANSITIVE && !HERE(BOTTLE))
         return GO_UNKNOWN;
 
-    if (HERE(URN) && game.prop[URN] != URN_EMPTY) {
+    if (HERE(URN) && game.objects[URN].prop != URN_EMPTY) {
         rspeak(URN_NOPOUR);
         return GO_CLEAROBJ;
     }
@@ -792,7 +795,7 @@ phase_codes_t fill(verb_t verb, obj_t obj)
                  ? OIL_BOTTLE
                  : WATER_BOTTLE);
     if (TOTING(BOTTLE))
-        game.place[LIQUID()] = CARRIED;
+        game.objects[LIQUID()].place = CARRIED;
     return GO_CLEAROBJ;
 }
 
@@ -809,10 +812,8 @@ static phase_codes_t find(verb_t verb, obj_t obj)
         return GO_CLEAROBJ;
     }
 
-    if (AT(obj) ||
-        (LIQUID() == obj && AT(BOTTLE)) ||
-        obj == LIQLOC(game.loc) ||
-        (obj == DWARF && atdwrf(game.loc) > 0)) {
+    if (AT(obj) || (LIQUID() == obj && AT(BOTTLE)) ||
+        obj == LIQLOC(game.loc) || (obj == DWARF && atdwrf(game.loc) > 0)) {
         rspeak(YOU_HAVEIT);
         return GO_CLEAROBJ;
     }
@@ -830,7 +831,7 @@ static phase_codes_t fly(verb_t verb, obj_t obj)
             rspeak(FLAP_ARMS);
             return GO_CLEAROBJ;
         }
-        if (game.prop[RUG] != RUG_HOVER) {
+        if (game.objects[RUG].prop != RUG_HOVER) {
             rspeak(RUG_NOTHING2);
             return GO_CLEAROBJ;
         }
@@ -841,19 +842,26 @@ static phase_codes_t fly(verb_t verb, obj_t obj)
         speak(actions[verb].message);
         return GO_CLEAROBJ;
     }
-    if (game.prop[RUG] != RUG_HOVER) {
+    if (game.objects[RUG].prop != RUG_HOVER) {
         rspeak(RUG_NOTHING1);
         return GO_CLEAROBJ;
     }
-    game.oldlc2 = game.oldloc;
-    game.oldloc = game.loc;
 
-    if (game.prop[SAPPH] == STATE_NOTFOUND) {
-        game.newloc = game.place[SAPPH];
+    if (game.loc == LOC_CLIFF) {
+        game.oldlc2 = game.oldloc;
+        game.oldloc = game.loc;
+        game.newloc = LOC_LEDGE;
         rspeak(RUG_GOES);
-    } else {
+    } else if (game.loc == LOC_LEDGE) {
+        game.oldlc2 = game.oldloc;
+        game.oldloc = game.loc;
         game.newloc = LOC_CLIFF;
         rspeak(RUG_RETURNS);
+    } else {
+// LCOV_EXCL_START
+        /* should never happen */
+        rspeak(NOTHING_HAPPENS);
+// LCOV_EXCL_STOP
     }
     return GO_TERMINATE;
 }
@@ -863,8 +871,7 @@ static phase_codes_t inven(void)
 {
     bool empty = true;
     for (obj_t i = 1; i <= NOBJECTS; i++) {
-        if (i == BEAR ||
-            !TOTING(i))
+        if (i == BEAR || !TOTING(i))
             continue;
         if (empty) {
             rspeak(NOW_HOLDING);
@@ -884,11 +891,11 @@ static phase_codes_t light(verb_t verb, obj_t obj)
 {
     if (obj == INTRANSITIVE) {
         int selects = 0;
-        if (HERE(LAMP) && game.prop[LAMP] == LAMP_DARK && game.limit >= 0) {
+        if (HERE(LAMP) && game.objects[LAMP].prop == LAMP_DARK && game.limit >= 0) {
             obj = LAMP;
             selects++;
         }
-        if (HERE(URN) && game.prop[URN] == URN_DARK) {
+        if (HERE(URN) && game.objects[URN].prop == URN_DARK) {
             obj =  URN;
             selects++;
         }
@@ -898,7 +905,7 @@ static phase_codes_t light(verb_t verb, obj_t obj)
 
     switch (obj) {
     case URN:
-        state_change(URN, game.prop[URN] == URN_EMPTY ?
+        state_change(URN, game.objects[URN].prop == URN_EMPTY ?
                      URN_EMPTY :
                      URN_LIT);
         break;
@@ -918,21 +925,20 @@ static phase_codes_t light(verb_t verb, obj_t obj)
 }
 
 static phase_codes_t listen(void)
-/*  Listen.  Intransitive only.  Print stuff based on object sound proprties. */
+/*  Listen.  Intransitive only.  Print stuff based on object sound properties. */
 {
+    bool soundlatch = false;
     vocab_t sound = locations[game.loc].sound;
     if (sound != SILENT) {
         rspeak(sound);
         if (!locations[game.loc].loud)
             rspeak(NO_MESSAGE);
-        return GO_CLEAROBJ;
+        soundlatch = true;
     }
     for (obj_t i = 1; i <= NOBJECTS; i++) {
-        if (!HERE(i) ||
-            objects[i].sounds[0] == NULL ||
-            game.prop[i] < 0)
+        if (!HERE(i) || objects[i].sounds[0] == NULL || game.objects[i].prop < 0)
             continue;
-        int mi =  game.prop[i];
+        int mi =  game.objects[i].prop;
         /* (ESR) Some unpleasant magic on object states here. Ideally
          * we'd have liked the bird to be a normal object that we can
          * use state_change() on; can't do it, because there are
@@ -944,9 +950,10 @@ static phase_codes_t listen(void)
         rspeak(NO_MESSAGE);
         if (i == BIRD && mi == BIRD_ENDSTATE)
             DESTROY(BIRD);
-        return GO_CLEAROBJ;
+        soundlatch = true;
     }
-    rspeak(ALL_SILENT);
+    if (!soundlatch)
+        rspeak(ALL_SILENT);
     return GO_CLEAROBJ;
 }
 
@@ -999,7 +1006,7 @@ static phase_codes_t lock(verb_t verb, obj_t obj)
         if (verb == LOCK)
             rspeak(HUH_MAN);
         else if (TOTING(CLAM))
-	    rspeak(DROP_CLAM);
+            rspeak(DROP_CLAM);
         else if (!TOTING(TRIDENT))
             rspeak(CLAM_OPENER);
         else {
@@ -1020,7 +1027,7 @@ static phase_codes_t lock(verb_t verb, obj_t obj)
             rspeak(OYSTER_OPENS);
         break;
     case DOOR:
-        rspeak((game.prop[DOOR] == DOOR_UNRUSTED) ? OK_MAN : RUSTY_DOOR);
+        rspeak((game.objects[DOOR].prop == DOOR_UNRUSTED) ? OK_MAN : RUSTY_DOOR);
         break;
     case CAGE:
         rspeak( NO_LOCK);
@@ -1039,9 +1046,8 @@ static phase_codes_t pour(verb_t verb, obj_t obj)
 /*  Pour.  If no object, or object is bottle, assume contents of bottle.
  *  special tests for pouring water or oil on plant or rusty door. */
 {
-    if (obj == BOTTLE ||
-        obj == INTRANSITIVE)
-        obj = LIQUID();
+    if (obj == BOTTLE || obj == INTRANSITIVE)
+	obj = LIQUID();
     if (obj == NO_OBJECT)
         return GO_UNKNOWN;
     if (!TOTING(obj)) {
@@ -1053,20 +1059,19 @@ static phase_codes_t pour(verb_t verb, obj_t obj)
         rspeak(CANT_POUR);
         return GO_CLEAROBJ;
     }
-    if (HERE(URN) && game.prop[URN] == URN_EMPTY)
+    if (HERE(URN) && game.objects[URN].prop == URN_EMPTY)
         return fill(verb, URN);
-    game.prop[BOTTLE] = EMPTY_BOTTLE;
-    game.place[obj] = LOC_NOWHERE;
-    if (!(AT(PLANT) ||
-          AT(DOOR))) {
+    game.objects[BOTTLE].prop = EMPTY_BOTTLE;
+    game.objects[obj].place = LOC_NOWHERE;
+    if (!(AT(PLANT) || AT(DOOR))) {
         rspeak(GROUND_WET);
         return GO_CLEAROBJ;
     }
     if (!AT(DOOR)) {
         if (obj == WATER) {
             /* cycle through the three plant states */
-            state_change(PLANT, MOD(game.prop[PLANT] + 1, 3));
-            game.prop[PLANT2] = game.prop[PLANT];
+            state_change(PLANT, MOD(game.objects[PLANT].prop + 1, 3));
+            game.objects[PLANT2].prop = game.objects[PLANT].prop;
             return GO_MOVE;
         } else {
             rspeak(SHAKING_LEAVES);
@@ -1083,7 +1088,7 @@ static phase_codes_t pour(verb_t verb, obj_t obj)
 static phase_codes_t quit(void)
 /*  Quit.  Intransitive only.  Verify intent and exit if that's what he wants. */
 {
-    if (yes(arbitrary_messages[REALLY_QUIT], arbitrary_messages[OK_MAN], arbitrary_messages[OK_MAN]))
+    if (yes_or_no(arbitrary_messages[REALLY_QUIT], arbitrary_messages[OK_MAN], arbitrary_messages[OK_MAN]))
         terminate(quitgame);
     return GO_CLEAROBJ;
 }
@@ -1094,24 +1099,28 @@ static phase_codes_t read(command_t command)
     if (command.obj == INTRANSITIVE) {
         command.obj = NO_OBJECT;
         for (int i = 1; i <= NOBJECTS; i++) {
-            if (HERE(i) && objects[i].texts[0] != NULL && game.prop[i] >= 0)
+            if (HERE(i) && objects[i].texts[0] != NULL && game.objects[i].prop >= 0)
                 command.obj = command.obj * NOBJECTS + i;
         }
-        if (command.obj > NOBJECTS ||
-            command.obj == NO_OBJECT ||
-            DARK(game.loc))
+        if (command.obj > NOBJECTS || command.obj == NO_OBJECT || DARK(game.loc))
             return GO_UNKNOWN;
     }
 
     if (DARK(game.loc)) {
         sspeak(NO_SEE, command.word[0].raw);
-    } else if (command.obj == OYSTER && !game.clshnt && game.closed) {
-        game.clshnt = yes(arbitrary_messages[CLUE_QUERY], arbitrary_messages[WAYOUT_CLUE], arbitrary_messages[OK_MAN]);
+    } else if (command.obj == OYSTER) {
+        if (!TOTING(OYSTER) || !game.closed) {
+            rspeak(DONT_UNDERSTAND);
+        } else if (!game.clshnt) {
+            game.clshnt = yes_or_no(arbitrary_messages[CLUE_QUERY], arbitrary_messages[WAYOUT_CLUE], arbitrary_messages[OK_MAN]);
+        } else {
+            pspeak(OYSTER, hear, true, 1);	// Not really a sound, but oh well.
+        }
     } else if (objects[command.obj].texts[0] == NULL ||
-               game.prop[command.obj] == STATE_NOTFOUND) {
+               game.objects[command.obj].prop == STATE_NOTFOUND) {
         speak(actions[command.verb].message);
     } else
-        pspeak(command.obj, study, true, game.prop[command.obj]);
+        pspeak(command.obj, study, true, game.objects[command.obj].prop);
     return GO_CLEAROBJ;
 }
 
@@ -1123,7 +1132,7 @@ static phase_codes_t reservoir(void)
         return GO_CLEAROBJ;
     } else {
         state_change(RESER,
-                     game.prop[RESER] == WATERS_PARTED ? WATERS_UNPARTED : WATERS_PARTED);
+                     game.objects[RESER].prop == WATERS_PARTED ? WATERS_UNPARTED : WATERS_PARTED);
         if (AT(RESER))
             return GO_CLEAROBJ;
         else {
@@ -1138,10 +1147,10 @@ static phase_codes_t reservoir(void)
 static phase_codes_t rub(verb_t verb, obj_t obj)
 /* Rub.  Yields various snide remarks except for lit urn. */
 {
-    if (obj == URN && game.prop[URN] == URN_LIT) {
+    if (obj == URN && game.objects[URN].prop == URN_LIT) {
         DESTROY(URN);
         drop(AMBER, game.loc);
-        game.prop[AMBER] = AMBER_IN_ROCK;
+        game.objects[AMBER].prop = AMBER_IN_ROCK;
         --game.tally;
         drop(CAVITY, game.loc);
         rspeak(URN_GENIES);
@@ -1185,7 +1194,7 @@ static phase_codes_t throw_support(vocab_t spk)
     return GO_MOVE;
 }
 
-static phase_codes_t throw (command_t command)
+static phase_codes_t throwit(command_t command)
 /*  Throw.  Same as discard unless axe.  Then same as attack except
  *  ignore bird, and if dwarf is present then one might be killed.
  *  (Only way to do so!)  Axe also special for dragon, bear, and
@@ -1215,16 +1224,16 @@ static phase_codes_t throw (command_t command)
         return (discard(command.verb, command.obj));
     else {
         if (atdwrf(game.loc) <= 0) {
-            if (AT(DRAGON) && game.prop[DRAGON] == DRAGON_BARS)
+            if (AT(DRAGON) && game.objects[DRAGON].prop == DRAGON_BARS)
                 return throw_support(DRAGON_SCALES);
             if (AT(TROLL))
                 return throw_support(TROLL_RETURNS);
             if (AT(OGRE))
                 return throw_support(OGRE_DODGE);
-            if (HERE(BEAR) && game.prop[BEAR] == UNTAMED_BEAR) {
+            if (HERE(BEAR) && game.objects[BEAR].prop == UNTAMED_BEAR) {
                 /* This'll teach him to throw the axe at the bear! */
                 drop(AXE, game.loc);
-                game.fixed[AXE] = IS_FIXED;
+                game.objects[AXE].fixed = IS_FIXED;
                 juggle(BEAR);
                 state_change(AXE, AXE_LOST);
                 return GO_CLEAROBJ;
@@ -1237,8 +1246,8 @@ static phase_codes_t throw (command_t command)
             return throw_support(DWARF_DODGES);
         } else {
             int i = atdwrf(game.loc);
-            game.dseen[i] = false;
-            game.dloc[i] = LOC_NOWHERE;
+            game.dwarves[i].seen = false;
+            game.dwarves[i].loc = LOC_NOWHERE;
             return throw_support((++game.dkill == 1) ?
                                  DWARF_SMOKE :
                                  KILLED_DWARF);
@@ -1249,8 +1258,7 @@ static phase_codes_t throw (command_t command)
 static phase_codes_t wake(verb_t verb, obj_t obj)
 /* Wake.  Only use is to disturb the dwarves. */
 {
-    if (obj != DWARF ||
-        !game.closed) {
+    if (obj != DWARF || !game.closed) {
         speak(actions[verb].message);
         return GO_CLEAROBJ;
     } else {
@@ -1280,11 +1288,7 @@ static phase_codes_t waste(verb_t verb, turn_t turns)
 static phase_codes_t wave(verb_t verb, obj_t obj)
 /* Wave.  No effect unless waving rod at fissure or at bird. */
 {
-    if (obj != ROD ||
-        !TOTING(obj) ||
-        (!HERE(BIRD) &&
-         (game.closng ||
-          !AT(FISSURE)))) {
+    if (obj != ROD || !TOTING(obj) || (!HERE(BIRD) && (game.closng || !AT(FISSURE)))) {
         speak(((!TOTING(obj)) && (obj != ROD ||
                                   !TOTING(ROD2))) ?
               arbitrary_messages[ARENT_CARRYING] :
@@ -1292,33 +1296,33 @@ static phase_codes_t wave(verb_t verb, obj_t obj)
         return GO_CLEAROBJ;
     }
 
-    if (game.prop[BIRD] == BIRD_UNCAGED && game.loc == game.place[STEPS] && game.prop[JADE] == STATE_NOTFOUND) {
+    if (game.objects[BIRD].prop == BIRD_UNCAGED && game.loc == game.objects[STEPS].place
+	&& game.objects[JADE].prop == STATE_NOTFOUND) {
         drop(JADE, game.loc);
-        game.prop[JADE] = STATE_FOUND;
+        game.objects[JADE].prop = STATE_FOUND;
         --game.tally;
         rspeak(NECKLACE_FLY);
         return GO_CLEAROBJ;
     } else {
         if (game.closed) {
-            rspeak((game.prop[BIRD] == BIRD_CAGED) ?
+            rspeak((game.objects[BIRD].prop == BIRD_CAGED) ?
                    CAGE_FLY :
                    FREE_FLY);
             return GO_DWARFWAKE;
         }
-        if (game.closng ||
-            !AT(FISSURE)) {
-            rspeak((game.prop[BIRD] == BIRD_CAGED) ?
+        if (game.closng || !AT(FISSURE)) {
+            rspeak((game.objects[BIRD].prop == BIRD_CAGED) ?
                    CAGE_FLY :
                    FREE_FLY);
             return GO_CLEAROBJ;
         }
         if (HERE(BIRD))
-            rspeak((game.prop[BIRD] == BIRD_CAGED) ?
+            rspeak((game.objects[BIRD].prop == BIRD_CAGED) ?
                    CAGE_FLY :
                    FREE_FLY);
 
         state_change(FISSURE,
-                     game.prop[FISSURE] == BRIDGED ? UNBRIDGED : BRIDGED);
+                     game.objects[FISSURE].prop == BRIDGED ? UNBRIDGED : BRIDGED);
         return GO_CLEAROBJ;
     }
 }
@@ -1348,13 +1352,13 @@ phase_codes_t action(command_t command)
             /* FALL THROUGH */;
         else if (command.obj == DWARF && atdwrf(game.loc) > 0)
             /* FALL THROUGH */;
-        else if ((LIQUID() == command.obj && HERE(BOTTLE)) ||
-                 command.obj == LIQLOC(game.loc))
+        else if (!game.closed && ((LIQUID() == command.obj && HERE(BOTTLE)) ||
+                                  command.obj == LIQLOC(game.loc)))
             /* FALL THROUGH */;
-        else if (command.obj == OIL && HERE(URN) && game.prop[URN] != URN_EMPTY) {
+        else if (command.obj == OIL && HERE(URN) && game.objects[URN].prop != URN_EMPTY) {
             command.obj = URN;
             /* FALL THROUGH */;
-        } else if (command.obj == PLANT && AT(PLANT2) && game.prop[PLANT2] != PLANT_THIRSTY) {
+        } else if (command.obj == PLANT && AT(PLANT2) && game.objects[PLANT2].prop != PLANT_THIRSTY) {
             command.obj = PLANT2;
             /* FALL THROUGH */;
         } else if (command.obj == KNIFE && game.knfloc == game.loc) {
@@ -1385,8 +1389,7 @@ phase_codes_t action(command_t command)
              * will do here. We're preventing interpretation as an intransitive
              * verb when the word is unknown. */
             command.obj = command.word[1].raw[0] != '\0' ? KEYS : NO_OBJECT;
-        if (command.obj == NO_OBJECT ||
-            command.obj == INTRANSITIVE) {
+        if (command.obj == NO_OBJECT || command.obj == INTRANSITIVE) {
             /*  Analyse an intransitive verb (ie, no object given yet). */
             switch (command.verb) {
             case CARRY:
@@ -1520,7 +1523,7 @@ phase_codes_t action(command_t command)
         case RUB:
             return rub(command.verb, command.obj);
         case THROW:
-            return throw (command);
+            return throwit(command);
         case QUIT: {
             speak(actions[command.verb].message);
             return GO_CLEAROBJ;