actions.c

   1 #include <stdlib.h>
   2 #include <stdbool.h>
   3 #include "advent.h"
   4 #include "dungeon.h"
   5
   6 static int fill(token_t, token_t);
   7
   8 static void state_change(long obj, long state)
   9 {
  10     game.prop[obj] = state;
  11     pspeak(obj, change, state);
  12 }
  13
  14 static int attack(struct command_t *command)
  15 /*  Attack.  Assume target if unambiguous.  "Throw" also links here.
  16  *  Attackable objects fall into two categories: enemies (snake,
  17  *  dwarf, etc.)  and others (bird, clam, machine).  Ambiguous if 2
  18  *  enemies, or no enemies but 2 others. */
  19 {
  20     vocab_t verb = command->verb;
  21     vocab_t obj = command->obj;
  22     long spk = actions[verb].message;
  23     if (obj == 0 || obj == INTRANSITIVE) {
  24         if (atdwrf(game.loc) > 0)
  25             obj = DWARF;
  26         if (HERE(SNAKE))
  27             obj = obj * NOBJECTS + SNAKE;
  28         if (AT(DRAGON) && game.prop[DRAGON] == 0)
  29             obj = obj * NOBJECTS + DRAGON;
  30         if (AT(TROLL))
  31             obj = obj * NOBJECTS + TROLL;
  32         if (AT(OGRE))
  33             obj = obj * NOBJECTS + OGRE;
  34         if (HERE(BEAR) && game.prop[BEAR] == UNTAMED_BEAR)
  35             obj = obj * NOBJECTS + BEAR;
  36         if (obj > NOBJECTS)
  37             return GO_UNKNOWN;
  38         if (obj == 0) {
  39             /* Can't attack bird or machine by throwing axe. */
  40             if (HERE(BIRD) && verb != THROW)
  41                 obj = BIRD;
  42             if (HERE(VEND) && verb != THROW)
  43                 obj = obj * NOBJECTS + VEND;
  44             /* Clam and oyster both treated as clam for intransitive case;
  45              * no harm done. */
  46             if (HERE(CLAM) || HERE(OYSTER))
  47                 obj = NOBJECTS * obj + CLAM;
  48             if (obj > NOBJECTS)
  49                 return GO_UNKNOWN;
  50         }
  51     }
  52     if (obj == BIRD) {
  53         spk = UNHAPPY_BIRD;
  54         if (game.closed) {
  55             rspeak(spk);
  56             return GO_CLEAROBJ;
  57         }
  58         DESTROY(BIRD);
  59         spk = BIRD_DEAD;
  60     } else if (obj == VEND) {
  61         state_change(VEND,
  62                      game.prop[VEND] == VEND_BLOCKS ? VEND_UNBLOCKS : VEND_BLOCKS);
  63         return GO_CLEAROBJ;
  64     }
  65
  66     if (obj == 0)
  67         spk = NO_TARGET;
  68     if (obj == CLAM || obj == OYSTER)
  69         spk = SHELL_IMPERVIOUS;
  70     if (obj == SNAKE)
  71         spk = SNAKE_WARNING;
  72     if (obj == DWARF)
  73         spk = BARE_HANDS_QUERY;
  74     if (obj == DWARF && game.closed)
  75         return GO_DWARFWAKE;
  76     if (obj == DRAGON)
  77         spk = ALREADY_DEAD;
  78     if (obj == TROLL)
  79         spk = ROCKY_TROLL;
  80     if (obj == OGRE)
  81         spk = OGRE_DODGE;
  82     if (obj == OGRE && atdwrf(game.loc) > 0) {
  83         rspeak(spk);
  84         rspeak(KNIFE_THROWN);
  85         DESTROY(OGRE);
  86         int dwarves = 0;
  87         for (int i = 1; i < PIRATE; i++) {
  88             if (game.dloc[i] == game.loc) {
  89                 ++dwarves;
  90                 game.dloc[i] = LOC_LONGWEST;
  91                 game.dseen[i] = false;
  92             }
  93         }
  94         spk = (dwarves > 1) ? OGRE_PANIC1 : OGRE_PANIC2;
  95     } else if (obj == BEAR)
  96         /* FIXME: Arithmetic on message numbers */
  97         spk = BEAR_HANDS + (game.prop[BEAR] + 1) / 2;
  98     else if (obj == DRAGON && game.prop[DRAGON] == 0) {
  99         /*  Fun stuff for dragon.  If he insists on attacking it, win!
 100          *  Set game.prop to dead, move dragon to central loc (still
 101          *  fixed), move rug there (not fixed), and move him there,
 102          *  too.  Then do a null motion to get new description. */
 103         rspeak(BARE_HANDS_QUERY);
 104         if (silent_yes()) {
 105             // FIXME: setting wd1 is a workaround for broken logic
 106             command->wd1 = token_to_packed("Y");
 107         } else {
 108             // FIXME: setting wd1 is a workaround for broken logic
 109             command->wd1 = token_to_packed("N");
 110             return GO_CHECKFOO;
 111         }
 112         pspeak(DRAGON, look, 3);
 113         game.prop[DRAGON] = 1;
 114         game.prop[RUG] = 0;
 115         int k = (objects[DRAGON].plac + objects[DRAGON].fixd) / 2;
 116         move(DRAGON + NOBJECTS, -1);
 117         move(RUG + NOBJECTS, 0);
 118         move(DRAGON, k);
 119         move(RUG, k);
 120         drop(BLOOD, k);
 121         for (obj = 1; obj <= NOBJECTS; obj++) {
 122             if (game.place[obj] == objects[DRAGON].plac || game.place[obj] == objects[DRAGON].fixd)
 123                 move(obj, k);
 124         }
 125         game.loc = k;
 126         return GO_MOVE;
 127     }
 128
 129     rspeak(spk);
 130     return GO_CLEAROBJ;
 131 }
 132
 133 static int bigwords(token_t foo)
 134 /*  FEE FIE FOE FOO (AND FUM).  Advance to next state if given in proper order.
 135  *  Look up foo in section 3 of vocab to determine which word we've got.  Last
 136  *  word zips the eggs back to the giant room (unless already there). */
 137 {
 138     //int k = vocab(foo, 3);
 139     char word[6];
 140     packed_to_token(foo, word);
 141     int k = (int) get_special_vocab_id(word);
 142     int spk = NOTHING_HAPPENS;
 143     if (game.foobar != 1 - k) {
 144         if (game.foobar != 0 && game.loc == LOC_GIANTROOM)
 145             spk = START_OVER;
 146         rspeak(spk);
 147         return GO_CLEAROBJ;
 148     } else {
 149         game.foobar = k;
 150         if (k != 4) {
 151             rspeak(OK_MAN);
 152             return GO_CLEAROBJ;
 153         }
 154         game.foobar = 0;
 155         if (game.place[EGGS] == objects[EGGS].plac || (TOTING(EGGS) && game.loc == objects[EGGS].plac)) {
 156             rspeak(spk);
 157             return GO_CLEAROBJ;
 158         } else {
 159             /*  Bring back troll if we steal the eggs back from him before
 160              *  crossing. */
 161             if (game.place[EGGS] == LOC_NOWHERE && game.place[TROLL] == LOC_NOWHERE && game.prop[TROLL] == 0)
 162                 game.prop[TROLL] = 1;
 163             k = 2;
 164             if (HERE(EGGS))
 165                 k = 1;
 166             if (game.loc == objects[EGGS].plac)
 167                 k = 0;
 168             move(EGGS, objects[EGGS].plac);
 169             pspeak(EGGS, look, k);
 170             return GO_CLEAROBJ;
 171         }
 172     }
 173 }
 174
 175 static int bivalve(token_t verb, token_t obj)
 176 /* Clam/oyster actions */
 177 {
 178     int spk;
 179     bool is_oyster = (obj == OYSTER);
 180     spk = is_oyster ? OYSTER_OPENS : PEARL_FALLS;
 181     if (TOTING(obj))
 182         spk = is_oyster ? DROP_OYSTER : DROP_CLAM;
 183     if (!TOTING(TRIDENT))
 184         spk = is_oyster ? OYSTER_OPENER : CLAM_OPENER;
 185     if (verb == LOCK)
 186         spk = HUH_MAN;
 187     if (spk == PEARL_FALLS) {
 188         DESTROY(CLAM);
 189         drop(OYSTER, game.loc);
 190         drop(PEARL, LOC_CULDESAC);
 191     }
 192     rspeak(spk);
 193     return GO_CLEAROBJ;
 194 }
 195
 196 static void blast(void)
 197 /*  Blast.  No effect unless you've got dynamite, which is a neat trick! */
 198 {
 199     if (game.prop[ROD2] < 0 || !game.closed)
 200         rspeak(REQUIRES_DYNAMITE);
 201     else {
 202         game.bonus = VICTORY_MESSAGE;
 203         if (game.loc == LOC_NE)
 204             game.bonus = DEFEAT_MESSAGE;
 205         if (HERE(ROD2))
 206             game.bonus = SPLATTER_MESSAGE;
 207         rspeak(game.bonus);
 208         terminate(endgame);
 209     }
 210 }
 211
 212 static int vbreak(token_t verb, token_t obj)
 213 /*  Break.  Only works for mirror in repository and, of course, the vase. */
 214 {
 215     int spk = actions[verb].message;
 216     if (obj == MIRROR)
 217         spk = TOO_FAR;
 218     if (obj == VASE && game.prop[VASE] == 0) {
 219         if (TOTING(VASE))
 220             drop(VASE, game.loc);
 221         game.prop[VASE] = 2;
 222         game.fixed[VASE] = -1;
 223         spk = BREAK_VASE;
 224     } else {
 225         if (obj == MIRROR && game.closed) {
 226             rspeak(BREAK_MIRROR);
 227             return GO_DWARFWAKE;
 228         }
 229     }
 230     rspeak(spk);
 231     return GO_CLEAROBJ;
 232 }
 233
 234 static int brief(void)
 235 /*  Brief.  Intransitive only.  Suppress long descriptions after first time. */
 236 {
 237     game.abbnum = 10000;
 238     game.detail = 3;
 239     rspeak(BRIEF_CONFIRM);
 240     return GO_CLEAROBJ;
 241 }
 242
 243 static int vcarry(token_t verb, token_t obj)
 244 /*  Carry an object.  Special cases for bird and cage (if bird in cage, can't
 245  *  take one without the other).  Liquids also special, since they depend on
 246  *  status of bottle.  Also various side effects, etc. */
 247 {
 248     int spk;
 249     if (obj == INTRANSITIVE) {
 250         /*  Carry, no object given yet.  OK if only one object present. */
 251         if (game.atloc[game.loc] == 0 ||
 252             game.link[game.atloc[game.loc]] != 0 ||
 253             atdwrf(game.loc) > 0)
 254             return GO_UNKNOWN;
 255         obj = game.atloc[game.loc];
 256     }
 257
 258     if (TOTING(obj)) {
 259         rspeak(ALREADY_CARRYING);
 260         return GO_CLEAROBJ;
 261     }
 262     spk = YOU_JOKING;
 263     if (obj == PLANT && game.prop[PLANT] <= 0)
 264         spk = DEEP_ROOTS;
 265     if (obj == BEAR && game.prop[BEAR] == SITTING_BEAR)
 266         spk = BEAR_CHAINED;
 267     if (obj == CHAIN && game.prop[BEAR] != UNTAMED_BEAR)
 268         spk = STILL_LOCKED;
 269     if (obj == URN)
 270         spk = URN_NOBUDGE;
 271     if (obj == CAVITY)
 272         spk = DOUGHNUT_HOLES;
 273     if (obj == BLOOD)
 274         spk = FEW_DROPS;
 275     if (obj == RUG && game.prop[RUG] == 2)
 276         spk = RUG_HOVERS;
 277     if (obj == SIGN)
 278         spk = HAND_PASSTHROUGH;
 279     if (obj == MESSAG) {
 280         rspeak(REMOVE_MESSAGE);
 281         DESTROY(MESSAG);
 282         return GO_CLEAROBJ;
 283     }
 284     if (game.fixed[obj] != 0) {
 285         rspeak(spk);
 286         return GO_CLEAROBJ;
 287     }
 288     if (obj == WATER || obj == OIL) {
 289         if (!HERE(BOTTLE) || LIQUID() != obj) {
 290             if (TOTING(BOTTLE) && game.prop[BOTTLE] == EMPTY_BOTTLE)
 291                 return (fill(verb, BOTTLE));
 292             else {
 293                 if (game.prop[BOTTLE] != EMPTY_BOTTLE)
 294                     spk = BOTTLE_FULL;
 295                 if (!TOTING(BOTTLE))
 296                     spk = NO_CONTAINER;
 297                 rspeak(spk);
 298                 return GO_CLEAROBJ;
 299             }
 300         }
 301         obj = BOTTLE;
 302     }
 303
 304     spk = CARRY_LIMIT;
 305     if (game.holdng >= INVLIMIT) {
 306         rspeak(spk);
 307         return GO_CLEAROBJ;
 308     } else if (obj == BIRD && game.prop[BIRD] != BIRD_CAGED && -1 - game.prop[BIRD] != BIRD_CAGED) {
 309         if (game.prop[BIRD] == BIRD_FOREST_UNCAGED) {
 310             DESTROY(BIRD);
 311             rspeak(BIRD_CRAP);
 312             return GO_CLEAROBJ;
 313         }
 314         if (!TOTING(CAGE))
 315             spk = CANNOT_CARRY;
 316         if (TOTING(ROD))
 317             spk = BIRD_EVADES;
 318         if (spk == CANNOT_CARRY || spk == BIRD_EVADES) {
 319             rspeak(spk);
 320             return GO_CLEAROBJ;
 321         }
 322         game.prop[BIRD] = BIRD_CAGED;
 323     }
 324     if ((obj == BIRD || obj == CAGE) && (game.prop[BIRD] == BIRD_CAGED || -1 - game.prop[BIRD] == 1))
 325         carry(BIRD + CAGE - obj, game.loc);
 326     carry(obj, game.loc);
 327     if (obj == BOTTLE && LIQUID() != 0)
 328         game.place[LIQUID()] = CARRIED;
 329     if (GSTONE(obj) && game.prop[obj] != 0) {
 330         game.prop[obj] = 0;
 331         game.prop[CAVITY] = CAVITY_EMPTY;
 332     }
 333     rspeak(OK_MAN);
 334     return GO_CLEAROBJ;
 335 }
 336
 337 static int chain(token_t verb)
 338 /* Do something to the bear's chain */
 339 {
 340     int spk;
 341     if (verb != LOCK) {
 342         spk = CHAIN_UNLOCKED;
 343         if (game.prop[BEAR] == UNTAMED_BEAR)
 344             spk = BEAR_BLOCKS;
 345         if (game.prop[CHAIN] == 0)
 346             spk = ALREADY_UNLOCKED;
 347         if (spk != CHAIN_UNLOCKED) {
 348             rspeak(spk);
 349             return GO_CLEAROBJ;
 350         }
 351         game.prop[CHAIN] = 0;
 352         game.fixed[CHAIN] = 0;
 353         if (game.prop[BEAR] != BEAR_DEAD)
 354             game.prop[BEAR] = CONTENTED_BEAR;
 355         /* FIXME: Arithmetic on state numbers */
 356         game.fixed[BEAR] = 2 - game.prop[BEAR];
 357     } else {
 358         spk = CHAIN_LOCKED;
 359         if (game.prop[CHAIN] != 0)
 360             spk = ALREADY_LOCKED;
 361         if (game.loc != objects[CHAIN].plac)
 362             spk = NO_LOCKSITE;
 363         if (spk != CHAIN_LOCKED) {
 364             rspeak(spk);
 365             return GO_CLEAROBJ;
 366         }
 367         game.prop[CHAIN] = 2;
 368         if (TOTING(CHAIN))
 369             drop(CHAIN, game.loc);
 370         game.fixed[CHAIN] = -1;
 371     }
 372     rspeak(spk);
 373     return GO_CLEAROBJ;
 374 }
 375
 376 static int discard(token_t verb, token_t obj, bool just_do_it)
 377 /*  Discard object.  "Throw" also comes here for most objects.  Special cases for
 378  *  bird (might attack snake or dragon) and cage (might contain bird) and vase.
 379  *  Drop coins at vending machine for extra batteries. */
 380 {
 381     int spk = actions[verb].message;
 382     if (!just_do_it) {
 383         if (TOTING(ROD2) && obj == ROD && !TOTING(ROD))
 384             obj = ROD2;
 385         if (!TOTING(obj)) {
 386             rspeak(spk);
 387             return GO_CLEAROBJ;
 388         }
 389         if (obj == BIRD && HERE(SNAKE)) {
 390             rspeak(BIRD_ATTACKS);
 391             if (game.closed)
 392                 return GO_DWARFWAKE;
 393             DESTROY(SNAKE);
 394             /* Set game.prop for use by travel options */
 395             game.prop[SNAKE] = SNAKE_CHASED;
 396
 397         } else if ((GSTONE(obj) && AT(CAVITY) && game.prop[CAVITY] != CAVITY_FULL)) {
 398             rspeak(GEM_FITS);
 399             game.prop[obj] = 1;
 400             game.prop[CAVITY] = CAVITY_FULL;
 401             if (HERE(RUG) && ((obj == EMERALD && game.prop[RUG] != 2) || (obj == RUBY &&
 402                               game.prop[RUG] == 2))) {
 403                 spk = RUG_RISES;
 404                 if (TOTING(RUG))
 405                     spk = RUG_WIGGLES;
 406                 if (obj == RUBY)
 407                     spk = RUG_SETTLES;
 408                 rspeak(spk);
 409                 if (spk != RUG_WIGGLES) {
 410                     int k = 2 - game.prop[RUG];
 411                     game.prop[RUG] = k;
 412                     if (k == 2)
 413                         k = objects[SAPPH].plac;
 414                     move(RUG + NOBJECTS, k);
 415                 }
 416             }
 417         } else if (obj == COINS && HERE(VEND)) {
 418             DESTROY(COINS);
 419             drop(BATTERY, game.loc);
 420             pspeak(BATTERY, look, FRESH_BATTERIES);
 421             return GO_CLEAROBJ;
 422         } else if (obj == BIRD && AT(DRAGON) && game.prop[DRAGON] == 0) {
 423             rspeak(BIRD_BURNT);
 424             DESTROY(BIRD);
 425             return GO_CLEAROBJ;
 426         } else if (obj == BEAR && AT(TROLL)) {
 427             rspeak(TROLL_SCAMPERS);
 428             move(TROLL, 0);
 429             move(TROLL + NOBJECTS, 0);
 430             move(TROLL2, objects[TROLL].plac);
 431             move(TROLL2 + NOBJECTS, objects[TROLL].fixd);
 432             juggle(CHASM);
 433             game.prop[TROLL] = 2;
 434         } else if (obj != VASE || game.loc == objects[PILLOW].plac) {
 435             rspeak(OK_MAN);
 436         } else {
 437             game.prop[VASE] = 2;
 438             if (AT(PILLOW))
 439                 game.prop[VASE] = 0;
 440             pspeak(VASE, look, game.prop[VASE] + 1);
 441             if (game.prop[VASE] != 0)
 442                 game.fixed[VASE] = -1;
 443         }
 444     }
 445     int k = LIQUID();
 446     if (k == obj)
 447         obj = BOTTLE;
 448     if (obj == BOTTLE && k != 0)
 449         game.place[k] = LOC_NOWHERE;
 450     if (obj == CAGE && game.prop[BIRD] == BIRD_CAGED)
 451         drop(BIRD, game.loc);
 452     drop(obj, game.loc);
 453     if (obj != BIRD)
 454         return GO_CLEAROBJ;
 455     game.prop[BIRD] = BIRD_UNCAGED;
 456     if (FOREST(game.loc))
 457         game.prop[BIRD] = BIRD_FOREST_UNCAGED;
 458     return GO_CLEAROBJ;
 459 }
 460
 461 static int drink(token_t verb, token_t obj)
 462 /*  Drink.  If no object, assume water and look for it here.  If water is in
 463  *  the bottle, drink that, else must be at a water loc, so drink stream. */
 464 {
 465     int spk = actions[verb].message;
 466     if (obj == 0 && LIQLOC(game.loc) != WATER && (LIQUID() != WATER || !HERE(BOTTLE)))
 467         return GO_UNKNOWN;
 468     if (obj != BLOOD) {
 469         if (obj != 0 && obj != WATER)
 470             spk = RIDICULOUS_ATTEMPT;
 471         if (spk != RIDICULOUS_ATTEMPT && LIQUID() == WATER && HERE(BOTTLE)) {
 472             game.prop[BOTTLE] = EMPTY_BOTTLE;
 473             game.place[WATER] = LOC_NOWHERE;
 474             spk = BOTTLE_EMPTY;
 475         }
 476     } else {
 477         DESTROY(BLOOD);
 478         game.prop[DRAGON] = 2;
 479         game.blooded = true;
 480         spk = HEAD_BUZZES;
 481     }
 482     rspeak(spk);
 483     return GO_CLEAROBJ;
 484 }
 485
 486 static int eat(token_t verb, token_t obj)
 487 /*  Eat.  Intransitive: assume food if present, else ask what.  Transitive: food
 488  *  ok, some things lose appetite, rest are ridiculous. */
 489 {
 490     int spk = actions[verb].message;
 491     if (obj == INTRANSITIVE) {
 492         if (!HERE(FOOD))
 493             return GO_UNKNOWN;
 494         DESTROY(FOOD);
 495         spk = THANKS_DELICIOUS;
 496     } else {
 497         if (obj == FOOD) {
 498             DESTROY(FOOD);
 499             spk = THANKS_DELICIOUS;
 500         }
 501         if (obj == BIRD || obj == SNAKE || obj == CLAM || obj == OYSTER || obj ==
 502             DWARF || obj == DRAGON || obj == TROLL || obj == BEAR || obj ==
 503             OGRE)
 504             spk = LOST_APPETITE;
 505     }
 506     rspeak(spk);
 507     return GO_CLEAROBJ;
 508 }
 509
 510 static int extinguish(token_t verb, int obj)
 511 /* Extinguish.  Lamp, urn, dragon/volcano (nice try). */
 512 {
 513     int spk = actions[verb].message;
 514     if (obj == INTRANSITIVE) {
 515         if (HERE(LAMP) && game.prop[LAMP] == LAMP_BRIGHT)
 516             obj = LAMP;
 517         if (HERE(URN) && game.prop[URN] == 2)
 518             obj = obj * NOBJECTS + URN;
 519         if (obj == INTRANSITIVE || obj == 0 || obj > NOBJECTS)
 520             return GO_UNKNOWN;
 521     }
 522
 523     if (obj == URN) {
 524         game.prop[URN] = game.prop[URN] / 2;
 525         spk = URN_DARK;
 526     } else if (obj == LAMP) {
 527         state_change(LAMP, LAMP_DARK);
 528         spk = DARK(game.loc) ? PITCH_DARK : NO_MESSAGE;
 529     } else if (obj == DRAGON || obj == VOLCANO)
 530         spk = BEYOND_POWER;
 531     rspeak(spk);
 532     return GO_CLEAROBJ;
 533 }
 534
 535 static int feed(token_t verb, token_t obj)
 536 /*  Feed.  If bird, no seed.  Snake, dragon, troll: quip.  If dwarf, make him
 537  *  mad.  Bear, special. */
 538 {
 539     int spk = actions[verb].message;
 540     if (obj == BIRD) {
 541         rspeak(BIRD_PINING);
 542         return GO_CLEAROBJ;
 543     } else if (obj == SNAKE || obj == DRAGON || obj == TROLL) {
 544         spk = NOTHING_EDIBLE;
 545         if (obj == DRAGON && game.prop[DRAGON] != 0)
 546             spk = RIDICULOUS_ATTEMPT;
 547         if (obj == TROLL)
 548             spk = TROLL_VICES;
 549         if (obj == SNAKE && !game.closed && HERE(BIRD)) {
 550             DESTROY(BIRD);
 551             spk = BIRD_DEVOURED;
 552         }
 553     } else if (obj == DWARF) {
 554         if (HERE(FOOD)) {
 555             game.dflag += 2;
 556             spk = REALLY_MAD;
 557         }
 558     } else if (obj == BEAR) {
 559         if (game.prop[BEAR] == UNTAMED_BEAR)
 560             spk = NOTHING_EDIBLE;
 561         if (game.prop[BEAR] == BEAR_DEAD)
 562             spk = RIDICULOUS_ATTEMPT;
 563         if (HERE(FOOD)) {
 564             DESTROY(FOOD);
 565             game.prop[BEAR] = SITTING_BEAR;
 566             game.fixed[AXE] = 0;
 567             game.prop[AXE] = 0;
 568             spk = BEAR_TAMED;
 569         }
 570     } else if (obj == OGRE) {
 571         if (HERE(FOOD))
 572             spk = OGRE_FULL;
 573     } else {
 574         spk = AM_GAME;
 575     }
 576     rspeak(spk);
 577     return GO_CLEAROBJ;
 578 }
 579
 580 int fill(token_t verb, token_t obj)
 581 /*  Fill.  Bottle or urn must be empty, and liquid available.  (Vase
 582  *  is nasty.) */
 583 {
 584     int k;
 585     int spk = actions[verb].message;
 586     if (obj == VASE) {
 587         spk = ARENT_CARRYING;
 588         if (LIQLOC(game.loc) == 0)
 589             spk = FILL_INVALID;
 590         if (LIQLOC(game.loc) == 0 || !TOTING(VASE)) {
 591             rspeak(spk);
 592             return GO_CLEAROBJ;
 593         }
 594         rspeak(SHATTER_VASE);
 595         game.prop[VASE] = 2;
 596         game.fixed[VASE] = -1;
 597         return (discard(verb, obj, true));
 598     } else if (obj == URN) {
 599         spk = FULL_URN;
 600         if (game.prop[URN] != 0) {
 601             rspeak(spk);
 602             return GO_CLEAROBJ;
 603         }
 604         spk = FILL_INVALID;
 605         k = LIQUID();
 606         if (k == 0 || !HERE(BOTTLE)) {
 607             rspeak(spk);
 608             return GO_CLEAROBJ;
 609         }
 610         game.place[k] = LOC_NOWHERE;
 611         game.prop[BOTTLE] = EMPTY_BOTTLE;
 612         if (k == OIL)
 613             game.prop[URN] = 1;
 614         spk = WATER_URN + game.prop[URN];
 615         rspeak(spk);
 616         return GO_CLEAROBJ;
 617     } else if (obj != 0 && obj != BOTTLE) {
 618         rspeak(spk);
 619         return GO_CLEAROBJ;
 620     } else if (obj == 0 && !HERE(BOTTLE))
 621         return GO_UNKNOWN;
 622     spk = BOTTLED_WATER;
 623     if (LIQLOC(game.loc) == 0)
 624         spk = NO_LIQUID;
 625     if (HERE(URN) && game.prop[URN] != 0)
 626         spk = URN_NOPOUR;
 627     if (LIQUID() != 0)
 628         spk = BOTTLE_FULL;
 629     if (spk == BOTTLED_WATER) {
 630         /* FIXME: Arithmetic on property values */
 631         game.prop[BOTTLE] = MOD(conditions[game.loc], 4) / 2 * 2;
 632         k = LIQUID();
 633         if (TOTING(BOTTLE))
 634             game.place[k] = CARRIED;
 635         if (k == OIL)
 636             spk = BOTTLED_OIL;
 637     }
 638     rspeak(spk);
 639     return GO_CLEAROBJ;
 640 }
 641
 642 static int find(token_t verb, token_t obj)
 643 /* Find.  Might be carrying it, or it might be here.  Else give caveat. */
 644 {
 645     int spk = actions[verb].message;
 646     if (AT(obj) ||
 647         (LIQUID() == obj && AT(BOTTLE)) ||
 648         obj == LIQLOC(game.loc) ||
 649         (obj == DWARF && atdwrf(game.loc) > 0))
 650         spk = YOU_HAVEIT;
 651     if (game.closed)
 652         spk = NEEDED_NEARBY;
 653     if (TOTING(obj))
 654         spk = ALREADY_CARRYING;
 655     rspeak(spk);
 656     return GO_CLEAROBJ;
 657 }
 658
 659 static int fly(token_t verb, token_t obj)
 660 /* Fly.  Snide remarks unless hovering rug is here. */
 661 {
 662     int spk = actions[verb].message;
 663     if (obj == INTRANSITIVE) {
 664         if (game.prop[RUG] != 2)
 665             spk = RUG_NOTHING2;
 666         if (!HERE(RUG))
 667             spk = FLAP_ARMS;
 668         if (spk == RUG_NOTHING2 || spk == FLAP_ARMS) {
 669             rspeak(spk);
 670             return GO_CLEAROBJ;
 671         }
 672         obj = RUG;
 673     }
 674
 675     if (obj != RUG) {
 676         rspeak(spk);
 677         return GO_CLEAROBJ;
 678     }
 679     spk = RUG_NOTHING1;
 680     if (game.prop[RUG] != 2) {
 681         rspeak(spk);
 682         return GO_CLEAROBJ;
 683     }
 684     game.oldlc2 = game.oldloc;
 685     game.oldloc = game.loc;
 686     game.newloc = game.place[RUG] + game.fixed[RUG] - game.loc;
 687     spk = RUG_GOES;
 688     if (game.prop[SAPPH] >= 0)
 689         spk = RUG_RETURNS;
 690     rspeak(spk);
 691     return GO_TERMINATE;
 692 }
 693
 694 static int inven(void)
 695 /* Inventory. If object, treat same as find.  Else report on current burden. */
 696 {
 697     int spk = NO_CARRY;
 698     for (int i = 1; i <= NOBJECTS; i++) {
 699         if (i == BEAR || !TOTING(i))
 700             continue;
 701         if (spk == NO_CARRY)
 702             rspeak(NOW_HOLDING);
 703         game.blklin = false;
 704         pspeak(i, touch, -1);
 705         game.blklin = true;
 706         spk = NO_MESSAGE;
 707     }
 708     if (TOTING(BEAR))
 709         spk = TAME_BEAR;
 710     rspeak(spk);
 711     return GO_CLEAROBJ;
 712 }
 713
 714 static int light(token_t verb, token_t obj)
 715 /*  Light.  Applicable only to lamp and urn. */
 716 {
 717     int spk = actions[verb].message;
 718     if (obj == INTRANSITIVE) {
 719         if (HERE(LAMP) && game.prop[LAMP] == LAMP_DARK && game.limit >= 0)
 720             obj = LAMP;
 721         if (HERE(URN) && game.prop[URN] == 1)
 722             obj = obj * NOBJECTS + URN;
 723         if (obj == INTRANSITIVE || obj == 0 || obj > NOBJECTS)
 724             return GO_UNKNOWN;
 725     }
 726
 727     if (obj == URN) {
 728         if (game.prop[URN] == 0) {
 729             rspeak(URN_EMPTY);
 730         } else {
 731             game.prop[URN] = 2;
 732             rspeak(URN_LIT);
 733         }
 734         return GO_CLEAROBJ;
 735     } else {
 736         if (obj != LAMP) {
 737             rspeak(spk);
 738             return GO_CLEAROBJ;
 739         }
 740         spk = LAMP_OUT;
 741         if (game.limit < 0) {
 742             rspeak(spk);
 743             return GO_CLEAROBJ;
 744         }
 745         state_change(LAMP, LAMP_BRIGHT);
 746         if (game.wzdark)
 747             return GO_TOP;
 748         else
 749             return GO_CLEAROBJ;
 750     }
 751 }
 752
 753 static int listen(void)
 754 /*  Listen.  Intransitive only.  Print stuff based on objsnd/locsnd. */
 755 {
 756     long k;
 757     int spk = ALL_SILENT;
 758     k = locations[game.loc].sound;
 759     if (k != SILENT) {
 760         rspeak(k);
 761         if (locations[game.loc].loud)
 762             return GO_CLEAROBJ;
 763         else
 764             spk = NO_MESSAGE;
 765     }
 766     for (int i = 1; i <= NOBJECTS; i++) {
 767         if (!HERE(i) || objects[i].sounds[0] == NULL || game.prop[i] < 0)
 768             continue;
 769         int mi =  game.prop[i];
 770         if (i == BIRD)
 771             mi += 3 * game.blooded;
 772         long packed_zzword = token_to_packed(game.zzword);
 773         pspeak(i, hear, mi, packed_zzword);
 774         spk = NO_MESSAGE;
 775         /* FIXME: Magic number, sensitive to bird state logic */
 776         if (i == BIRD && game.prop[i] == 5)
 777             DESTROY(BIRD);
 778     }
 779     rspeak(spk);
 780     return GO_CLEAROBJ;
 781 }
 782
 783 static int lock(token_t verb, token_t obj)
 784 /* Lock, unlock, no object given.  Assume various things if present. */
 785 {
 786     int spk = actions[verb].message;
 787     if (obj == INTRANSITIVE) {
 788         spk = NOTHING_LOCKED;
 789         if (HERE(CLAM))
 790             obj = CLAM;
 791         if (HERE(OYSTER))
 792             obj = OYSTER;
 793         if (AT(DOOR))
 794             obj = DOOR;
 795         if (AT(GRATE))
 796             obj = GRATE;
 797         if (obj != 0 && HERE(CHAIN))
 798             return GO_UNKNOWN;
 799         if (HERE(CHAIN))
 800             obj = CHAIN;
 801         if (obj == 0 || obj == INTRANSITIVE) {
 802             rspeak(spk);
 803             return GO_CLEAROBJ;
 804         }
 805     }
 806
 807     /*  Lock, unlock object.  Special stuff for opening clam/oyster
 808      *  and for chain. */
 809     if (obj == CLAM || obj == OYSTER)
 810         return bivalve(verb, obj);
 811     if (obj == DOOR)
 812         spk = RUSTY_DOOR;
 813     if (obj == DOOR && game.prop[DOOR] == 1)
 814         spk = OK_MAN;
 815     if (obj == CAGE)
 816         spk = NO_LOCK;
 817     if (obj == KEYS)
 818         spk = CANNOT_UNLOCK;
 819     if (obj == GRATE || obj == CHAIN) {
 820         spk = NO_KEYS;
 821         if (HERE(KEYS)) {
 822             if (obj == CHAIN)
 823                 return chain(verb);
 824             if (game.closng) {
 825                 spk = EXIT_CLOSED;
 826                 if (!game.panic)
 827                     game.clock2 = PANICTIME;
 828                 game.panic = true;
 829             } else {
 830                 state_change(GRATE, (verb == LOCK) ? GRATE_CLOSED : GRATE_OPEN);
 831                 return GO_CLEAROBJ;
 832             }
 833         }
 834     }
 835     rspeak(spk);
 836     return GO_CLEAROBJ;
 837 }
 838
 839 static int pour(token_t verb, token_t obj)
 840 /*  Pour.  If no object, or object is bottle, assume contents of bottle.
 841  *  special tests for pouring water or oil on plant or rusty door. */
 842 {
 843     int spk = actions[verb].message;
 844     if (obj == BOTTLE || obj == 0)
 845         obj = LIQUID();
 846     if (obj == 0)
 847         return GO_UNKNOWN;
 848     if (!TOTING(obj)) {
 849         rspeak(spk);
 850         return GO_CLEAROBJ;
 851     }
 852     spk = CANT_POUR;
 853     if (obj != OIL && obj != WATER) {
 854         rspeak(spk);
 855         return GO_CLEAROBJ;
 856     }
 857     if (HERE(URN) && game.prop[URN] == 0)
 858         return fill(verb, URN);
 859     game.prop[BOTTLE] = EMPTY_BOTTLE;
 860     game.place[obj] = LOC_NOWHERE;
 861     spk = GROUND_WET;
 862     if (!(AT(PLANT) || AT(DOOR))) {
 863         rspeak(spk);
 864         return GO_CLEAROBJ;
 865     }
 866     if (!AT(DOOR)) {
 867         spk = SHAKING_LEAVES;
 868         if (obj != WATER) {
 869             rspeak(spk);
 870             return GO_CLEAROBJ;
 871         }
 872         pspeak(PLANT, look, game.prop[PLANT] + 3);
 873         game.prop[PLANT] = MOD(game.prop[PLANT] + 1, 3);
 874         game.prop[PLANT2] = game.prop[PLANT];
 875         return GO_MOVE;
 876     } else {
 877         game.prop[DOOR] = 0;
 878         if (obj == OIL)
 879             game.prop[DOOR] = 1;
 880         spk = RUSTED_HINGES + game.prop[DOOR];
 881         rspeak(spk);
 882         return GO_CLEAROBJ;
 883     }
 884 }
 885
 886 static int quit(void)
 887 /*  Quit.  Intransitive only.  Verify intent and exit if that's what he wants. */
 888 {
 889     if (yes(arbitrary_messages[REALLY_QUIT], arbitrary_messages[OK_MAN], arbitrary_messages[OK_MAN]))
 890         terminate(quitgame);
 891     return GO_CLEAROBJ;
 892 }
 893
 894 static int read(struct command_t command)
 895 /*  Read.  Print stuff based on objtxt.  Oyster (?) is special case. */
 896 {
 897     if (command.obj == INTRANSITIVE) {
 898         command.obj = 0;
 899         for (int i = 1; i <= NOBJECTS; i++) {
 900             if (HERE(i) && objects[i].texts[0] != NULL && game.prop[i] >= 0)
 901                 command.obj = command.obj * NOBJECTS + i;
 902         }
 903         if (command.obj > NOBJECTS || command.obj == 0 || DARK(game.loc))
 904             return GO_UNKNOWN;
 905     }
 906
 907     if (DARK(game.loc)) {
 908         rspeak(NO_SEE, command.wd1, command.wd1x);
 909     } else if (command.obj == OYSTER && !game.clshnt && game.closed) {
 910         game.clshnt = yes(arbitrary_messages[CLUE_QUERY], arbitrary_messages[WAYOUT_CLUE], arbitrary_messages[OK_MAN]);
 911     } else if (objects[command.obj].texts[0] == NULL || game.prop[command.obj] < 0) {
 912         rspeak(actions[command.verb].message);
 913     } else
 914         pspeak(command.obj, study, game.prop[command.obj]);
 915     return GO_CLEAROBJ;
 916 }
 917
 918 static int reservoir(void)
 919 /*  Z'ZZZ (word gets recomputed at startup; different each game). */
 920 {
 921     if (!AT(RESER) && game.loc != game.fixed[RESER] - 1) {
 922         rspeak(NOTHING_HAPPENS);
 923         return GO_CLEAROBJ;
 924     } else {
 925         pspeak(RESER, look, game.prop[RESER] + 1);
 926         game.prop[RESER] = 1 - game.prop[RESER];
 927         if (AT(RESER))
 928             return GO_CLEAROBJ;
 929         else {
 930             game.oldlc2 = game.loc;
 931             game.newloc = 0;
 932             rspeak(NOT_BRIGHT);
 933             return GO_TERMINATE;
 934         }
 935     }
 936 }
 937
 938 static int rub(token_t verb, token_t obj)
 939 /* Rub.  Yields various snide remarks except for lit urn. */
 940 {
 941     int spk = actions[verb].message;
 942     if (obj != LAMP)
 943         spk = PECULIAR_NOTHING;
 944     if (obj == URN && game.prop[URN] == 2) {
 945         DESTROY(URN);
 946         drop(AMBER, game.loc);
 947         game.prop[AMBER] = 1;
 948         --game.tally;
 949         drop(CAVITY, game.loc);
 950         spk = URN_GENIES;
 951     }
 952     rspeak(spk);
 953     return GO_CLEAROBJ;
 954 }
 955
 956 static int say(struct command_t *command)
 957 /* Say.  Echo WD2 (or WD1 if no WD2 (SAY WHAT?, etc.).)  Magic words override. */
 958 {
 959     long a = command->wd1, b = command->wd1x;
 960     if (command->wd2 > 0) {
 961         a = command->wd2;
 962         b = command->wd2x;
 963         command->wd1 = command->wd2;
 964     }
 965     //int wd = vocab(command->wd1, -1);
 966     char word1[6];
 967     packed_to_token(command->wd1, word1);
 968     int wd = (int) get_vocab_id(word1);
 969     /* FIXME: Magic numbers */
 970     if (wd == 62 || wd == 65 || wd == 71 || wd == 2025 || wd == 2034) {
 971         /* FIXME: scribbles on the interpreter's command block */
 972         wordclear(&command->wd2);
 973         return GO_LOOKUP;
 974     }
 975     rspeak(OKEY_DOKEY, a, b);
 976     return GO_CLEAROBJ;
 977 }
 978
 979 static int throw_support(long spk)
 980 {
 981     rspeak(spk);
 982     drop(AXE, game.loc);
 983     return GO_MOVE;
 984 }
 985
 986 static int throw (struct command_t *command)
 987 /*  Throw.  Same as discard unless axe.  Then same as attack except
 988  *  ignore bird, and if dwarf is present then one might be killed.
 989  *  (Only way to do so!)  Axe also special for dragon, bear, and
 990  *  troll.  Treasures special for troll. */
 991 {
 992     int spk = actions[command->verb].message;
 993     if (TOTING(ROD2) && command->obj == ROD && !TOTING(ROD))
 994         command->obj = ROD2;
 995     if (!TOTING(command->obj)) {
 996         rspeak(spk);
 997         return GO_CLEAROBJ;
 998     }
 999     if (objects[command->obj].is_treasure && AT(TROLL)) {
1000         spk = TROLL_SATISFIED;
1001         /*  Snarf a treasure for the troll. */
1002         drop(command->obj, 0);
1003         move(TROLL, 0);
1004         move(TROLL + NOBJECTS, 0);
1005         drop(TROLL2, objects[TROLL].plac);
1006         drop(TROLL2 + NOBJECTS, objects[TROLL].fixd);
1007         juggle(CHASM);
1008         rspeak(spk);
1009         return GO_CLEAROBJ;
1010     }
1011     if (command->obj == FOOD && HERE(BEAR)) {
1012         /* But throwing food is another story. */
1013         command->obj = BEAR;
1014         return (feed(command->verb, command->obj));
1015     }
1016     if (command->obj != AXE)
1017         return (discard(command->verb, command->obj, false));
1018     else {
1019         int i = atdwrf(game.loc);
1020         if (i <= 0) {
1021             if (AT(DRAGON) && game.prop[DRAGON] == 0)
1022                 return throw_support(DRAGON_SCALES);
1023             if (AT(TROLL))
1024                 return throw_support(TROLL_RETURNS);
1025             else if (AT(OGRE))
1026                 return throw_support(OGRE_DODGE);
1027             else if (HERE(BEAR) && game.prop[BEAR] == UNTAMED_BEAR) {
1028                 /* This'll teach him to throw the axe at the bear! */
1029                 drop(AXE, game.loc);
1030                 game.fixed[AXE] = -1;
1031                 game.prop[AXE] = 1;
1032                 juggle(BEAR);
1033                 rspeak(AXE_LOST);
1034                 return GO_CLEAROBJ;
1035             }
1036             command->obj = 0;
1037             return (attack(command));
1038         }
1039
1040         if (randrange(NDWARVES + 1) < game.dflag) {
1041             return throw_support(DWARF_DODGES);
1042         } else {
1043             game.dseen[i] = false;
1044             game.dloc[i] = 0;
1045             return throw_support((++game.dkill == 1)
1046                                  ? DWARF_SMOKE : KILLED_DWARF);
1047         }
1048     }
1049 }
1050
1051 static int wake(token_t verb, token_t obj)
1052 /* Wake.  Only use is to disturb the dwarves. */
1053 {
1054     if (obj != DWARF || !game.closed) {
1055         rspeak(actions[verb].message);
1056         return GO_CLEAROBJ;
1057     } else {
1058         rspeak(PROD_DWARF);
1059         return GO_DWARFWAKE;
1060     }
1061 }
1062
1063 static int wave(token_t verb, token_t obj)
1064 /* Wave.  No effect unless waving rod at fissure or at bird. */
1065 {
1066     int spk = actions[verb].message;
1067     if ((!TOTING(obj)) && (obj != ROD || !TOTING(ROD2)))
1068         spk = ARENT_CARRYING;
1069     if (obj != ROD ||
1070         !TOTING(obj) ||
1071         (!HERE(BIRD) && (game.closng || !AT(FISSURE)))) {
1072         rspeak(spk);
1073         return GO_CLEAROBJ;
1074     }
1075     /* FIXME: Arithemetic on proprty values */
1076     if (HERE(BIRD))
1077         spk = FREE_FLY + MOD(game.prop[BIRD], 2);
1078     if (spk == FREE_FLY && game.loc == game.place[STEPS] && game.prop[JADE] < 0) {
1079         drop(JADE, game.loc);
1080         game.prop[JADE] = 0;
1081         --game.tally;
1082         spk = NECKLACE_FLY;
1083         rspeak(spk);
1084         return GO_CLEAROBJ;
1085     } else {
1086         if (game.closed) {
1087             rspeak(spk);
1088             return GO_DWARFWAKE;
1089         }
1090         if (game.closng || !AT(FISSURE)) {
1091             rspeak(spk);
1092             return GO_CLEAROBJ;
1093         }
1094         if (HERE(BIRD))
1095             rspeak(spk);
1096         game.prop[FISSURE] = 1 - game.prop[FISSURE];
1097         pspeak(FISSURE, look, 2 - game.prop[FISSURE]);
1098         return GO_CLEAROBJ;
1099     }
1100 }
1101
1102 int action(struct command_t *command)
1103 /*  Analyse a verb.  Remember what it was, go back for object if second word
1104  *  unless verb is "say", which snarfs arbitrary second word.
1105  */
1106 {
1107     token_t spk = actions[command->verb].message;
1108
1109     if (command->part == unknown) {
1110         /*  Analyse an object word.  See if the thing is here, whether
1111          *  we've got a verb yet, and so on.  Object must be here
1112          *  unless verb is "find" or "invent(ory)" (and no new verb
1113          *  yet to be analysed).  Water and oil are also funny, since
1114          *  they are never actually dropped at any location, but might
1115          *  be here inside the bottle or urn or as a feature of the
1116          *  location. */
1117         if (HERE(command->obj))
1118             /* FALL THROUGH */;
1119         else if (command->obj == GRATE) {
1120             if (game.loc == LOC_START || game.loc == LOC_VALLEY || game.loc == LOC_SLIT)
1121                 command->obj = DPRSSN;
1122             if (game.loc == LOC_COBBLE || game.loc == LOC_DEBRIS || game.loc == LOC_AWKWARD ||
1123                 game.loc == LOC_BIRD || game.loc == LOC_PITTOP)
1124                 command->obj = ENTRNC;
1125         } else if (command->obj == DWARF && atdwrf(game.loc) > 0)
1126             /* FALL THROUGH */;
1127         else if ((LIQUID() == command->obj && HERE(BOTTLE)) || command->obj == LIQLOC(game.loc))
1128             /* FALL THROUGH */;
1129         else if (command->obj == OIL && HERE(URN) && game.prop[URN] != 0) {
1130             command->obj = URN;
1131             /* FALL THROUGH */;
1132         } else if (command->obj == PLANT && AT(PLANT2) && game.prop[PLANT2] != 0) {
1133             command->obj = PLANT2;
1134             /* FALL THROUGH */;
1135         } else if (command->obj == KNIFE && game.knfloc == game.loc) {
1136             game.knfloc = -1;
1137             spk = KNIVES_VANISH;
1138             rspeak(spk);
1139             return GO_CLEAROBJ;
1140         } else if (command->obj == ROD && HERE(ROD2)) {
1141             command->obj = ROD2;
1142             /* FALL THROUGH */;
1143         } else if ((command->verb == FIND || command->verb == INVENTORY) && command->wd2 <= 0)
1144             /* FALL THROUGH */;
1145         else {
1146             rspeak(NO_SEE, command->wd1, command->wd1x);
1147             return GO_CLEAROBJ;
1148         }
1149
1150         if (command->wd2 > 0)
1151             return GO_WORD2;
1152         if (command->verb != 0)
1153             command->part = transitive;
1154     }
1155
1156     switch (command->part) {
1157     case intransitive:
1158         if (command->wd2 > 0 && command->verb != SAY)
1159             return GO_WORD2;
1160         if (command->verb == SAY)
1161             command->obj = command->wd2;
1162         if (command->obj == 0 || command->obj == INTRANSITIVE) {
1163             /*  Analyse an intransitive verb (ie, no object given yet). */
1164             switch (command->verb) {
1165             case CARRY:
1166                 return vcarry(command->verb, INTRANSITIVE);
1167             case  DROP:
1168                 return GO_UNKNOWN;
1169             case  SAY:
1170                 return GO_UNKNOWN;
1171             case  UNLOCK:
1172                 return lock(command->verb, INTRANSITIVE);
1173             case  NOTHING: {
1174                 rspeak(OK_MAN);
1175                 return (GO_CLEAROBJ);
1176             }
1177             case  LOCK:
1178                 return lock(command->verb, INTRANSITIVE);
1179             case  LIGHT:
1180                 return light(command->verb, INTRANSITIVE);
1181             case  EXTINGUISH:
1182                 return extinguish(command->verb, INTRANSITIVE);
1183             case  WAVE:
1184                 return GO_UNKNOWN;
1185             case  TAME:
1186                 return GO_UNKNOWN;
1187             case GO: {
1188                 rspeak(spk);
1189                 return GO_CLEAROBJ;
1190             }
1191             case ATTACK:
1192                 return attack(command);
1193             case POUR:
1194                 return pour(command->verb, command->obj);
1195             case EAT:
1196                 return eat(command->verb, INTRANSITIVE);
1197             case DRINK:
1198                 return drink(command->verb, command->obj);
1199             case RUB:
1200                 return GO_UNKNOWN;
1201             case THROW:
1202                 return GO_UNKNOWN;
1203             case QUIT:
1204                 return quit();
1205             case FIND:
1206                 return GO_UNKNOWN;
1207             case INVENTORY:
1208                 return inven();
1209             case FEED:
1210                 return GO_UNKNOWN;
1211             case FILL:
1212                 return fill(command->verb, command->obj);
1213             case BLAST:
1214                 blast();
1215                 return GO_CLEAROBJ;
1216             case SCORE:
1217                 score(scoregame);
1218                 return GO_CLEAROBJ;
1219             case GIANTWORDS:
1220                 return bigwords(command->wd1);
1221             case BRIEF:
1222                 return brief();
1223             case READ:
1224                 command->obj = INTRANSITIVE;
1225                 return read(*command);
1226             case BREAK:
1227                 return GO_UNKNOWN;
1228             case WAKE:
1229                 return GO_UNKNOWN;
1230             case SAVE:
1231                 return suspend();
1232             case RESUME:
1233                 return resume();
1234             case FLY:
1235                 return fly(command->verb, INTRANSITIVE);
1236             case LISTEN:
1237                 return listen();
1238             case PART:
1239                 return reservoir();
1240             default:
1241                 BUG(INTRANSITIVE_ACTION_VERB_EXCEEDS_GOTO_LIST); // LCOV_EXCL_LINE
1242             }
1243         }
1244     /* FALLTHRU */
1245     case transitive:
1246         /*  Analyse a transitive verb. */
1247         switch (command->verb) {
1248         case  CARRY:
1249             return vcarry(command->verb, command->obj);
1250         case  DROP:
1251             return discard(command->verb, command->obj, false);
1252         case  SAY:
1253             return say(command);
1254         case  UNLOCK:
1255             return lock(command->verb, command->obj);
1256         case  NOTHING: {
1257             rspeak(OK_MAN);
1258             return (GO_CLEAROBJ);
1259         }
1260         case  LOCK:
1261             return lock(command->verb, command->obj);
1262         case LIGHT:
1263             return light(command->verb, command->obj);
1264         case EXTINGUISH:
1265             return extinguish(command->verb, command->obj);
1266         case WAVE:
1267             return wave(command->verb, command->obj);
1268         case TAME: {
1269             rspeak(spk);
1270             return GO_CLEAROBJ;
1271         }
1272         case GO: {
1273             rspeak(spk);
1274             return GO_CLEAROBJ;
1275         }
1276         case ATTACK:
1277             return attack(command);
1278         case POUR:
1279             return pour(command->verb, command->obj);
1280         case EAT:
1281             return eat(command->verb, command->obj);
1282         case DRINK:
1283             return drink(command->verb, command->obj);
1284         case RUB:
1285             return rub(command->verb, command->obj);
1286         case THROW:
1287             return throw (command);
1288         case QUIT: {
1289             rspeak(spk);
1290             return GO_CLEAROBJ;
1291         }
1292         case FIND:
1293             return find(command->verb, command->obj);
1294         case INVENTORY:
1295             return find(command->verb, command->obj);
1296         case FEED:
1297             return feed(command->verb, command->obj);
1298         case FILL:
1299             return fill(command->verb, command->obj);
1300         case BLAST:
1301             blast();
1302             return GO_CLEAROBJ;
1303         case SCORE: {
1304             rspeak(spk);
1305             return GO_CLEAROBJ;
1306         }
1307         case GIANTWORDS: {
1308             rspeak(spk);
1309             return GO_CLEAROBJ;
1310         }
1311         case BRIEF: {
1312             rspeak(spk);
1313             return GO_CLEAROBJ;
1314         }
1315         case READ:
1316             return read(*command);
1317         case BREAK:
1318             return vbreak(command->verb, command->obj);
1319         case WAKE:
1320             return wake(command->verb, command->obj);
1321         case SAVE: {
1322             rspeak(spk);
1323             return GO_CLEAROBJ;
1324         }
1325         case RESUME: {
1326             rspeak(spk);
1327             return GO_CLEAROBJ;
1328         }
1329         case FLY:
1330             return fly(command->verb, command->obj);
1331         case LISTEN: {
1332             rspeak(spk);
1333             return GO_CLEAROBJ;
1334         }
1335         case PART:
1336             return reservoir();
1337         default:
1338             BUG(TRANSITIVE_ACTION_VERB_EXCEEDS_GOTO_LIST); // LCOV_EXCL_LINE
1339         }
1340     case unknown:
1341         /* Unknown verb, couldn't deduce object - might need hint */
1342         rspeak(WHAT_DO, command->wd1, command->wd1x);
1343         return GO_CHECKHINT;
1344     default:
1345         BUG(SPEECHPART_NOT_TRANSITIVE_OR_INTRANSITIVE_OR_UNKNOWN); // LCOV_EXCL_LINE
1346     }
1347 }