Address GitLab issue #56: handling of "fee fie foe foo" and "fum"
[open-adventure.git] / actions.c
1 /*
2  * Actions for the duneon-running code.
3  *
4  * Copyright (c) 1977, 2005 by Will Crowther and Don Woods
5  * Copyright (c) 2017 by Eric S. Raymond
6  * SPDX-License-Identifier: BSD-2-clause
7  */
8
9 #include <stdlib.h>
10 #include <stdbool.h>
11 #include <string.h>
12 #include "advent.h"
13 #include "dungeon.h"
14 #include <inttypes.h>
15
16 static phase_codes_t fill(verb_t, obj_t);
17
18 static phase_codes_t attack(command_t command)
19 /*  Attack.  Assume target if unambiguous.  "Throw" also links here.
20  *  Attackable objects fall into two categories: enemies (snake,
21  *  dwarf, etc.)  and others (bird, clam, machine).  Ambiguous if 2
22  *  enemies, or no enemies but 2 others. */
23 {
24     verb_t verb = command.verb;
25     obj_t obj = command.obj;
26
27     if (obj == INTRANSITIVE) {
28         int changes = 0;
29         if (atdwrf(game.loc) > 0) {
30             obj = DWARF;
31             ++changes;
32         }
33         if (HERE(SNAKE)) {
34             obj = SNAKE;
35             ++changes;
36         }
37         if (AT(DRAGON) && game.prop[DRAGON] == DRAGON_BARS) {
38             obj = DRAGON;
39             ++changes;
40         }
41         if (AT(TROLL)) {
42             obj = TROLL;
43             ++changes;
44         }
45         if (AT(OGRE)) {
46             obj = OGRE;
47             ++changes;
48         }
49         if (HERE(BEAR) && game.prop[BEAR] == UNTAMED_BEAR) {
50             obj = BEAR;
51             ++changes;
52         }
53         /* check for low-priority targets */
54         if (obj == INTRANSITIVE) {
55             /* Can't attack bird or machine by throwing axe. */
56             if (HERE(BIRD) && verb != THROW) {
57                 obj = BIRD;
58                 ++changes;
59             }
60             if (HERE(VEND) && verb != THROW) {
61                 obj = VEND;
62                 ++changes;
63             }
64             /* Clam and oyster both treated as clam for intransitive case;
65              * no harm done. */
66             if (HERE(CLAM) || HERE(OYSTER)) {
67                 obj = CLAM;
68                 ++changes;
69             }
70         }
71         if (changes >= 2)
72             return GO_UNKNOWN;
73     }
74
75     if (obj == BIRD) {
76         if (game.closed) {
77             rspeak(UNHAPPY_BIRD);
78         } else {
79             DESTROY(BIRD);
80             rspeak(BIRD_DEAD);
81         }
82         return GO_CLEAROBJ;
83     }
84     if (obj == VEND) {
85         state_change(VEND,
86                      game.prop[VEND] == VEND_BLOCKS ? VEND_UNBLOCKS : VEND_BLOCKS);
87
88         return GO_CLEAROBJ;
89     }
90
91     if (obj == BEAR) {
92         switch (game.prop[BEAR]) {
93         case UNTAMED_BEAR:
94             rspeak(BEAR_HANDS);
95             break;
96         case SITTING_BEAR:
97             rspeak(BEAR_CONFUSED);
98             break;
99         case CONTENTED_BEAR:
100             rspeak(BEAR_CONFUSED);
101             break;
102         case BEAR_DEAD:
103             rspeak(ALREADY_DEAD);
104             break;
105         }
106         return GO_CLEAROBJ;
107     }
108     if (obj == DRAGON && game.prop[DRAGON] == DRAGON_BARS) {
109         /*  Fun stuff for dragon.  If he insists on attacking it, win!
110          *  Set game.prop to dead, move dragon to central loc (still
111          *  fixed), move rug there (not fixed), and move him there,
112          *  too.  Then do a null motion to get new description. */
113         rspeak(BARE_HANDS_QUERY);
114         if (!silent_yes()) {
115             speak(arbitrary_messages[NASTY_DRAGON]);
116             return GO_MOVE;
117         }
118         state_change(DRAGON, DRAGON_DEAD);
119         game.prop[RUG] = RUG_FLOOR;
120         /* Hardcoding LOC_SECRET5 as the dragon's death location is ugly.
121          * The way it was computed before was worse; it depended on the
122          * two dragon locations being LOC_SECRET4 and LOC_SECRET6 and
123          * LOC_SECRET5 being right between them.
124          */
125         move(DRAGON + NOBJECTS, IS_FIXED);
126         move(RUG + NOBJECTS, IS_FREE);
127         move(DRAGON, LOC_SECRET5);
128         move(RUG, LOC_SECRET5);
129         drop(BLOOD, LOC_SECRET5);
130         for (obj_t i = 1; i <= NOBJECTS; i++) {
131             if (game.place[i] == objects[DRAGON].plac ||
132                 game.place[i] == objects[DRAGON].fixd)
133                 move(i, LOC_SECRET5);
134         }
135         game.loc = LOC_SECRET5;
136         return GO_MOVE;
137     }
138
139     if (obj == OGRE) {
140         rspeak(OGRE_DODGE);
141         if (atdwrf(game.loc) == 0)
142             return GO_CLEAROBJ;
143
144         rspeak(KNIFE_THROWN);
145         DESTROY(OGRE);
146         int dwarves = 0;
147         for (int i = 1; i < PIRATE; i++) {
148             if (game.dloc[i] == game.loc) {
149                 ++dwarves;
150                 game.dloc[i] = LOC_LONGWEST;
151                 game.dseen[i] = false;
152             }
153         }
154         rspeak((dwarves > 1) ?
155                OGRE_PANIC1 :
156                OGRE_PANIC2);
157         return GO_CLEAROBJ;
158     }
159
160     switch (obj) {
161     case INTRANSITIVE:
162         rspeak(NO_TARGET);
163         break;
164     case CLAM:
165     case OYSTER:
166         rspeak(SHELL_IMPERVIOUS);
167         break;
168     case SNAKE:
169         rspeak(SNAKE_WARNING);
170         break;
171     case DWARF:
172         if (game.closed) {
173             return GO_DWARFWAKE;
174         }
175         rspeak(BARE_HANDS_QUERY);
176         break;
177     case DRAGON:
178         rspeak(ALREADY_DEAD);
179         break;
180     case TROLL:
181         rspeak(ROCKY_TROLL);
182         break;
183     default:
184         speak(actions[verb].message);
185     }
186     return GO_CLEAROBJ;
187 }
188
189 static phase_codes_t bigwords(vocab_t id)
190 /*  FEE FIE FOE FOO (AND FUM).  Advance to next state if given in proper order.
191  *  Look up foo in special section of vocab to determine which word we've got.
192  *  Last word zips the eggs back to the giant room (unless already there). */
193 {
194     if ((game.foobar == WORD_EMPTY && id == FEE) ||
195         (game.foobar == FEE && id == FIE) ||
196         (game.foobar == FIE && id == FOE) ||
197         (game.foobar == FOE && id == FOO) ||
198         (game.foobar == FOE && id == FUM)) {
199         game.foobar = id;
200         if ((id != FOO) && (id != FUM)) {
201             rspeak(OK_MAN);
202             return GO_CLEAROBJ;
203         }
204         game.foobar = WORD_EMPTY;
205         if (game.place[EGGS] == objects[EGGS].plac ||
206             (TOTING(EGGS) && game.loc == objects[EGGS].plac)) {
207             rspeak(NOTHING_HAPPENS);
208             return GO_CLEAROBJ;
209         } else if (id == FUM) {
210             goto fum;
211         } else {
212             /*  Bring back troll if we steal the eggs back from him before
213              *  crossing. */
214             if (game.place[EGGS] == LOC_NOWHERE && game.place[TROLL] == LOC_NOWHERE && game.prop[TROLL] == TROLL_UNPAID)
215                 game.prop[TROLL] = TROLL_PAIDONCE;
216             if (HERE(EGGS))
217                 pspeak(EGGS, look, true, EGGS_VANISHED);
218             else if (game.loc == objects[EGGS].plac)
219                 pspeak(EGGS, look, true, EGGS_HERE);
220             else
221                 pspeak(EGGS, look, true, EGGS_DONE);
222             move(EGGS, objects[EGGS].plac);
223
224             return GO_CLEAROBJ;
225         }
226     } else {
227     fum:
228         if (game.loc == LOC_GIANTROOM) {
229             rspeak(START_OVER);
230         } else {
231             /* This is new begavior in Open Adventure - sounds better when
232              * player isn't in the Giant Room. */
233             rspeak(WELL_POINTLESS);
234         }
235         game.foobar = WORD_EMPTY;
236         return GO_CLEAROBJ;
237     }
238 }
239
240 static void blast(void)
241 /*  Blast.  No effect unless you've got dynamite, which is a neat trick! */
242 {
243     if (game.prop[ROD2] == STATE_NOTFOUND ||
244         !game.closed)
245         rspeak(REQUIRES_DYNAMITE);
246     else {
247         if (HERE(ROD2)) {
248             game.bonus = splatter;
249             rspeak(SPLATTER_MESSAGE);
250         } else if (game.loc == LOC_NE) {
251             game.bonus = defeat;
252             rspeak(DEFEAT_MESSAGE);
253         } else {
254             game.bonus = victory;
255             rspeak(VICTORY_MESSAGE);
256         }
257         terminate(endgame);
258     }
259 }
260
261 static phase_codes_t vbreak(verb_t verb, obj_t obj)
262 /*  Break.  Only works for mirror in repository and, of course, the vase. */
263 {
264     switch (obj) {
265     case MIRROR:
266         if (game.closed) {
267             state_change(MIRROR, MIRROR_BROKEN);
268             return GO_DWARFWAKE;
269         } else {
270             rspeak(TOO_FAR);
271             break;
272         }
273     case VASE:
274         if (game.prop[VASE] == VASE_WHOLE) {
275             if (TOTING(VASE))
276                 drop(VASE, game.loc);
277             state_change(VASE, VASE_BROKEN);
278             game.fixed[VASE] = IS_FIXED;
279             break;
280         }
281     /* FALLTHRU */
282     default:
283         speak(actions[verb].message);
284     }
285     return (GO_CLEAROBJ);
286 }
287
288 static phase_codes_t brief(void)
289 /*  Brief.  Intransitive only.  Suppress full descriptions after first time. */
290 {
291     game.abbnum = 10000;
292     game.detail = 3;
293     rspeak(BRIEF_CONFIRM);
294     return GO_CLEAROBJ;
295 }
296
297 static phase_codes_t vcarry(verb_t verb, obj_t obj)
298 /*  Carry an object.  Special cases for bird and cage (if bird in cage, can't
299  *  take one without the other).  Liquids also special, since they depend on
300  *  status of bottle.  Also various side effects, etc. */
301 {
302     if (obj == INTRANSITIVE) {
303         /*  Carry, no object given yet.  OK if only one object present. */
304         if (game.atloc[game.loc] == NO_OBJECT ||
305             game.link[game.atloc[game.loc]] != 0 ||
306             atdwrf(game.loc) > 0)
307             return GO_UNKNOWN;
308         obj = game.atloc[game.loc];
309     }
310
311     if (TOTING(obj)) {
312         speak(actions[verb].message);
313         return GO_CLEAROBJ;
314     }
315
316     if (obj == MESSAG) {
317         rspeak(REMOVE_MESSAGE);
318         DESTROY(MESSAG);
319         return GO_CLEAROBJ;
320     }
321
322     if (game.fixed[obj] != IS_FREE) {
323         switch (obj) {
324         case PLANT:
325             /* Next guard tests whether plant is tiny or stashed */
326             rspeak(game.prop[PLANT] <= PLANT_THIRSTY ? DEEP_ROOTS : YOU_JOKING);
327             break;
328         case BEAR:
329             rspeak( game.prop[BEAR] == SITTING_BEAR ? BEAR_CHAINED : YOU_JOKING);
330             break;
331         case CHAIN:
332             rspeak( game.prop[BEAR] != UNTAMED_BEAR ? STILL_LOCKED : YOU_JOKING);
333             break;
334         case RUG:
335             rspeak(game.prop[RUG] == RUG_HOVER ? RUG_HOVERS : YOU_JOKING);
336             break;
337         case URN:
338             rspeak(URN_NOBUDGE);
339             break;
340         case CAVITY:
341             rspeak(DOUGHNUT_HOLES);
342             break;
343         case BLOOD:
344             rspeak(FEW_DROPS);
345             break;
346         case SIGN:
347             rspeak(HAND_PASSTHROUGH);
348             break;
349         default:
350             rspeak(YOU_JOKING);
351         }
352         return GO_CLEAROBJ;
353     }
354
355     if (obj == WATER ||
356         obj == OIL) {
357         if (!HERE(BOTTLE) ||
358             LIQUID() != obj) {
359             if (!TOTING(BOTTLE)) {
360                 rspeak(NO_CONTAINER);
361                 return GO_CLEAROBJ;
362             }
363             if (game.prop[BOTTLE] == EMPTY_BOTTLE) {
364                 return (fill(verb, BOTTLE));
365             } else
366                 rspeak(BOTTLE_FULL);
367             return GO_CLEAROBJ;
368         }
369         obj = BOTTLE;
370     }
371
372     if (game.holdng >= INVLIMIT) {
373         rspeak(CARRY_LIMIT);
374         return GO_CLEAROBJ;
375
376     }
377
378     if (obj == BIRD && game.prop[BIRD] != BIRD_CAGED && STASHED(BIRD) != BIRD_CAGED) {
379         if (game.prop[BIRD] == BIRD_FOREST_UNCAGED) {
380             DESTROY(BIRD);
381             rspeak(BIRD_CRAP);
382             return GO_CLEAROBJ;
383         }
384         if (!TOTING(CAGE)) {
385             rspeak(CANNOT_CARRY);
386             return GO_CLEAROBJ;
387         }
388         if (TOTING(ROD)) {
389             rspeak(BIRD_EVADES);
390             return GO_CLEAROBJ;
391         }
392         game.prop[BIRD] = BIRD_CAGED;
393     }
394     if ((obj == BIRD ||
395          obj == CAGE) &&
396         (game.prop[BIRD] == BIRD_CAGED || STASHED(BIRD) == BIRD_CAGED)) {
397         /* expression maps BIRD to CAGE and CAGE to BIRD */
398         carry(BIRD + CAGE - obj, game.loc);
399     }
400
401     carry(obj, game.loc);
402
403     if (obj == BOTTLE && LIQUID() != NO_OBJECT)
404         game.place[LIQUID()] = CARRIED;
405
406     if (GSTONE(obj) && game.prop[obj] != STATE_FOUND) {
407         game.prop[obj] = STATE_FOUND;
408         game.prop[CAVITY] = CAVITY_EMPTY;
409     }
410     rspeak(OK_MAN);
411     return GO_CLEAROBJ;
412 }
413
414 static int chain(verb_t verb)
415 /* Do something to the bear's chain */
416 {
417     if (verb != LOCK) {
418         if (game.prop[BEAR] == UNTAMED_BEAR) {
419             rspeak(BEAR_BLOCKS);
420             return GO_CLEAROBJ;
421         }
422         if (game.prop[CHAIN] == CHAIN_HEAP) {
423             rspeak(ALREADY_UNLOCKED);
424             return GO_CLEAROBJ;
425         }
426         game.prop[CHAIN] = CHAIN_HEAP;
427         game.fixed[CHAIN] = IS_FREE;
428         if (game.prop[BEAR] != BEAR_DEAD)
429             game.prop[BEAR] = CONTENTED_BEAR;
430
431         switch (game.prop[BEAR]) {
432         // LCOV_EXCL_START
433         case BEAR_DEAD:
434             /* Can't be reached until the bear can die in some way other
435              * than a bridge collapse. Leave in in case this changes, but
436              * exclude from coverage testing. */
437             game.fixed[BEAR] = IS_FIXED;
438             break;
439         // LCOV_EXCL_STOP
440         default:
441             game.fixed[BEAR] = IS_FREE;
442         }
443         rspeak(CHAIN_UNLOCKED);
444         return GO_CLEAROBJ;
445     }
446
447     if (game.prop[CHAIN] != CHAIN_HEAP) {
448         rspeak(ALREADY_LOCKED);
449         return GO_CLEAROBJ;
450     }
451     if (game.loc != objects[CHAIN].plac) {
452         rspeak(NO_LOCKSITE);
453         return GO_CLEAROBJ;
454     }
455
456     game.prop[CHAIN] = CHAIN_FIXED;
457
458     if (TOTING(CHAIN))
459         drop(CHAIN, game.loc);
460     game.fixed[CHAIN] = IS_FIXED;
461
462     rspeak(CHAIN_LOCKED);
463     return GO_CLEAROBJ;
464 }
465
466 static phase_codes_t discard(verb_t verb, obj_t obj)
467 /*  Discard object.  "Throw" also comes here for most objects.  Special cases for
468  *  bird (might attack snake or dragon) and cage (might contain bird) and vase.
469  *  Drop coins at vending machine for extra batteries. */
470 {
471     if (obj == ROD && !TOTING(ROD) && TOTING(ROD2)) {
472         obj = ROD2;
473     }
474
475     if (!TOTING(obj)) {
476         speak(actions[verb].message);
477         return GO_CLEAROBJ;
478     }
479
480     if (GSTONE(obj) && AT(CAVITY) && game.prop[CAVITY] != CAVITY_FULL) {
481         rspeak(GEM_FITS);
482         game.prop[obj] = STATE_IN_CAVITY;
483         game.prop[CAVITY] = CAVITY_FULL;
484         if (HERE(RUG) && ((obj == EMERALD && game.prop[RUG] != RUG_HOVER) ||
485                           (obj == RUBY && game.prop[RUG] == RUG_HOVER))) {
486             if (obj == RUBY)
487                 rspeak(RUG_SETTLES);
488             else if (TOTING(RUG))
489                 rspeak(RUG_WIGGLES);
490             else
491                 rspeak(RUG_RISES);
492             if (!TOTING(RUG) || obj == RUBY) {
493                 int k = (game.prop[RUG] == RUG_HOVER) ? RUG_FLOOR : RUG_HOVER;
494                 game.prop[RUG] = k;
495                 if (k == RUG_HOVER)
496                     k = objects[SAPPH].plac;
497                 move(RUG + NOBJECTS, k);
498             }
499         }
500         drop(obj, game.loc);
501         return GO_CLEAROBJ;
502     }
503
504     if (obj == COINS && HERE(VEND)) {
505         DESTROY(COINS);
506         drop(BATTERY, game.loc);
507         pspeak(BATTERY, look, true, FRESH_BATTERIES);
508         return GO_CLEAROBJ;
509     }
510
511     if (LIQUID() == obj)
512         obj = BOTTLE;
513     if (obj == BOTTLE && LIQUID() != NO_OBJECT) {
514         game.place[LIQUID()] = LOC_NOWHERE;
515     }
516
517     if (obj == BEAR && AT(TROLL)) {
518         state_change(TROLL, TROLL_GONE);
519         move(TROLL, LOC_NOWHERE);
520         move(TROLL + NOBJECTS, IS_FREE);
521         move(TROLL2, objects[TROLL].plac);
522         move(TROLL2 + NOBJECTS, objects[TROLL].fixd);
523         juggle(CHASM);
524         drop(obj, game.loc);
525         return GO_CLEAROBJ;
526     }
527
528     if (obj == VASE) {
529         if (game.loc != objects[PILLOW].plac) {
530             state_change(VASE, AT(PILLOW)
531                          ? VASE_WHOLE
532                          : VASE_DROPPED);
533             if (game.prop[VASE] != VASE_WHOLE)
534                 game.fixed[VASE] = IS_FIXED;
535             drop(obj, game.loc);
536             return GO_CLEAROBJ;
537         }
538     }
539
540     if (obj == CAGE && game.prop[BIRD] == BIRD_CAGED) {
541         drop(BIRD, game.loc);
542     }
543
544     if (obj == BIRD) {
545         if (AT(DRAGON) && game.prop[DRAGON] == DRAGON_BARS) {
546             rspeak(BIRD_BURNT);
547             DESTROY(BIRD);
548             return GO_CLEAROBJ;
549         }
550         if (HERE(SNAKE)) {
551             rspeak(BIRD_ATTACKS);
552             if (game.closed)
553                 return GO_DWARFWAKE;
554             DESTROY(SNAKE);
555             /* Set game.prop for use by travel options */
556             game.prop[SNAKE] = SNAKE_CHASED;
557         } else
558             rspeak(OK_MAN);
559
560         game.prop[BIRD] = FOREST(game.loc) ? BIRD_FOREST_UNCAGED : BIRD_UNCAGED;
561         drop(obj, game.loc);
562         return GO_CLEAROBJ;
563     }
564
565     rspeak(OK_MAN);
566     drop(obj, game.loc);
567     return GO_CLEAROBJ;
568 }
569
570 static phase_codes_t drink(verb_t verb, obj_t obj)
571 /*  Drink.  If no object, assume water and look for it here.  If water is in
572  *  the bottle, drink that, else must be at a water loc, so drink stream. */
573 {
574     if (obj == INTRANSITIVE && LIQLOC(game.loc) != WATER &&
575         (LIQUID() != WATER || !HERE(BOTTLE))) {
576         return GO_UNKNOWN;
577     }
578
579     if (obj == BLOOD) {
580         DESTROY(BLOOD);
581         state_change(DRAGON, DRAGON_BLOODLESS);
582         game.blooded = true;
583         return GO_CLEAROBJ;
584     }
585
586     if (obj != INTRANSITIVE && obj != WATER) {
587         rspeak(RIDICULOUS_ATTEMPT);
588         return GO_CLEAROBJ;
589     }
590     if (LIQUID() == WATER && HERE(BOTTLE)) {
591         game.place[WATER] = LOC_NOWHERE;
592         state_change(BOTTLE, EMPTY_BOTTLE);
593         return GO_CLEAROBJ;
594     }
595
596     speak(actions[verb].message);
597     return GO_CLEAROBJ;
598 }
599
600 static phase_codes_t eat(verb_t verb, obj_t obj)
601 /*  Eat.  Intransitive: assume food if present, else ask what.  Transitive: food
602  *  ok, some things lose appetite, rest are ridiculous. */
603 {
604     switch (obj) {
605     case INTRANSITIVE:
606         if (!HERE(FOOD))
607             return GO_UNKNOWN;
608     /* FALLTHRU */
609     case FOOD:
610         DESTROY(FOOD);
611         rspeak(THANKS_DELICIOUS);
612         break;
613     case BIRD:
614     case SNAKE:
615     case CLAM:
616     case OYSTER:
617     case DWARF:
618     case DRAGON:
619     case TROLL:
620     case BEAR:
621     case OGRE:
622         rspeak(LOST_APPETITE);
623         break;
624     default:
625         speak(actions[verb].message);
626     }
627     return GO_CLEAROBJ;
628 }
629
630 static phase_codes_t extinguish(verb_t verb, obj_t obj)
631 /* Extinguish.  Lamp, urn, dragon/volcano (nice try). */
632 {
633     if (obj == INTRANSITIVE) {
634         if (HERE(LAMP) && game.prop[LAMP] == LAMP_BRIGHT)
635             obj = LAMP;
636         if (HERE(URN) && game.prop[URN] == URN_LIT)
637             obj = URN;
638         if (obj == INTRANSITIVE)
639             return GO_UNKNOWN;
640     }
641
642     switch (obj) {
643     case URN:
644         if (game.prop[URN] != URN_EMPTY) {
645             state_change(URN, URN_DARK);
646         } else {
647             pspeak(URN, change, true, URN_DARK);
648         }
649         break;
650     case LAMP:
651         state_change(LAMP, LAMP_DARK);
652         rspeak(DARK(game.loc) ?
653                PITCH_DARK :
654                NO_MESSAGE);
655         break;
656     case DRAGON:
657     case VOLCANO:
658         rspeak(BEYOND_POWER);
659         break;
660     default:
661         speak(actions[verb].message);
662     }
663     return GO_CLEAROBJ;
664 }
665
666 static phase_codes_t feed(verb_t verb, obj_t obj)
667 /*  Feed.  If bird, no seed.  Snake, dragon, troll: quip.  If dwarf, make him
668  *  mad.  Bear, special. */
669 {
670     switch (obj) {
671     case BIRD:
672         rspeak(BIRD_PINING);
673         break;
674     case DRAGON:
675         if (game.prop[DRAGON] != DRAGON_BARS)
676             rspeak(RIDICULOUS_ATTEMPT);
677         else
678             rspeak(NOTHING_EDIBLE);
679         break;
680     case SNAKE:
681         if (!game.closed && HERE(BIRD)) {
682             DESTROY(BIRD);
683             rspeak(BIRD_DEVOURED);
684         } else
685             rspeak(NOTHING_EDIBLE);
686         break;
687     case TROLL:
688         rspeak(TROLL_VICES);
689         break;
690     case DWARF:
691         if (HERE(FOOD)) {
692             game.dflag += 2;
693             rspeak(REALLY_MAD);
694         } else
695             speak(actions[verb].message);
696         break;
697     case BEAR:
698         if (game.prop[BEAR] == BEAR_DEAD) {
699             rspeak(RIDICULOUS_ATTEMPT);
700             break;
701         }
702         if (game.prop[BEAR] == UNTAMED_BEAR) {
703             if (HERE(FOOD)) {
704                 DESTROY(FOOD);
705                 game.fixed[AXE] = IS_FREE;
706                 game.prop[AXE] = AXE_HERE;
707                 state_change(BEAR, SITTING_BEAR);
708             } else
709                 rspeak(NOTHING_EDIBLE);
710             break;
711         }
712         speak(actions[verb].message);
713         break;
714     case OGRE:
715         if (HERE(FOOD))
716             rspeak(OGRE_FULL);
717         else
718             speak(actions[verb].message);
719         break;
720     default:
721         rspeak(AM_GAME);
722     }
723     return GO_CLEAROBJ;
724 }
725
726 phase_codes_t fill(verb_t verb, obj_t obj)
727 /*  Fill.  Bottle or urn must be empty, and liquid available.  (Vase
728  *  is nasty.) */
729 {
730     if (obj == VASE) {
731         if (LIQLOC(game.loc) == NO_OBJECT) {
732             rspeak(FILL_INVALID);
733             return GO_CLEAROBJ;
734         }
735         if (!TOTING(VASE)) {
736             rspeak(ARENT_CARRYING);
737             return GO_CLEAROBJ;
738         }
739         rspeak(SHATTER_VASE);
740         game.prop[VASE] = VASE_BROKEN;
741         game.fixed[VASE] = IS_FIXED;
742         drop(VASE, game.loc);
743         return GO_CLEAROBJ;
744     }
745
746     if (obj == URN) {
747         if (game.prop[URN] != URN_EMPTY) {
748             rspeak(FULL_URN);
749             return GO_CLEAROBJ;
750         }
751         if (!HERE(BOTTLE)) {
752             rspeak(FILL_INVALID);
753             return GO_CLEAROBJ;
754         }
755         int k = LIQUID();
756         switch (k) {
757         case WATER:
758             game.prop[BOTTLE] = EMPTY_BOTTLE;
759             rspeak(WATER_URN);
760             break;
761         case OIL:
762             game.prop[URN] = URN_DARK;
763             game.prop[BOTTLE] = EMPTY_BOTTLE;
764             rspeak(OIL_URN);
765             break;
766         case NO_OBJECT:
767         default:
768             rspeak(FILL_INVALID);
769             return GO_CLEAROBJ;
770         }
771         game.place[k] = LOC_NOWHERE;
772         return GO_CLEAROBJ;
773     }
774     if (obj != INTRANSITIVE && obj != BOTTLE) {
775         speak(actions[verb].message);
776         return GO_CLEAROBJ;
777     }
778     if (obj == INTRANSITIVE && !HERE(BOTTLE))
779         return GO_UNKNOWN;
780
781     if (HERE(URN) && game.prop[URN] != URN_EMPTY) {
782         rspeak(URN_NOPOUR);
783         return GO_CLEAROBJ;
784     }
785     if (LIQUID() != NO_OBJECT) {
786         rspeak(BOTTLE_FULL);
787         return GO_CLEAROBJ;
788     }
789     if (LIQLOC(game.loc) == NO_OBJECT) {
790         rspeak(NO_LIQUID);
791         return GO_CLEAROBJ;
792     }
793
794     state_change(BOTTLE, (LIQLOC(game.loc) == OIL)
795                  ? OIL_BOTTLE
796                  : WATER_BOTTLE);
797     if (TOTING(BOTTLE))
798         game.place[LIQUID()] = CARRIED;
799     return GO_CLEAROBJ;
800 }
801
802 static phase_codes_t find(verb_t verb, obj_t obj)
803 /* Find.  Might be carrying it, or it might be here.  Else give caveat. */
804 {
805     if (TOTING(obj)) {
806         rspeak(ALREADY_CARRYING);
807         return GO_CLEAROBJ;
808     }
809
810     if (game.closed) {
811         rspeak(NEEDED_NEARBY);
812         return GO_CLEAROBJ;
813     }
814
815     if (AT(obj) ||
816         (LIQUID() == obj && AT(BOTTLE)) ||
817         obj == LIQLOC(game.loc) ||
818         (obj == DWARF && atdwrf(game.loc) > 0)) {
819         rspeak(YOU_HAVEIT);
820         return GO_CLEAROBJ;
821     }
822
823
824     speak(actions[verb].message);
825     return GO_CLEAROBJ;
826 }
827
828 static phase_codes_t fly(verb_t verb, obj_t obj)
829 /* Fly.  Snide remarks unless hovering rug is here. */
830 {
831     if (obj == INTRANSITIVE) {
832         if (!HERE(RUG)) {
833             rspeak(FLAP_ARMS);
834             return GO_CLEAROBJ;
835         }
836         if (game.prop[RUG] != RUG_HOVER) {
837             rspeak(RUG_NOTHING2);
838             return GO_CLEAROBJ;
839         }
840         obj = RUG;
841     }
842
843     if (obj != RUG) {
844         speak(actions[verb].message);
845         return GO_CLEAROBJ;
846     }
847     if (game.prop[RUG] != RUG_HOVER) {
848         rspeak(RUG_NOTHING1);
849         return GO_CLEAROBJ;
850     }
851
852     if (game.loc == LOC_CLIFF) {
853         game.oldlc2 = game.oldloc;
854         game.oldloc = game.loc;
855         game.newloc = LOC_LEDGE;
856         rspeak(RUG_GOES);
857     } else if (game.loc == LOC_LEDGE) {
858         game.oldlc2 = game.oldloc;
859         game.oldloc = game.loc;
860         game.newloc = LOC_CLIFF;
861         rspeak(RUG_RETURNS);
862     } else {
863         /* should never happen */
864         rspeak(NOTHING_HAPPENS);
865     }
866     return GO_TERMINATE;
867 }
868
869 static phase_codes_t inven(void)
870 /* Inventory. If object, treat same as find.  Else report on current burden. */
871 {
872     bool empty = true;
873     for (obj_t i = 1; i <= NOBJECTS; i++) {
874         if (i == BEAR ||
875             !TOTING(i))
876             continue;
877         if (empty) {
878             rspeak(NOW_HOLDING);
879             empty = false;
880         }
881         pspeak(i, touch, false, -1);
882     }
883     if (TOTING(BEAR))
884         rspeak(TAME_BEAR);
885     if (empty)
886         rspeak(NO_CARRY);
887     return GO_CLEAROBJ;
888 }
889
890 static phase_codes_t light(verb_t verb, obj_t obj)
891 /*  Light.  Applicable only to lamp and urn. */
892 {
893     if (obj == INTRANSITIVE) {
894         int selects = 0;
895         if (HERE(LAMP) && game.prop[LAMP] == LAMP_DARK && game.limit >= 0) {
896             obj = LAMP;
897             selects++;
898         }
899         if (HERE(URN) && game.prop[URN] == URN_DARK) {
900             obj =  URN;
901             selects++;
902         }
903         if (selects != 1)
904             return GO_UNKNOWN;
905     }
906
907     switch (obj) {
908     case URN:
909         state_change(URN, game.prop[URN] == URN_EMPTY ?
910                      URN_EMPTY :
911                      URN_LIT);
912         break;
913     case LAMP:
914         if (game.limit < 0) {
915             rspeak(LAMP_OUT);
916             break;
917         }
918         state_change(LAMP, LAMP_BRIGHT);
919         if (game.wzdark)
920             return GO_TOP;
921         break;
922     default:
923         speak(actions[verb].message);
924     }
925     return GO_CLEAROBJ;
926 }
927
928 static phase_codes_t listen(void)
929 /*  Listen.  Intransitive only.  Print stuff based on object sound proprties. */
930 {
931     bool soundlatch = false;
932     vocab_t sound = locations[game.loc].sound;
933     if (sound != SILENT) {
934         rspeak(sound);
935         if (!locations[game.loc].loud)
936             rspeak(NO_MESSAGE);
937         soundlatch = true;
938     }
939     for (obj_t i = 1; i <= NOBJECTS; i++) {
940         if (!HERE(i) ||
941             objects[i].sounds[0] == NULL ||
942             game.prop[i] < 0)
943             continue;
944         int mi =  game.prop[i];
945         /* (ESR) Some unpleasant magic on object states here. Ideally
946          * we'd have liked the bird to be a normal object that we can
947          * use state_change() on; can't do it, because there are
948          * actually two different series of per-state birdsounds
949          * depending on whether player has drunk dragon's blood. */
950         if (i == BIRD)
951             mi += 3 * game.blooded;
952         pspeak(i, hear, true, mi, game.zzword);
953         rspeak(NO_MESSAGE);
954         if (i == BIRD && mi == BIRD_ENDSTATE)
955             DESTROY(BIRD);
956         soundlatch = true;
957     }
958     if (!soundlatch)
959         rspeak(ALL_SILENT);
960     return GO_CLEAROBJ;
961 }
962
963 static phase_codes_t lock(verb_t verb, obj_t obj)
964 /* Lock, unlock, no object given.  Assume various things if present. */
965 {
966     if (obj == INTRANSITIVE) {
967         if (HERE(CLAM))
968             obj = CLAM;
969         if (HERE(OYSTER))
970             obj = OYSTER;
971         if (AT(DOOR))
972             obj = DOOR;
973         if (AT(GRATE))
974             obj = GRATE;
975         if (HERE(CHAIN))
976             obj = CHAIN;
977         if (obj == INTRANSITIVE) {
978             rspeak(NOTHING_LOCKED);
979             return GO_CLEAROBJ;
980         }
981     }
982
983     /*  Lock, unlock object.  Special stuff for opening clam/oyster
984      *  and for chain. */
985
986     switch (obj) {
987     case CHAIN:
988         if (HERE(KEYS)) {
989             return chain(verb);
990         } else
991             rspeak(NO_KEYS);
992         break;
993     case GRATE:
994         if (HERE(KEYS)) {
995             if (game.closng) {
996                 rspeak(EXIT_CLOSED);
997                 if (!game.panic)
998                     game.clock2 = PANICTIME;
999                 game.panic = true;
1000             } else {
1001                 state_change(GRATE, (verb == LOCK) ?
1002                              GRATE_CLOSED :
1003                              GRATE_OPEN);
1004             }
1005         } else
1006             rspeak(NO_KEYS);
1007         break;
1008     case CLAM:
1009         if (verb == LOCK)
1010             rspeak(HUH_MAN);
1011         else if (TOTING(CLAM))
1012             rspeak(DROP_CLAM);
1013         else if (!TOTING(TRIDENT))
1014             rspeak(CLAM_OPENER);
1015         else {
1016             DESTROY(CLAM);
1017             drop(OYSTER, game.loc);
1018             drop(PEARL, LOC_CULDESAC);
1019             rspeak(PEARL_FALLS);
1020         }
1021         break;
1022     case OYSTER:
1023         if (verb == LOCK)
1024             rspeak(HUH_MAN);
1025         else if (TOTING(OYSTER))
1026             rspeak(DROP_OYSTER);
1027         else if (!TOTING(TRIDENT))
1028             rspeak(OYSTER_OPENER);
1029         else
1030             rspeak(OYSTER_OPENS);
1031         break;
1032     case DOOR:
1033         rspeak((game.prop[DOOR] == DOOR_UNRUSTED) ? OK_MAN : RUSTY_DOOR);
1034         break;
1035     case CAGE:
1036         rspeak( NO_LOCK);
1037         break;
1038     case KEYS:
1039         rspeak(CANNOT_UNLOCK);
1040         break;
1041     default:
1042         speak(actions[verb].message);
1043     }
1044
1045     return GO_CLEAROBJ;
1046 }
1047
1048 static phase_codes_t pour(verb_t verb, obj_t obj)
1049 /*  Pour.  If no object, or object is bottle, assume contents of bottle.
1050  *  special tests for pouring water or oil on plant or rusty door. */
1051 {
1052     if (obj == BOTTLE ||
1053         obj == INTRANSITIVE)
1054         obj = LIQUID();
1055     if (obj == NO_OBJECT)
1056         return GO_UNKNOWN;
1057     if (!TOTING(obj)) {
1058         speak(actions[verb].message);
1059         return GO_CLEAROBJ;
1060     }
1061
1062     if (obj != OIL && obj != WATER) {
1063         rspeak(CANT_POUR);
1064         return GO_CLEAROBJ;
1065     }
1066     if (HERE(URN) && game.prop[URN] == URN_EMPTY)
1067         return fill(verb, URN);
1068     game.prop[BOTTLE] = EMPTY_BOTTLE;
1069     game.place[obj] = LOC_NOWHERE;
1070     if (!(AT(PLANT) ||
1071           AT(DOOR))) {
1072         rspeak(GROUND_WET);
1073         return GO_CLEAROBJ;
1074     }
1075     if (!AT(DOOR)) {
1076         if (obj == WATER) {
1077             /* cycle through the three plant states */
1078             state_change(PLANT, MOD(game.prop[PLANT] + 1, 3));
1079             game.prop[PLANT2] = game.prop[PLANT];
1080             return GO_MOVE;
1081         } else {
1082             rspeak(SHAKING_LEAVES);
1083             return GO_CLEAROBJ;
1084         }
1085     } else {
1086         state_change(DOOR, (obj == OIL) ?
1087                      DOOR_UNRUSTED :
1088                      DOOR_RUSTED);
1089         return GO_CLEAROBJ;
1090     }
1091 }
1092
1093 static phase_codes_t quit(void)
1094 /*  Quit.  Intransitive only.  Verify intent and exit if that's what he wants. */
1095 {
1096     if (yes(arbitrary_messages[REALLY_QUIT], arbitrary_messages[OK_MAN], arbitrary_messages[OK_MAN]))
1097         terminate(quitgame);
1098     return GO_CLEAROBJ;
1099 }
1100
1101 static phase_codes_t read(command_t command)
1102 /*  Read.  Print stuff based on objtxt.  Oyster (?) is special case. */
1103 {
1104     if (command.obj == INTRANSITIVE) {
1105         command.obj = NO_OBJECT;
1106         for (int i = 1; i <= NOBJECTS; i++) {
1107             if (HERE(i) && objects[i].texts[0] != NULL && game.prop[i] >= 0)
1108                 command.obj = command.obj * NOBJECTS + i;
1109         }
1110         if (command.obj > NOBJECTS ||
1111             command.obj == NO_OBJECT ||
1112             DARK(game.loc))
1113             return GO_UNKNOWN;
1114     }
1115
1116     if (DARK(game.loc)) {
1117         sspeak(NO_SEE, command.word[0].raw);
1118     } else if (command.obj == OYSTER) {
1119         if (!TOTING(OYSTER) || !game.closed) {
1120             rspeak(DONT_UNDERSTAND);
1121         } else if (!game.clshnt) {
1122             game.clshnt = yes(arbitrary_messages[CLUE_QUERY], arbitrary_messages[WAYOUT_CLUE], arbitrary_messages[OK_MAN]);
1123         } else if (game.clshnt) {
1124             pspeak(OYSTER, hear, true, 1);      // Not really a sound, but oh well.
1125         }
1126     } else if (objects[command.obj].texts[0] == NULL ||
1127                game.prop[command.obj] == STATE_NOTFOUND) {
1128         speak(actions[command.verb].message);
1129     } else
1130         pspeak(command.obj, study, true, game.prop[command.obj]);
1131     return GO_CLEAROBJ;
1132 }
1133
1134 static phase_codes_t reservoir(void)
1135 /*  Z'ZZZ (word gets recomputed at startup; different each game). */
1136 {
1137     if (!AT(RESER) && game.loc != LOC_RESBOTTOM) {
1138         rspeak(NOTHING_HAPPENS);
1139         return GO_CLEAROBJ;
1140     } else {
1141         state_change(RESER,
1142                      game.prop[RESER] == WATERS_PARTED ? WATERS_UNPARTED : WATERS_PARTED);
1143         if (AT(RESER))
1144             return GO_CLEAROBJ;
1145         else {
1146             game.oldlc2 = game.loc;
1147             game.newloc = LOC_NOWHERE;
1148             rspeak(NOT_BRIGHT);
1149             return GO_TERMINATE;
1150         }
1151     }
1152 }
1153
1154 static phase_codes_t rub(verb_t verb, obj_t obj)
1155 /* Rub.  Yields various snide remarks except for lit urn. */
1156 {
1157     if (obj == URN && game.prop[URN] == URN_LIT) {
1158         DESTROY(URN);
1159         drop(AMBER, game.loc);
1160         game.prop[AMBER] = AMBER_IN_ROCK;
1161         --game.tally;
1162         drop(CAVITY, game.loc);
1163         rspeak(URN_GENIES);
1164     } else if (obj != LAMP) {
1165         rspeak(PECULIAR_NOTHING);
1166     } else {
1167         speak(actions[verb].message);
1168     }
1169     return GO_CLEAROBJ;
1170 }
1171
1172 static phase_codes_t say(command_t command)
1173 /* Say.  Echo WD2. Magic words override. */
1174 {
1175     if (command.word[1].type == MOTION &&
1176         (command.word[1].id == XYZZY ||
1177          command.word[1].id == PLUGH ||
1178          command.word[1].id == PLOVER)) {
1179         return GO_WORD2;
1180     }
1181     if (command.word[1].type == ACTION && command.word[1].id == PART)
1182         return reservoir();
1183
1184     if (command.word[1].type == ACTION &&
1185         (command.word[1].id == FEE ||
1186          command.word[1].id == FIE ||
1187          command.word[1].id == FOE ||
1188          command.word[1].id == FOO ||
1189          command.word[1].id == FUM ||
1190          command.word[1].id == PART)) {
1191         return bigwords(command.word[1].id);
1192     }
1193     sspeak(OKEY_DOKEY, command.word[1].raw);
1194     return GO_CLEAROBJ;
1195 }
1196
1197 static phase_codes_t throw_support(vocab_t spk)
1198 {
1199     rspeak(spk);
1200     drop(AXE, game.loc);
1201     return GO_MOVE;
1202 }
1203
1204 static phase_codes_t throw (command_t command)
1205 /*  Throw.  Same as discard unless axe.  Then same as attack except
1206  *  ignore bird, and if dwarf is present then one might be killed.
1207  *  (Only way to do so!)  Axe also special for dragon, bear, and
1208  *  troll.  Treasures special for troll. */
1209 {
1210     if (!TOTING(command.obj)) {
1211         speak(actions[command.verb].message);
1212         return GO_CLEAROBJ;
1213     }
1214     if (objects[command.obj].is_treasure && AT(TROLL)) {
1215         /*  Snarf a treasure for the troll. */
1216         drop(command.obj, LOC_NOWHERE);
1217         move(TROLL, LOC_NOWHERE);
1218         move(TROLL + NOBJECTS, IS_FREE);
1219         drop(TROLL2, objects[TROLL].plac);
1220         drop(TROLL2 + NOBJECTS, objects[TROLL].fixd);
1221         juggle(CHASM);
1222         rspeak(TROLL_SATISFIED);
1223         return GO_CLEAROBJ;
1224     }
1225     if (command.obj == FOOD && HERE(BEAR)) {
1226         /* But throwing food is another story. */
1227         command.obj = BEAR;
1228         return (feed(command.verb, command.obj));
1229     }
1230     if (command.obj != AXE)
1231         return (discard(command.verb, command.obj));
1232     else {
1233         if (atdwrf(game.loc) <= 0) {
1234             if (AT(DRAGON) && game.prop[DRAGON] == DRAGON_BARS)
1235                 return throw_support(DRAGON_SCALES);
1236             if (AT(TROLL))
1237                 return throw_support(TROLL_RETURNS);
1238             if (AT(OGRE))
1239                 return throw_support(OGRE_DODGE);
1240             if (HERE(BEAR) && game.prop[BEAR] == UNTAMED_BEAR) {
1241                 /* This'll teach him to throw the axe at the bear! */
1242                 drop(AXE, game.loc);
1243                 game.fixed[AXE] = IS_FIXED;
1244                 juggle(BEAR);
1245                 state_change(AXE, AXE_LOST);
1246                 return GO_CLEAROBJ;
1247             }
1248             command.obj = INTRANSITIVE;
1249             return (attack(command));
1250         }
1251
1252         if (randrange(NDWARVES + 1) < game.dflag) {
1253             return throw_support(DWARF_DODGES);
1254         } else {
1255             int i = atdwrf(game.loc);
1256             game.dseen[i] = false;
1257             game.dloc[i] = LOC_NOWHERE;
1258             return throw_support((++game.dkill == 1) ?
1259                                  DWARF_SMOKE :
1260                                  KILLED_DWARF);
1261         }
1262     }
1263 }
1264
1265 static phase_codes_t wake(verb_t verb, obj_t obj)
1266 /* Wake.  Only use is to disturb the dwarves. */
1267 {
1268     if (obj != DWARF ||
1269         !game.closed) {
1270         speak(actions[verb].message);
1271         return GO_CLEAROBJ;
1272     } else {
1273         rspeak(PROD_DWARF);
1274         return GO_DWARFWAKE;
1275     }
1276 }
1277
1278 static phase_codes_t seed(verb_t verb, const char *arg)
1279 /* Set seed */
1280 {
1281     int32_t seed = strtol(arg, NULL, 10);
1282     speak(actions[verb].message, seed);
1283     set_seed(seed);
1284     --game.turns;
1285     return GO_TOP;
1286 }
1287
1288 static phase_codes_t waste(verb_t verb, turn_t turns)
1289 /* Burn turns */
1290 {
1291     game.limit -= turns;
1292     speak(actions[verb].message, (int)game.limit);
1293     return GO_TOP;
1294 }
1295
1296 static phase_codes_t wave(verb_t verb, obj_t obj)
1297 /* Wave.  No effect unless waving rod at fissure or at bird. */
1298 {
1299     if (obj != ROD ||
1300         !TOTING(obj) ||
1301         (!HERE(BIRD) &&
1302          (game.closng ||
1303           !AT(FISSURE)))) {
1304         speak(((!TOTING(obj)) && (obj != ROD ||
1305                                   !TOTING(ROD2))) ?
1306               arbitrary_messages[ARENT_CARRYING] :
1307               actions[verb].message);
1308         return GO_CLEAROBJ;
1309     }
1310
1311     if (game.prop[BIRD] == BIRD_UNCAGED && game.loc == game.place[STEPS] && game.prop[JADE] == STATE_NOTFOUND) {
1312         drop(JADE, game.loc);
1313         game.prop[JADE] = STATE_FOUND;
1314         --game.tally;
1315         rspeak(NECKLACE_FLY);
1316         return GO_CLEAROBJ;
1317     } else {
1318         if (game.closed) {
1319             rspeak((game.prop[BIRD] == BIRD_CAGED) ?
1320                    CAGE_FLY :
1321                    FREE_FLY);
1322             return GO_DWARFWAKE;
1323         }
1324         if (game.closng ||
1325             !AT(FISSURE)) {
1326             rspeak((game.prop[BIRD] == BIRD_CAGED) ?
1327                    CAGE_FLY :
1328                    FREE_FLY);
1329             return GO_CLEAROBJ;
1330         }
1331         if (HERE(BIRD))
1332             rspeak((game.prop[BIRD] == BIRD_CAGED) ?
1333                    CAGE_FLY :
1334                    FREE_FLY);
1335
1336         state_change(FISSURE,
1337                      game.prop[FISSURE] == BRIDGED ? UNBRIDGED : BRIDGED);
1338         return GO_CLEAROBJ;
1339     }
1340 }
1341
1342 phase_codes_t action(command_t command)
1343 /*  Analyse a verb.  Remember what it was, go back for object if second word
1344  *  unless verb is "say", which snarfs arbitrary second word.
1345  */
1346 {
1347     /* Previously, actions that result in a message, but don't do anything
1348      * further were called "specials". Now they're handled here as normal
1349      * actions. If noaction is true, then we spit out the message and return */
1350     if (actions[command.verb].noaction) {
1351         speak(actions[command.verb].message);
1352         return GO_CLEAROBJ;
1353     }
1354
1355     if (command.part == unknown) {
1356         /*  Analyse an object word.  See if the thing is here, whether
1357          *  we've got a verb yet, and so on.  Object must be here
1358          *  unless verb is "find" or "invent(ory)" (and no new verb
1359          *  yet to be analysed).  Water and oil are also funny, since
1360          *  they are never actually dropped at any location, but might
1361          *  be here inside the bottle or urn or as a feature of the
1362          *  location. */
1363         if (HERE(command.obj))
1364             /* FALL THROUGH */;
1365         else if (command.obj == DWARF && atdwrf(game.loc) > 0)
1366             /* FALL THROUGH */;
1367         else if (!game.closed && ((LIQUID() == command.obj && HERE(BOTTLE)) ||
1368                                  command.obj == LIQLOC(game.loc)))
1369             /* FALL THROUGH */;
1370         else if (command.obj == OIL && HERE(URN) && game.prop[URN] != URN_EMPTY) {
1371             command.obj = URN;
1372             /* FALL THROUGH */;
1373         } else if (command.obj == PLANT && AT(PLANT2) && game.prop[PLANT2] != PLANT_THIRSTY) {
1374             command.obj = PLANT2;
1375             /* FALL THROUGH */;
1376         } else if (command.obj == KNIFE && game.knfloc == game.loc) {
1377             game.knfloc = -1;
1378             rspeak(KNIVES_VANISH);
1379             return GO_CLEAROBJ;
1380         } else if (command.obj == ROD && HERE(ROD2)) {
1381             command.obj = ROD2;
1382             /* FALL THROUGH */;
1383         } else if ((command.verb == FIND ||
1384                     command.verb == INVENTORY) && (command.word[1].id == WORD_EMPTY || command.word[1].id == WORD_NOT_FOUND))
1385             /* FALL THROUGH */;
1386         else {
1387             sspeak(NO_SEE, command.word[0].raw);
1388             return GO_CLEAROBJ;
1389         }
1390
1391         if (command.verb != 0)
1392             command.part = transitive;
1393     }
1394
1395     switch (command.part) {
1396     case intransitive:
1397         if (command.word[1].raw[0] != '\0' && command.verb != SAY)
1398             return GO_WORD2;
1399         if (command.verb == SAY)
1400             /* KEYS is not special, anything not NO_OBJECT or INTRANSITIVE
1401              * will do here. We're preventing interpretation as an intransitive
1402              * verb when the word is unknown. */
1403             command.obj = command.word[1].raw[0] != '\0' ? KEYS : NO_OBJECT;
1404         if (command.obj == NO_OBJECT ||
1405             command.obj == INTRANSITIVE) {
1406             /*  Analyse an intransitive verb (ie, no object given yet). */
1407             switch (command.verb) {
1408             case CARRY:
1409                 return vcarry(command.verb, INTRANSITIVE);
1410             case  DROP:
1411                 return GO_UNKNOWN;
1412             case  SAY:
1413                 return GO_UNKNOWN;
1414             case  UNLOCK:
1415                 return lock(command.verb, INTRANSITIVE);
1416             case  NOTHING: {
1417                 rspeak(OK_MAN);
1418                 return (GO_CLEAROBJ);
1419             }
1420             case  LOCK:
1421                 return lock(command.verb, INTRANSITIVE);
1422             case  LIGHT:
1423                 return light(command.verb, INTRANSITIVE);
1424             case  EXTINGUISH:
1425                 return extinguish(command.verb, INTRANSITIVE);
1426             case  WAVE:
1427                 return GO_UNKNOWN;
1428             case  TAME:
1429                 return GO_UNKNOWN;
1430             case GO: {
1431                 speak(actions[command.verb].message);
1432                 return GO_CLEAROBJ;
1433             }
1434             case ATTACK:
1435                 command.obj = INTRANSITIVE;
1436                 return attack(command);
1437             case POUR:
1438                 return pour(command.verb, INTRANSITIVE);
1439             case EAT:
1440                 return eat(command.verb, INTRANSITIVE);
1441             case DRINK:
1442                 return drink(command.verb, INTRANSITIVE);
1443             case RUB:
1444                 return GO_UNKNOWN;
1445             case THROW:
1446                 return GO_UNKNOWN;
1447             case QUIT:
1448                 return quit();
1449             case FIND:
1450                 return GO_UNKNOWN;
1451             case INVENTORY:
1452                 return inven();
1453             case FEED:
1454                 return GO_UNKNOWN;
1455             case FILL:
1456                 return fill(command.verb, INTRANSITIVE);
1457             case BLAST:
1458                 blast();
1459                 return GO_CLEAROBJ;
1460             case SCORE:
1461                 score(scoregame);
1462                 return GO_CLEAROBJ;
1463             case FEE:
1464             case FIE:
1465             case FOE:
1466             case FOO:
1467             case FUM:
1468                 return bigwords(command.word[0].id);
1469             case BRIEF:
1470                 return brief();
1471             case READ:
1472                 command.obj = INTRANSITIVE;
1473                 return read(command);
1474             case BREAK:
1475                 return GO_UNKNOWN;
1476             case WAKE:
1477                 return GO_UNKNOWN;
1478             case SAVE:
1479                 return suspend();
1480             case RESUME:
1481                 return resume();
1482             case FLY:
1483                 return fly(command.verb, INTRANSITIVE);
1484             case LISTEN:
1485                 return listen();
1486             case PART:
1487                 return reservoir();
1488             case SEED:
1489             case WASTE:
1490                 rspeak(NUMERIC_REQUIRED);
1491                 return GO_TOP;
1492             default: // LCOV_EXCL_LINE
1493                 BUG(INTRANSITIVE_ACTION_VERB_EXCEEDS_GOTO_LIST); // LCOV_EXCL_LINE
1494             }
1495         }
1496     /* FALLTHRU */
1497     case transitive:
1498         /*  Analyse a transitive verb. */
1499         switch (command.verb) {
1500         case  CARRY:
1501             return vcarry(command.verb, command.obj);
1502         case  DROP:
1503             return discard(command.verb, command.obj);
1504         case  SAY:
1505             return say(command);
1506         case  UNLOCK:
1507             return lock(command.verb, command.obj);
1508         case  NOTHING: {
1509             rspeak(OK_MAN);
1510             return (GO_CLEAROBJ);
1511         }
1512         case  LOCK:
1513             return lock(command.verb, command.obj);
1514         case LIGHT:
1515             return light(command.verb, command.obj);
1516         case EXTINGUISH:
1517             return extinguish(command.verb, command.obj);
1518         case WAVE:
1519             return wave(command.verb, command.obj);
1520         case TAME: {
1521             speak(actions[command.verb].message);
1522             return GO_CLEAROBJ;
1523         }
1524         case GO: {
1525             speak(actions[command.verb].message);
1526             return GO_CLEAROBJ;
1527         }
1528         case ATTACK:
1529             return attack(command);
1530         case POUR:
1531             return pour(command.verb, command.obj);
1532         case EAT:
1533             return eat(command.verb, command.obj);
1534         case DRINK:
1535             return drink(command.verb, command.obj);
1536         case RUB:
1537             return rub(command.verb, command.obj);
1538         case THROW:
1539             return throw (command);
1540         case QUIT: {
1541             speak(actions[command.verb].message);
1542             return GO_CLEAROBJ;
1543         }
1544         case FIND:
1545             return find(command.verb, command.obj);
1546         case INVENTORY:
1547             return find(command.verb, command.obj);
1548         case FEED:
1549             return feed(command.verb, command.obj);
1550         case FILL:
1551             return fill(command.verb, command.obj);
1552         case BLAST:
1553             blast();
1554             return GO_CLEAROBJ;
1555         case SCORE: {
1556             speak(actions[command.verb].message);
1557             return GO_CLEAROBJ;
1558         }
1559         case FEE:
1560         case FIE:
1561         case FOE:
1562         case FOO:
1563         case FUM: {
1564             speak(actions[command.verb].message);
1565             return GO_CLEAROBJ;
1566         }
1567         case BRIEF: {
1568             speak(actions[command.verb].message);
1569             return GO_CLEAROBJ;
1570         }
1571         case READ:
1572             return read(command);
1573         case BREAK:
1574             return vbreak(command.verb, command.obj);
1575         case WAKE:
1576             return wake(command.verb, command.obj);
1577         case SAVE: {
1578             speak(actions[command.verb].message);
1579             return GO_CLEAROBJ;
1580         }
1581         case RESUME: {
1582             speak(actions[command.verb].message);
1583             return GO_CLEAROBJ;
1584         }
1585         case FLY:
1586             return fly(command.verb, command.obj);
1587         case LISTEN: {
1588             speak(actions[command.verb].message);
1589             return GO_CLEAROBJ;
1590         }
1591         // LCOV_EXCL_START
1592         // This case should never happen - here only as placeholder
1593         case PART:
1594             return reservoir();
1595         // LCOV_EXCL_STOP
1596         case SEED:
1597             return seed(command.verb, command.word[1].raw);
1598         case WASTE:
1599             return waste(command.verb, (turn_t)atol(command.word[1].raw));
1600         default: // LCOV_EXCL_LINE
1601             BUG(TRANSITIVE_ACTION_VERB_EXCEEDS_GOTO_LIST); // LCOV_EXCL_LINE
1602         }
1603     case unknown:
1604         /* Unknown verb, couldn't deduce object - might need hint */
1605         sspeak(WHAT_DO, command.word[0].raw);
1606         return GO_CHECKHINT;
1607     default: // LCOV_EXCL_LINE
1608         BUG(SPEECHPART_NOT_TRANSITIVE_OR_INTRANSITIVE_OR_UNKNOWN); // LCOV_EXCL_LINE
1609     }
1610 }