actions.c

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