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