actions.c

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